diff --git a/Libs/Google.Protobuf/ByteArray.cs b/Libs/Google.Protobuf/ByteArray.cs
new file mode 100644
index 0000000..b945ee1
--- /dev/null
+++ b/Libs/Google.Protobuf/ByteArray.cs
@@ -0,0 +1,79 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Provides a utility routine to copy small arrays much more quickly than Buffer.BlockCopy
+    /// </summary>
+    internal static class ByteArray
+    {
+        /// <summary>
+        /// The threshold above which you should use Buffer.BlockCopy rather than ByteArray.Copy
+        /// </summary>
+        private const int CopyThreshold = 12;
+
+        /// <summary>
+        /// Determines which copy routine to use based on the number of bytes to be copied.
+        /// </summary>
+        internal static void Copy(byte[] src, int srcOffset, byte[] dst, int dstOffset, int count)
+        {
+            if (count > CopyThreshold)
+            {
+                Buffer.BlockCopy(src, srcOffset, dst, dstOffset, count);
+            }
+            else
+            {
+                int stop = srcOffset + count;
+                for (int i = srcOffset; i < stop; i++)
+                {
+                    dst[dstOffset++] = src[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reverses the order of bytes in the array
+        /// </summary>
+        internal static void Reverse(byte[] bytes)
+        {
+            for (int first = 0, last = bytes.Length - 1; first < last; first++, last--)
+            {
+                byte temp = bytes[first];
+                bytes[first] = bytes[last];
+                bytes[last] = temp;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/ByteString.cs b/Libs/Google.Protobuf/ByteString.cs
new file mode 100644
index 0000000..1d2ccbe
--- /dev/null
+++ b/Libs/Google.Protobuf/ByteString.cs
@@ -0,0 +1,434 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+#if !NET35
+using System.Threading;
+using System.Threading.Tasks;
+#endif
+#if NET35
+using LC.Google.Protobuf.Compatibility;
+#endif
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Immutable array of bytes.
+    /// </summary>
+    [SecuritySafeCritical]
+    public sealed class ByteString : IEnumerable<byte>, IEquatable<ByteString>
+    {
+        private static readonly ByteString empty = new ByteString(new byte[0]);
+
+        private readonly ReadOnlyMemory<byte> bytes;
+
+        /// <summary>
+        /// Internal use only. Ensure that the provided memory is not mutated and belongs to this instance.
+        /// </summary>
+        internal static ByteString AttachBytes(ReadOnlyMemory<byte> bytes)
+        {
+            return new ByteString(bytes);
+        }
+
+        /// <summary>
+        /// Internal use only. Ensure that the provided memory is not mutated and belongs to this instance.
+        /// This method encapsulates converting array to memory. Reduces need for SecuritySafeCritical
+        /// in .NET Framework.
+        /// </summary>
+        internal static ByteString AttachBytes(byte[] bytes)
+        {
+            return AttachBytes(bytes.AsMemory());
+        }
+
+        /// <summary>
+        /// Constructs a new ByteString from the given memory. The memory is
+        /// *not* copied, and must not be modified after this constructor is called.
+        /// </summary>
+        private ByteString(ReadOnlyMemory<byte> bytes)
+        {
+            this.bytes = bytes;
+        }
+
+        /// <summary>
+        /// Returns an empty ByteString.
+        /// </summary>
+        public static ByteString Empty
+        {
+            get { return empty; }
+        }
+
+        /// <summary>
+        /// Returns the length of this ByteString in bytes.
+        /// </summary>
+        public int Length
+        {
+            get { return bytes.Length; }
+        }
+
+        /// <summary>
+        /// Returns <c>true</c> if this byte string is empty, <c>false</c> otherwise.
+        /// </summary>
+        public bool IsEmpty
+        {
+            get { return Length == 0; }
+        }
+
+        /// <summary>
+        /// Provides read-only access to the data of this <see cref="ByteString"/>.
+        /// No data is copied so this is the most efficient way of accessing.
+        /// </summary>
+        public ReadOnlySpan<byte> Span
+        {
+            get { return bytes.Span; }
+        }
+
+        /// <summary>
+        /// Provides read-only access to the data of this <see cref="ByteString"/>.
+        /// No data is copied so this is the most efficient way of accessing.
+        /// </summary>
+        public ReadOnlyMemory<byte> Memory
+        {
+            get { return bytes; }
+        }
+
+        /// <summary>
+        /// Converts this <see cref="ByteString"/> into a byte array.
+        /// </summary>
+        /// <remarks>The data is copied - changes to the returned array will not be reflected in this <c>ByteString</c>.</remarks>
+        /// <returns>A byte array with the same data as this <c>ByteString</c>.</returns>
+        public byte[] ToByteArray()
+        {
+            return bytes.ToArray();
+        }
+
+        /// <summary>
+        /// Converts this <see cref="ByteString"/> into a standard base64 representation.
+        /// </summary>
+        /// <returns>A base64 representation of this <c>ByteString</c>.</returns>
+        public string ToBase64()
+        {
+            if (MemoryMarshal.TryGetArray(bytes, out ArraySegment<byte> segment))
+            {
+                // Fast path. ByteString was created with an array, so pass the underlying array.
+                return Convert.ToBase64String(segment.Array, segment.Offset, segment.Count);
+            }
+            else
+            {
+                // Slow path. BytesString is not an array. Convert memory and pass result to ToBase64String.
+                return Convert.ToBase64String(bytes.ToArray());
+            }
+        }
+
+        /// <summary>
+        /// Constructs a <see cref="ByteString" /> from the Base64 Encoded String.
+        /// </summary>
+        public static ByteString FromBase64(string bytes)
+        {
+            // By handling the empty string explicitly, we not only optimize but we fix a
+            // problem on CF 2.0. See issue 61 for details.
+            return bytes == "" ? Empty : new ByteString(Convert.FromBase64String(bytes));
+        }
+
+        /// <summary>
+        /// Constructs a <see cref="ByteString"/> from data in the given stream, synchronously.
+        /// </summary>
+        /// <remarks>If successful, <paramref name="stream"/> will be read completely, from the position
+        /// at the start of the call.</remarks>
+        /// <param name="stream">The stream to copy into a ByteString.</param>
+        /// <returns>A ByteString with content read from the given stream.</returns>
+        public static ByteString FromStream(Stream stream)
+        {
+            ProtoPreconditions.CheckNotNull(stream, nameof(stream));
+            int capacity = stream.CanSeek ? checked((int) (stream.Length - stream.Position)) : 0;
+            var memoryStream = new MemoryStream(capacity);
+            stream.CopyTo(memoryStream);
+#if NETSTANDARD1_1 || NETSTANDARD2_0
+            byte[] bytes = memoryStream.ToArray();
+#else
+            // Avoid an extra copy if we can.
+            byte[] bytes = memoryStream.Length == memoryStream.Capacity ? memoryStream.GetBuffer() : memoryStream.ToArray();
+#endif
+            return AttachBytes(bytes);
+        }
+
+#if !NET35
+        /// <summary>
+        /// Constructs a <see cref="ByteString"/> from data in the given stream, asynchronously.
+        /// </summary>
+        /// <remarks>If successful, <paramref name="stream"/> will be read completely, from the position
+        /// at the start of the call.</remarks>
+        /// <param name="stream">The stream to copy into a ByteString.</param>
+        /// <param name="cancellationToken">The cancellation token to use when reading from the stream, if any.</param>
+        /// <returns>A ByteString with content read from the given stream.</returns>
+        public static Task<ByteString> FromStreamAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            ProtoPreconditions.CheckNotNull(stream, nameof(stream));
+            return ByteStringAsync.FromStreamAsyncCore(stream, cancellationToken);
+        }
+#endif
+
+        /// <summary>
+        /// Constructs a <see cref="ByteString" /> from the given array. The contents
+        /// are copied, so further modifications to the array will not
+        /// be reflected in the returned ByteString.
+        /// This method can also be invoked in <c>ByteString.CopyFrom(0xaa, 0xbb, ...)</c> form
+        /// which is primarily useful for testing.
+        /// </summary>
+        public static ByteString CopyFrom(params byte[] bytes)
+        {
+            return new ByteString((byte[]) bytes.Clone());
+        }
+
+        /// <summary>
+        /// Constructs a <see cref="ByteString" /> from a portion of a byte array.
+        /// </summary>
+        public static ByteString CopyFrom(byte[] bytes, int offset, int count)
+        {
+            byte[] portion = new byte[count];
+            ByteArray.Copy(bytes, offset, portion, 0, count);
+            return new ByteString(portion);
+        }
+
+        /// <summary>
+        /// Constructs a <see cref="ByteString" /> from a read only span. The contents
+        /// are copied, so further modifications to the span will not
+        /// be reflected in the returned <see cref="ByteString" />.
+        /// </summary>
+        public static ByteString CopyFrom(ReadOnlySpan<byte> bytes)
+        {
+            return new ByteString(bytes.ToArray());
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="ByteString" /> by encoding the specified text with
+        /// the given encoding.
+        /// </summary>
+        public static ByteString CopyFrom(string text, Encoding encoding)
+        {
+            return new ByteString(encoding.GetBytes(text));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="ByteString" /> by encoding the specified text in UTF-8.
+        /// </summary>
+        public static ByteString CopyFromUtf8(string text)
+        {
+            return CopyFrom(text, Encoding.UTF8);
+        }
+
+        /// <summary>
+        /// Returns the byte at the given index.
+        /// </summary>
+        public byte this[int index]
+        {
+            get { return bytes.Span[index]; }
+        }
+
+        /// <summary>
+        /// Converts this <see cref="ByteString"/> into a string by applying the given encoding.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be used to convert binary data which was the result of encoding
+        /// text with the given encoding.
+        /// </remarks>
+        /// <param name="encoding">The encoding to use to decode the binary data into text.</param>
+        /// <returns>The result of decoding the binary data with the given decoding.</returns>
+        public string ToString(Encoding encoding)
+        {
+            if (MemoryMarshal.TryGetArray(bytes, out ArraySegment<byte> segment))
+            {
+                // Fast path. ByteString was created with an array.
+                return encoding.GetString(segment.Array, segment.Offset, segment.Count);
+            }
+            else
+            {
+                // Slow path. BytesString is not an array. Convert memory and pass result to GetString.
+                // TODO: Consider using GetString overload that takes a pointer.
+                byte[] array = bytes.ToArray();
+                return encoding.GetString(array, 0, array.Length);
+            }
+        }
+
+        /// <summary>
+        /// Converts this <see cref="ByteString"/> into a string by applying the UTF-8 encoding.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be used to convert binary data which was the result of encoding
+        /// text with UTF-8.
+        /// </remarks>
+        /// <returns>The result of decoding the binary data with the given decoding.</returns>
+        public string ToStringUtf8()
+        {
+            return ToString(Encoding.UTF8);
+        }
+
+        /// <summary>
+        /// Returns an iterator over the bytes in this <see cref="ByteString"/>.
+        /// </summary>
+        /// <returns>An iterator over the bytes in this object.</returns>
+        [SecuritySafeCritical]
+        public IEnumerator<byte> GetEnumerator()
+        {
+            return MemoryMarshal.ToEnumerable(bytes).GetEnumerator();
+        }
+
+        /// <summary>
+        /// Returns an iterator over the bytes in this <see cref="ByteString"/>.
+        /// </summary>
+        /// <returns>An iterator over the bytes in this object.</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// Creates a CodedInputStream from this ByteString's data.
+        /// </summary>
+        public CodedInputStream CreateCodedInput()
+        {
+            // We trust CodedInputStream not to reveal the provided byte array or modify it
+            if (MemoryMarshal.TryGetArray(bytes, out ArraySegment<byte> segment) && segment.Count == bytes.Length)
+            {
+                // Fast path. ByteString was created with a complete array.
+                return new CodedInputStream(segment.Array);
+            }
+            else
+            {
+                // Slow path. BytesString is not an array, or is a slice of an array.
+                // Convert memory and pass result to WriteRawBytes.
+                return new CodedInputStream(bytes.ToArray());
+            }
+        }
+
+        /// <summary>
+        /// Compares two byte strings for equality.
+        /// </summary>
+        /// <param name="lhs">The first byte string to compare.</param>
+        /// <param name="rhs">The second byte string to compare.</param>
+        /// <returns><c>true</c> if the byte strings are equal; false otherwise.</returns>
+        public static bool operator ==(ByteString lhs, ByteString rhs)
+        {
+            if (ReferenceEquals(lhs, rhs))
+            {
+                return true;
+            }
+            if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null))
+            {
+                return false;
+            }
+
+            return lhs.bytes.Span.SequenceEqual(rhs.bytes.Span);
+        }
+
+        /// <summary>
+        /// Compares two byte strings for inequality.
+        /// </summary>
+        /// <param name="lhs">The first byte string to compare.</param>
+        /// <param name="rhs">The second byte string to compare.</param>
+        /// <returns><c>false</c> if the byte strings are equal; true otherwise.</returns>
+        public static bool operator !=(ByteString lhs, ByteString rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        /// <summary>
+        /// Compares this byte string with another object.
+        /// </summary>
+        /// <param name="obj">The object to compare this with.</param>
+        /// <returns><c>true</c> if <paramref name="obj"/> refers to an equal <see cref="ByteString"/>; <c>false</c> otherwise.</returns>
+        [SecuritySafeCritical]
+        public override bool Equals(object obj)
+        {
+            return this == (obj as ByteString);
+        }
+
+        /// <summary>
+        /// Returns a hash code for this object. Two equal byte strings
+        /// will return the same hash code.
+        /// </summary>
+        /// <returns>A hash code for this object.</returns>
+        [SecuritySafeCritical]
+        public override int GetHashCode()
+        {
+            ReadOnlySpan<byte> b = bytes.Span;
+
+            int ret = 23;
+            for (int i = 0; i < b.Length; i++)
+            {
+                ret = (ret * 31) + b[i];
+            }
+            return ret;
+        }
+
+        /// <summary>
+        /// Compares this byte string with another.
+        /// </summary>
+        /// <param name="other">The <see cref="ByteString"/> to compare this with.</param>
+        /// <returns><c>true</c> if <paramref name="other"/> refers to an equal byte string; <c>false</c> otherwise.</returns>
+        public bool Equals(ByteString other)
+        {
+            return this == other;
+        }
+
+        /// <summary>
+        /// Copies the entire byte array to the destination array provided at the offset specified.
+        /// </summary>
+        public void CopyTo(byte[] array, int position)
+        {
+            bytes.CopyTo(array.AsMemory(position));
+        }
+
+        /// <summary>
+        /// Writes the entire byte array to the provided stream
+        /// </summary>
+        public void WriteTo(Stream outputStream)
+        {
+            if (MemoryMarshal.TryGetArray(bytes, out ArraySegment<byte> segment))
+            {
+                // Fast path. ByteString was created with an array, so pass the underlying array.
+                outputStream.Write(segment.Array, segment.Offset, segment.Count);
+            }
+            else
+            {
+                // Slow path. BytesString is not an array. Convert memory and pass result to WriteRawBytes.
+                var array = bytes.ToArray();
+                outputStream.Write(array, 0, array.Length);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/ByteStringAsync.cs b/Libs/Google.Protobuf/ByteStringAsync.cs
new file mode 100644
index 0000000..68c4d7f
--- /dev/null
+++ b/Libs/Google.Protobuf/ByteStringAsync.cs
@@ -0,0 +1,64 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// SecuritySafeCritical attribute can not be placed on types with async methods.
+    /// This class has ByteString's async methods so it can be marked with SecuritySafeCritical.
+    /// </summary>
+    internal static class ByteStringAsync
+    {
+#if !NET35
+        internal static async Task<ByteString> FromStreamAsyncCore(Stream stream, CancellationToken cancellationToken)
+        {
+            int capacity = stream.CanSeek ? checked((int)(stream.Length - stream.Position)) : 0;
+            var memoryStream = new MemoryStream(capacity);
+            // We have to specify the buffer size here, as there's no overload accepting the cancellation token
+            // alone. But it's documented to use 81920 by default if not specified.
+            await stream.CopyToAsync(memoryStream, 81920, cancellationToken);
+#if NETSTANDARD1_1
+            byte[] bytes = memoryStream.ToArray();
+#else
+            // Avoid an extra copy if we can.
+            byte[] bytes = memoryStream.Length == memoryStream.Capacity ? memoryStream.GetBuffer() : memoryStream.ToArray();
+#endif
+            return ByteString.AttachBytes(bytes);
+        }
+#endif
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/CodedInputStream.cs b/Libs/Google.Protobuf/CodedInputStream.cs
new file mode 100644
index 0000000..3660c19
--- /dev/null
+++ b/Libs/Google.Protobuf/CodedInputStream.cs
@@ -0,0 +1,699 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Reads and decodes protocol message fields.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This class is generally used by generated code to read appropriate
+    /// primitives from the stream. It effectively encapsulates the lowest
+    /// levels of protocol buffer format.
+    /// </para>
+    /// <para>
+    /// Repeated fields and map fields are not handled by this class; use <see cref="RepeatedField{T}"/>
+    /// and <see cref="MapField{TKey, TValue}"/> to serialize such fields.
+    /// </para>
+    /// </remarks>
+    [SecuritySafeCritical]
+    public sealed class CodedInputStream : IDisposable
+    {
+        /// <summary>
+        /// Whether to leave the underlying stream open when disposing of this stream.
+        /// This is always true when there's no stream.
+        /// </summary>
+        private readonly bool leaveOpen;
+
+        /// <summary>
+        /// Buffer of data read from the stream or provided at construction time.
+        /// </summary>
+        private readonly byte[] buffer;
+
+        /// <summary>
+        /// The stream to read further input from, or null if the byte array buffer was provided
+        /// directly on construction, with no further data available.
+        /// </summary>
+        private readonly Stream input;
+
+        /// <summary>
+        /// The parser state is kept separately so that other parse implementations can reuse the same
+        /// parsing primitives.
+        /// </summary>
+        private ParserInternalState state;
+
+        internal const int DefaultRecursionLimit = 100;
+        internal const int DefaultSizeLimit = Int32.MaxValue;
+        internal const int BufferSize = 4096;
+
+        #region Construction
+        // Note that the checks are performed such that we don't end up checking obviously-valid things
+        // like non-null references for arrays we've just created.
+
+        /// <summary>
+        /// Creates a new CodedInputStream reading data from the given byte array.
+        /// </summary>
+        public CodedInputStream(byte[] buffer) : this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), 0, buffer.Length, true)
+        {            
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="CodedInputStream"/> that reads from the given byte array slice.
+        /// </summary>
+        public CodedInputStream(byte[] buffer, int offset, int length)
+            : this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), offset, offset + length, true)
+        {            
+            if (offset < 0 || offset > buffer.Length)
+            {
+                throw new ArgumentOutOfRangeException("offset", "Offset must be within the buffer");
+            }
+            if (length < 0 || offset + length > buffer.Length)
+            {
+                throw new ArgumentOutOfRangeException("length", "Length must be non-negative and within the buffer");
+            }
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="CodedInputStream"/> reading data from the given stream, which will be disposed
+        /// when the returned object is disposed.
+        /// </summary>
+        /// <param name="input">The stream to read from.</param>
+        public CodedInputStream(Stream input) : this(input, false)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="CodedInputStream"/> reading data from the given stream.
+        /// </summary>
+        /// <param name="input">The stream to read from.</param>
+        /// <param name="leaveOpen"><c>true</c> to leave <paramref name="input"/> open when the returned
+        /// <c cref="CodedInputStream"/> is disposed; <c>false</c> to dispose of the given stream when the
+        /// returned object is disposed.</param>
+        public CodedInputStream(Stream input, bool leaveOpen)
+            : this(ProtoPreconditions.CheckNotNull(input, "input"), new byte[BufferSize], 0, 0, leaveOpen)
+        {
+        }
+        
+        /// <summary>
+        /// Creates a new CodedInputStream reading data from the given
+        /// stream and buffer, using the default limits.
+        /// </summary>
+        internal CodedInputStream(Stream input, byte[] buffer, int bufferPos, int bufferSize, bool leaveOpen)
+        {
+            this.input = input;
+            this.buffer = buffer;
+            this.state.bufferPos = bufferPos;
+            this.state.bufferSize = bufferSize;
+            this.state.sizeLimit = DefaultSizeLimit;
+            this.state.recursionLimit = DefaultRecursionLimit;
+            SegmentedBufferHelper.Initialize(this, out this.state.segmentedBufferHelper);
+            this.leaveOpen = leaveOpen;
+
+            this.state.currentLimit = int.MaxValue;
+        }
+
+        /// <summary>
+        /// Creates a new CodedInputStream reading data from the given
+        /// stream and buffer, using the specified limits.
+        /// </summary>
+        /// <remarks>
+        /// This chains to the version with the default limits instead of vice versa to avoid
+        /// having to check that the default values are valid every time.
+        /// </remarks>
+        internal CodedInputStream(Stream input, byte[] buffer, int bufferPos, int bufferSize, int sizeLimit, int recursionLimit, bool leaveOpen)
+            : this(input, buffer, bufferPos, bufferSize, leaveOpen)
+        {
+            if (sizeLimit <= 0)
+            {
+                throw new ArgumentOutOfRangeException("sizeLimit", "Size limit must be positive");
+            }
+            if (recursionLimit <= 0)
+            {
+                throw new ArgumentOutOfRangeException("recursionLimit!", "Recursion limit must be positive");
+            }
+            this.state.sizeLimit = sizeLimit;
+            this.state.recursionLimit = recursionLimit;
+        }
+        #endregion
+
+        /// <summary>
+        /// Creates a <see cref="CodedInputStream"/> with the specified size and recursion limits, reading
+        /// from an input stream.
+        /// </summary>
+        /// <remarks>
+        /// This method exists separately from the constructor to reduce the number of constructor overloads.
+        /// It is likely to be used considerably less frequently than the constructors, as the default limits
+        /// are suitable for most use cases.
+        /// </remarks>
+        /// <param name="input">The input stream to read from</param>
+        /// <param name="sizeLimit">The total limit of data to read from the stream.</param>
+        /// <param name="recursionLimit">The maximum recursion depth to allow while reading.</param>
+        /// <returns>A <c>CodedInputStream</c> reading from <paramref name="input"/> with the specified size
+        /// and recursion limits.</returns>
+        public static CodedInputStream CreateWithLimits(Stream input, int sizeLimit, int recursionLimit)
+        {
+            // Note: we may want an overload accepting leaveOpen
+            return new CodedInputStream(input, new byte[BufferSize], 0, 0, sizeLimit, recursionLimit, false);
+        }
+
+        /// <summary>
+        /// Returns the current position in the input stream, or the position in the input buffer
+        /// </summary>
+        public long Position 
+        {
+            get
+            {
+                if (input != null)
+                {
+                    return input.Position - ((state.bufferSize + state.bufferSizeAfterLimit) - state.bufferPos);
+                }
+                return state.bufferPos;
+            }
+        }
+
+        /// <summary>
+        /// Returns the last tag read, or 0 if no tags have been read or we've read beyond
+        /// the end of the stream.
+        /// </summary>
+        internal uint LastTag { get { return state.lastTag; } }
+
+        /// <summary>
+        /// Returns the size limit for this stream.
+        /// </summary>
+        /// <remarks>
+        /// This limit is applied when reading from the underlying stream, as a sanity check. It is
+        /// not applied when reading from a byte array data source without an underlying stream.
+        /// The default value is Int32.MaxValue.
+        /// </remarks>
+        /// <value>
+        /// The size limit.
+        /// </value>
+        public int SizeLimit { get { return state.sizeLimit; } }
+
+        /// <summary>
+        /// Returns the recursion limit for this stream. This limit is applied whilst reading messages,
+        /// to avoid maliciously-recursive data.
+        /// </summary>
+        /// <remarks>
+        /// The default limit is 100.
+        /// </remarks>
+        /// <value>
+        /// The recursion limit for this stream.
+        /// </value>
+        public int RecursionLimit { get { return state.recursionLimit; } }
+
+        /// <summary>
+        /// Internal-only property; when set to true, unknown fields will be discarded while parsing.
+        /// </summary>
+        internal bool DiscardUnknownFields
+        {
+            get { return state.DiscardUnknownFields; }
+            set { state.DiscardUnknownFields = value; }
+        }
+
+        /// <summary>
+        /// Internal-only property; provides extension identifiers to compatible messages while parsing.
+        /// </summary>
+        internal ExtensionRegistry ExtensionRegistry
+        {
+            get { return state.ExtensionRegistry; }
+            set { state.ExtensionRegistry = value; }
+        }
+
+        internal byte[] InternalBuffer => buffer;
+
+        internal Stream InternalInputStream => input;
+
+        internal ref ParserInternalState InternalState => ref state;
+
+        /// <summary>
+        /// Disposes of this instance, potentially closing any underlying stream.
+        /// </summary>
+        /// <remarks>
+        /// As there is no flushing to perform here, disposing of a <see cref="CodedInputStream"/> which
+        /// was constructed with the <c>leaveOpen</c> option parameter set to <c>true</c> (or one which
+        /// was constructed to read from a byte array) has no effect.
+        /// </remarks>
+        public void Dispose()
+        {
+            if (!leaveOpen)
+            {
+                input.Dispose();
+            }
+        }
+
+        #region Validation
+        /// <summary>
+        /// Verifies that the last call to ReadTag() returned tag 0 - in other words,
+        /// we've reached the end of the stream when we expected to.
+        /// </summary>
+        /// <exception cref="InvalidProtocolBufferException">The 
+        /// tag read was not the one specified</exception>
+        internal void CheckReadEndOfStreamTag()
+        {
+            ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref state);
+        }
+        #endregion
+
+        #region Reading of tags etc
+
+        /// <summary>
+        /// Peeks at the next field tag. This is like calling <see cref="ReadTag"/>, but the
+        /// tag is not consumed. (So a subsequent call to <see cref="ReadTag"/> will return the
+        /// same value.)
+        /// </summary>
+        public uint PeekTag()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.PeekTag(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads a field tag, returning the tag of 0 for "end of stream".
+        /// </summary>
+        /// <remarks>
+        /// If this method returns 0, it doesn't necessarily mean the end of all
+        /// the data in this CodedInputStream; it may be the end of the logical stream
+        /// for an embedded message, for example.
+        /// </remarks>
+        /// <returns>The next field tag, or 0 for end of stream. (0 is never a valid tag.)</returns>
+        public uint ReadTag()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseTag(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Skips the data for the field with the tag we've just read.
+        /// This should be called directly after <see cref="ReadTag"/>, when
+        /// the caller wishes to skip an unknown field.
+        /// </summary>
+        /// <remarks>
+        /// This method throws <see cref="InvalidProtocolBufferException"/> if the last-read tag was an end-group tag.
+        /// If a caller wishes to skip a group, they should skip the whole group, by calling this method after reading the
+        /// start-group tag. This behavior allows callers to call this method on any field they don't understand, correctly
+        /// resulting in an error if an end-group tag has not been paired with an earlier start-group tag.
+        /// </remarks>
+        /// <exception cref="InvalidProtocolBufferException">The last tag was an end-group tag</exception>
+        /// <exception cref="InvalidOperationException">The last read operation read to the end of the logical stream</exception>
+        public void SkipLastField()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            ParsingPrimitivesMessages.SkipLastField(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Skip a group.
+        /// </summary>
+        internal void SkipGroup(uint startGroupTag)
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            ParsingPrimitivesMessages.SkipGroup(ref span, ref state, startGroupTag);
+        }
+
+        /// <summary>
+        /// Reads a double field from the stream.
+        /// </summary>
+        public double ReadDouble()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseDouble(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads a float field from the stream.
+        /// </summary>
+        public float ReadFloat()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseFloat(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads a uint64 field from the stream.
+        /// </summary>
+        public ulong ReadUInt64()
+        {
+            return ReadRawVarint64();
+        }
+
+        /// <summary>
+        /// Reads an int64 field from the stream.
+        /// </summary>
+        public long ReadInt64()
+        {
+            return (long) ReadRawVarint64();
+        }
+
+        /// <summary>
+        /// Reads an int32 field from the stream.
+        /// </summary>
+        public int ReadInt32()
+        {
+            return (int) ReadRawVarint32();
+        }
+
+        /// <summary>
+        /// Reads a fixed64 field from the stream.
+        /// </summary>
+        public ulong ReadFixed64()
+        {
+            return ReadRawLittleEndian64();
+        }
+
+        /// <summary>
+        /// Reads a fixed32 field from the stream.
+        /// </summary>
+        public uint ReadFixed32()
+        {
+            return ReadRawLittleEndian32();
+        }
+
+        /// <summary>
+        /// Reads a bool field from the stream.
+        /// </summary>
+        public bool ReadBool()
+        {
+            return ReadRawVarint64() != 0;
+        }
+
+        /// <summary>
+        /// Reads a string field from the stream.
+        /// </summary>
+        public string ReadString()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ReadString(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads an embedded message field value from the stream.
+        /// </summary>
+        public void ReadMessage(IMessage builder)
+        {
+            // TODO(jtattermusch): if the message doesn't implement IBufferMessage (and thus does not provide the InternalMergeFrom method),
+            // what we're doing here works fine, but could be more efficient.
+            // What happends is that we first initialize a ParseContext from the current coded input stream only to parse the length of the message, at which point
+            // we will need to switch back again to CodedInputStream-based parsing (which involves copying and storing the state) to be able to
+            // invoke the legacy MergeFrom(CodedInputStream) method.
+            // For now, this inefficiency is fine, considering this is only a backward-compatibility scenario (and regenerating the code fixes it).
+            var span = new ReadOnlySpan<byte>(buffer);
+            ParseContext.Initialize(ref span, ref state, out ParseContext ctx);
+            try
+            {
+                ParsingPrimitivesMessages.ReadMessage(ref ctx, builder);
+            }
+            finally
+            {
+                ctx.CopyStateTo(this);
+            }
+        }
+
+        /// <summary>
+        /// Reads an embedded group field from the stream.
+        /// </summary>
+        public void ReadGroup(IMessage builder)
+        {
+            ParseContext.Initialize(this, out ParseContext ctx);
+            try
+            {
+                ParsingPrimitivesMessages.ReadGroup(ref ctx, builder);
+            }
+            finally
+            {
+                ctx.CopyStateTo(this);
+            }
+        }
+
+        /// <summary>
+        /// Reads a bytes field value from the stream.
+        /// </summary>   
+        public ByteString ReadBytes()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ReadBytes(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads a uint32 field value from the stream.
+        /// </summary>   
+        public uint ReadUInt32()
+        {
+            return ReadRawVarint32();
+        }
+
+        /// <summary>
+        /// Reads an enum field value from the stream.
+        /// </summary>   
+        public int ReadEnum()
+        {
+            // Currently just a pass-through, but it's nice to separate it logically from WriteInt32.
+            return (int) ReadRawVarint32();
+        }
+
+        /// <summary>
+        /// Reads an sfixed32 field value from the stream.
+        /// </summary>   
+        public int ReadSFixed32()
+        {
+            return (int) ReadRawLittleEndian32();
+        }
+
+        /// <summary>
+        /// Reads an sfixed64 field value from the stream.
+        /// </summary>   
+        public long ReadSFixed64()
+        {
+            return (long) ReadRawLittleEndian64();
+        }
+
+        /// <summary>
+        /// Reads an sint32 field value from the stream.
+        /// </summary>   
+        public int ReadSInt32()
+        {
+            return ParsingPrimitives.DecodeZigZag32(ReadRawVarint32());
+        }
+
+        /// <summary>
+        /// Reads an sint64 field value from the stream.
+        /// </summary>   
+        public long ReadSInt64()
+        {
+            return ParsingPrimitives.DecodeZigZag64(ReadRawVarint64());
+        }
+
+        /// <summary>
+        /// Reads a length for length-delimited data.
+        /// </summary>
+        /// <remarks>
+        /// This is internally just reading a varint, but this method exists
+        /// to make the calling code clearer.
+        /// </remarks>
+        public int ReadLength()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseLength(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Peeks at the next tag in the stream. If it matches <paramref name="tag"/>,
+        /// the tag is consumed and the method returns <c>true</c>; otherwise, the
+        /// stream is left in the original position and the method returns <c>false</c>.
+        /// </summary>
+        public bool MaybeConsumeTag(uint tag)
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.MaybeConsumeTag(ref span, ref state, tag);
+        }
+
+#endregion
+
+        #region Underlying reading primitives
+
+        /// <summary>
+        /// Reads a raw Varint from the stream.  If larger than 32 bits, discard the upper bits.
+        /// This method is optimised for the case where we've got lots of data in the buffer.
+        /// That means we can check the size just once, then just read directly from the buffer
+        /// without constant rechecking of the buffer length.
+        /// </summary>
+        internal uint ReadRawVarint32()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseRawVarint32(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads a varint from the input one byte at a time, so that it does not
+        /// read any bytes after the end of the varint. If you simply wrapped the
+        /// stream in a CodedInputStream and used ReadRawVarint32(Stream)
+        /// then you would probably end up reading past the end of the varint since
+        /// CodedInputStream buffers its input.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        internal static uint ReadRawVarint32(Stream input)
+        {
+            return ParsingPrimitives.ReadRawVarint32(input);
+        }
+
+        /// <summary>
+        /// Reads a raw varint from the stream.
+        /// </summary>
+        internal ulong ReadRawVarint64()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseRawVarint64(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads a 32-bit little-endian integer from the stream.
+        /// </summary>
+        internal uint ReadRawLittleEndian32()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseRawLittleEndian32(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Reads a 64-bit little-endian integer from the stream.
+        /// </summary>
+        internal ulong ReadRawLittleEndian64()
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ParseRawLittleEndian64(ref span, ref state);
+        }
+        #endregion
+
+        #region Internal reading and buffer management
+
+        /// <summary>
+        /// Sets currentLimit to (current position) + byteLimit. This is called
+        /// when descending into a length-delimited embedded message. The previous
+        /// limit is returned.
+        /// </summary>
+        /// <returns>The old limit.</returns>
+        internal int PushLimit(int byteLimit)
+        {
+            return SegmentedBufferHelper.PushLimit(ref state, byteLimit);
+        }
+
+        /// <summary>
+        /// Discards the current limit, returning the previous limit.
+        /// </summary>
+        internal void PopLimit(int oldLimit)
+        {
+            SegmentedBufferHelper.PopLimit(ref state, oldLimit);
+        }
+
+        /// <summary>
+        /// Returns whether or not all the data before the limit has been read.
+        /// </summary>
+        /// <returns></returns>
+        internal bool ReachedLimit
+        {
+            get
+            {
+                return SegmentedBufferHelper.IsReachedLimit(ref state);
+            }
+        }
+
+        /// <summary>
+        /// Returns true if the stream has reached the end of the input. This is the
+        /// case if either the end of the underlying input source has been reached or
+        /// the stream has reached a limit created using PushLimit.
+        /// </summary>
+        public bool IsAtEnd
+        {
+            get
+            {
+                var span = new ReadOnlySpan<byte>(buffer);
+                return SegmentedBufferHelper.IsAtEnd(ref span, ref state);
+            }
+        }
+
+        /// <summary>
+        /// Called when buffer is empty to read more bytes from the
+        /// input.  If <paramref name="mustSucceed"/> is true, RefillBuffer() guarantees that
+        /// either there will be at least one byte in the buffer when it returns
+        /// or it will throw an exception.  If <paramref name="mustSucceed"/> is false,
+        /// RefillBuffer() returns false if no more bytes were available.
+        /// </summary>
+        /// <param name="mustSucceed"></param>
+        /// <returns></returns>
+        private bool RefillBuffer(bool mustSucceed)
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return state.segmentedBufferHelper.RefillBuffer(ref span, ref state, mustSucceed);
+        }
+
+        /// <summary>
+        /// Reads a fixed size of bytes from the input.
+        /// </summary>
+        /// <exception cref="InvalidProtocolBufferException">
+        /// the end of the stream or the current limit was reached
+        /// </exception>
+        internal byte[] ReadRawBytes(int size)
+        {
+            var span = new ReadOnlySpan<byte>(buffer);
+            return ParsingPrimitives.ReadRawBytes(ref span, ref state, size);
+        }
+
+        /// <summary>
+        /// Reads a top-level message or a nested message after the limits for this message have been pushed.
+        /// (parser will proceed until the end of the current limit)
+        /// NOTE: this method needs to be public because it's invoked by the generated code - e.g. msg.MergeFrom(CodedInputStream input) method
+        /// </summary>
+        public void ReadRawMessage(IMessage message)
+        {
+            ParseContext.Initialize(this, out ParseContext ctx);
+            try
+            {
+                ParsingPrimitivesMessages.ReadRawMessage(ref ctx, message);
+            }
+            finally
+            {
+                ctx.CopyStateTo(this);
+            }
+        }
+#endregion
+    }
+}
diff --git a/Libs/Google.Protobuf/CodedOutputStream.ComputeSize.cs b/Libs/Google.Protobuf/CodedOutputStream.ComputeSize.cs
new file mode 100644
index 0000000..f6992be
--- /dev/null
+++ b/Libs/Google.Protobuf/CodedOutputStream.ComputeSize.cs
@@ -0,0 +1,308 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf
+{
+    // This part of CodedOutputStream provides all the static entry points that are used
+    // by generated code and internally to compute the size of messages prior to being
+    // written to an instance of CodedOutputStream.
+    public sealed partial class CodedOutputStream
+    {
+        private const int LittleEndian64Size = 8;
+        private const int LittleEndian32Size = 4;        
+
+        internal const int DoubleSize = LittleEndian64Size;
+        internal const int FloatSize = LittleEndian32Size;
+        internal const int BoolSize = 1;
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// double field, including the tag.
+        /// </summary>
+        public static int ComputeDoubleSize(double value)
+        {
+            return DoubleSize;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// float field, including the tag.
+        /// </summary>
+        public static int ComputeFloatSize(float value)
+        {
+            return FloatSize;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// uint64 field, including the tag.
+        /// </summary>
+        public static int ComputeUInt64Size(ulong value)
+        {
+            return ComputeRawVarint64Size(value);
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode an
+        /// int64 field, including the tag.
+        /// </summary>
+        public static int ComputeInt64Size(long value)
+        {
+            return ComputeRawVarint64Size((ulong) value);
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode an
+        /// int32 field, including the tag.
+        /// </summary>
+        public static int ComputeInt32Size(int value)
+        {
+            if (value >= 0)
+            {
+                return ComputeRawVarint32Size((uint) value);
+            }
+            else
+            {
+                // Must sign-extend.
+                return 10;
+            }
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// fixed64 field, including the tag.
+        /// </summary>
+        public static int ComputeFixed64Size(ulong value)
+        {
+            return LittleEndian64Size;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// fixed32 field, including the tag.
+        /// </summary>
+        public static int ComputeFixed32Size(uint value)
+        {
+            return LittleEndian32Size;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// bool field, including the tag.
+        /// </summary>
+        public static int ComputeBoolSize(bool value)
+        {
+            return BoolSize;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// string field, including the tag.
+        /// </summary>
+        public static int ComputeStringSize(String value)
+        {
+            int byteArraySize = WritingPrimitives.Utf8Encoding.GetByteCount(value);
+            return ComputeLengthSize(byteArraySize) + byteArraySize;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// group field, including the tag.
+        /// </summary>
+        public static int ComputeGroupSize(IMessage value)
+        {
+            return value.CalculateSize();
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode an
+        /// embedded message field, including the tag.
+        /// </summary>
+        public static int ComputeMessageSize(IMessage value)
+        {
+            int size = value.CalculateSize();
+            return ComputeLengthSize(size) + size;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// bytes field, including the tag.
+        /// </summary>
+        public static int ComputeBytesSize(ByteString value)
+        {
+            return ComputeLengthSize(value.Length) + value.Length;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// uint32 field, including the tag.
+        /// </summary>
+        public static int ComputeUInt32Size(uint value)
+        {
+            return ComputeRawVarint32Size(value);
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a
+        /// enum field, including the tag. The caller is responsible for
+        /// converting the enum value to its numeric value.
+        /// </summary>
+        public static int ComputeEnumSize(int value)
+        {
+            // Currently just a pass-through, but it's nice to separate it logically.
+            return ComputeInt32Size(value);
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode an
+        /// sfixed32 field, including the tag.
+        /// </summary>
+        public static int ComputeSFixed32Size(int value)
+        {
+            return LittleEndian32Size;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode an
+        /// sfixed64 field, including the tag.
+        /// </summary>
+        public static int ComputeSFixed64Size(long value)
+        {
+            return LittleEndian64Size;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode an
+        /// sint32 field, including the tag.
+        /// </summary>
+        public static int ComputeSInt32Size(int value)
+        {
+            return ComputeRawVarint32Size(WritingPrimitives.EncodeZigZag32(value));
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode an
+        /// sint64 field, including the tag.
+        /// </summary>
+        public static int ComputeSInt64Size(long value)
+        {
+            return ComputeRawVarint64Size(WritingPrimitives.EncodeZigZag64(value));
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a length,
+        /// as written by <see cref="WriteLength"/>.
+        /// </summary>
+        public static int ComputeLengthSize(int length)
+        {
+            return ComputeRawVarint32Size((uint) length);
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a varint.
+        /// </summary>
+        public static int ComputeRawVarint32Size(uint value)
+        {
+            if ((value & (0xffffffff << 7)) == 0)
+            {
+                return 1;
+            }
+            if ((value & (0xffffffff << 14)) == 0)
+            {
+                return 2;
+            }
+            if ((value & (0xffffffff << 21)) == 0)
+            {
+                return 3;
+            }
+            if ((value & (0xffffffff << 28)) == 0)
+            {
+                return 4;
+            }
+            return 5;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a varint.
+        /// </summary>
+        public static int ComputeRawVarint64Size(ulong value)
+        {
+            if ((value & (0xffffffffffffffffL << 7)) == 0)
+            {
+                return 1;
+            }
+            if ((value & (0xffffffffffffffffL << 14)) == 0)
+            {
+                return 2;
+            }
+            if ((value & (0xffffffffffffffffL << 21)) == 0)
+            {
+                return 3;
+            }
+            if ((value & (0xffffffffffffffffL << 28)) == 0)
+            {
+                return 4;
+            }
+            if ((value & (0xffffffffffffffffL << 35)) == 0)
+            {
+                return 5;
+            }
+            if ((value & (0xffffffffffffffffL << 42)) == 0)
+            {
+                return 6;
+            }
+            if ((value & (0xffffffffffffffffL << 49)) == 0)
+            {
+                return 7;
+            }
+            if ((value & (0xffffffffffffffffL << 56)) == 0)
+            {
+                return 8;
+            }
+            if ((value & (0xffffffffffffffffL << 63)) == 0)
+            {
+                return 9;
+            }
+            return 10;
+        }
+
+        /// <summary>
+        /// Computes the number of bytes that would be needed to encode a tag.
+        /// </summary>
+        public static int ComputeTagSize(int fieldNumber)
+        {
+            return ComputeRawVarint32Size(WireFormat.MakeTag(fieldNumber, 0));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/CodedOutputStream.cs b/Libs/Google.Protobuf/CodedOutputStream.cs
new file mode 100644
index 0000000..e717806
--- /dev/null
+++ b/Libs/Google.Protobuf/CodedOutputStream.cs
@@ -0,0 +1,607 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+using System.IO;
+using System.Security;
+using System.Text;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Encodes and writes protocol message fields.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This class is generally used by generated code to write appropriate
+    /// primitives to the stream. It effectively encapsulates the lowest
+    /// levels of protocol buffer format. Unlike some other implementations,
+    /// this does not include combined "write tag and value" methods. Generated
+    /// code knows the exact byte representations of the tags they're going to write,
+    /// so there's no need to re-encode them each time. Manually-written code calling
+    /// this class should just call one of the <c>WriteTag</c> overloads before each value.
+    /// </para>
+    /// <para>
+    /// Repeated fields and map fields are not handled by this class; use <c>RepeatedField&lt;T&gt;</c>
+    /// and <c>MapField&lt;TKey, TValue&gt;</c> to serialize such fields.
+    /// </para>
+    /// </remarks>
+    [SecuritySafeCritical]
+    public sealed partial class CodedOutputStream : IDisposable
+    {
+        /// <summary>
+        /// The buffer size used by CreateInstance(Stream).
+        /// </summary>
+        public static readonly int DefaultBufferSize = 4096;
+
+        private readonly bool leaveOpen;
+        private readonly byte[] buffer;
+        private WriterInternalState state;
+
+        private readonly Stream output;
+
+        #region Construction
+        /// <summary>
+        /// Creates a new CodedOutputStream that writes directly to the given
+        /// byte array. If more bytes are written than fit in the array,
+        /// OutOfSpaceException will be thrown.
+        /// </summary>
+        public CodedOutputStream(byte[] flatArray) : this(flatArray, 0, flatArray.Length)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new CodedOutputStream that writes directly to the given
+        /// byte array slice. If more bytes are written than fit in the array,
+        /// OutOfSpaceException will be thrown.
+        /// </summary>
+        private CodedOutputStream(byte[] buffer, int offset, int length)
+        {
+            this.output = null;
+            this.buffer = ProtoPreconditions.CheckNotNull(buffer, nameof(buffer));
+            this.state.position = offset;
+            this.state.limit = offset + length;
+            WriteBufferHelper.Initialize(this, out this.state.writeBufferHelper);
+            leaveOpen = true; // Simple way of avoiding trying to dispose of a null reference
+        }
+
+        private CodedOutputStream(Stream output, byte[] buffer, bool leaveOpen)
+        {
+            this.output = ProtoPreconditions.CheckNotNull(output, nameof(output));
+            this.buffer = buffer;
+            this.state.position = 0;
+            this.state.limit = buffer.Length;
+            WriteBufferHelper.Initialize(this, out this.state.writeBufferHelper);
+            this.leaveOpen = leaveOpen;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="CodedOutputStream" /> which write to the given stream, and disposes of that
+        /// stream when the returned <c>CodedOutputStream</c> is disposed.
+        /// </summary>
+        /// <param name="output">The stream to write to. It will be disposed when the returned <c>CodedOutputStream is disposed.</c></param>
+        public CodedOutputStream(Stream output) : this(output, DefaultBufferSize, false)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new CodedOutputStream which write to the given stream and uses
+        /// the specified buffer size.
+        /// </summary>
+        /// <param name="output">The stream to write to. It will be disposed when the returned <c>CodedOutputStream is disposed.</c></param>
+        /// <param name="bufferSize">The size of buffer to use internally.</param>
+        public CodedOutputStream(Stream output, int bufferSize) : this(output, new byte[bufferSize], false)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new CodedOutputStream which write to the given stream.
+        /// </summary>
+        /// <param name="output">The stream to write to.</param>
+        /// <param name="leaveOpen">If <c>true</c>, <paramref name="output"/> is left open when the returned <c>CodedOutputStream</c> is disposed;
+        /// if <c>false</c>, the provided stream is disposed as well.</param>
+        public CodedOutputStream(Stream output, bool leaveOpen) : this(output, DefaultBufferSize, leaveOpen)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new CodedOutputStream which write to the given stream and uses
+        /// the specified buffer size.
+        /// </summary>
+        /// <param name="output">The stream to write to.</param>
+        /// <param name="bufferSize">The size of buffer to use internally.</param>
+        /// <param name="leaveOpen">If <c>true</c>, <paramref name="output"/> is left open when the returned <c>CodedOutputStream</c> is disposed;
+        /// if <c>false</c>, the provided stream is disposed as well.</param>
+        public CodedOutputStream(Stream output, int bufferSize, bool leaveOpen) : this(output, new byte[bufferSize], leaveOpen)
+        {
+        }
+        #endregion
+
+        /// <summary>
+        /// Returns the current position in the stream, or the position in the output buffer
+        /// </summary>
+        public long Position
+        {
+            get
+            {
+                if (output != null)
+                {
+                    return output.Position + state.position;
+                }
+                return state.position;
+            }
+        }
+
+        #region Writing of values (not including tags)
+
+        /// <summary>
+        /// Writes a double field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteDouble(double value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteDouble(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a float field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteFloat(float value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteFloat(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a uint64 field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteUInt64(ulong value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteUInt64(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an int64 field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteInt64(long value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteInt64(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an int32 field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteInt32(int value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteInt32(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a fixed64 field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteFixed64(ulong value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteFixed64(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a fixed32 field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteFixed32(uint value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteFixed32(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a bool field value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteBool(bool value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteBool(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a string field value, without a tag, to the stream.
+        /// The data is length-prefixed.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteString(string value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteString(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a message, without a tag, to the stream.
+        /// The data is length-prefixed.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteMessage(IMessage value)
+        {
+            // TODO(jtattermusch): if the message doesn't implement IBufferMessage (and thus does not provide the InternalWriteTo method),
+            // what we're doing here works fine, but could be more efficient.
+            // For now, this inefficiency is fine, considering this is only a backward-compatibility scenario (and regenerating the code fixes it).
+            var span = new Span<byte>(buffer);
+            WriteContext.Initialize(ref span, ref state, out WriteContext ctx);
+            try
+            {
+                WritingPrimitivesMessages.WriteMessage(ref ctx, value);
+            }
+            finally
+            {
+                ctx.CopyStateTo(this);
+            }
+        }
+
+        /// <summary>
+        /// Writes a message, without a tag, to the stream.
+        /// Only the message data is written, without a length-delimiter.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteRawMessage(IMessage value)
+        {
+            // TODO(jtattermusch): if the message doesn't implement IBufferMessage (and thus does not provide the InternalWriteTo method),
+            // what we're doing here works fine, but could be more efficient.
+            // For now, this inefficiency is fine, considering this is only a backward-compatibility scenario (and regenerating the code fixes it).
+            var span = new Span<byte>(buffer);
+            WriteContext.Initialize(ref span, ref state, out WriteContext ctx);
+            try
+            {
+                WritingPrimitivesMessages.WriteRawMessage(ref ctx, value);
+            }
+            finally
+            {
+                ctx.CopyStateTo(this);
+            }
+        }
+
+        /// <summary>
+        /// Writes a group, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteGroup(IMessage value)
+        {
+            var span = new Span<byte>(buffer);
+            WriteContext.Initialize(ref span, ref state, out WriteContext ctx);
+            try
+            {
+                WritingPrimitivesMessages.WriteGroup(ref ctx, value);
+            }
+            finally
+            {
+                ctx.CopyStateTo(this);
+            }
+        }
+
+        /// <summary>
+        /// Write a byte string, without a tag, to the stream.
+        /// The data is length-prefixed.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteBytes(ByteString value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteBytes(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a uint32 value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteUInt32(uint value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteUInt32(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an enum value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteEnum(int value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteEnum(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sfixed32 value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write.</param>
+        public void WriteSFixed32(int value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteSFixed32(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sfixed64 value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteSFixed64(long value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteSFixed64(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sint32 value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteSInt32(int value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteSInt32(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sint64 value, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteSInt64(long value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteSInt64(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a length (in bytes) for length-delimited data.
+        /// </summary>
+        /// <remarks>
+        /// This method simply writes a rawint, but exists for clarity in calling code.
+        /// </remarks>
+        /// <param name="length">Length value, in bytes.</param>
+        public void WriteLength(int length)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteLength(ref span, ref state, length);
+        }
+
+        #endregion
+
+        #region Raw tag writing
+        /// <summary>
+        /// Encodes and writes a tag.
+        /// </summary>
+        /// <param name="fieldNumber">The number of the field to write the tag for</param>
+        /// <param name="type">The wire format type of the tag to write</param>
+        public void WriteTag(int fieldNumber, WireFormat.WireType type)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteTag(ref span, ref state, fieldNumber, type);
+        }
+
+        /// <summary>
+        /// Writes an already-encoded tag.
+        /// </summary>
+        /// <param name="tag">The encoded tag</param>
+        public void WriteTag(uint tag)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteTag(ref span, ref state, tag);
+        }
+
+        /// <summary>
+        /// Writes the given single-byte tag directly to the stream.
+        /// </summary>
+        /// <param name="b1">The encoded tag</param>
+        public void WriteRawTag(byte b1)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawTag(ref span, ref state, b1);
+        }
+
+        /// <summary>
+        /// Writes the given two-byte tag directly to the stream.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2);
+        }
+
+        /// <summary>
+        /// Writes the given three-byte tag directly to the stream.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        /// <param name="b3">The third byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2, byte b3)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3);
+        }
+
+        /// <summary>
+        /// Writes the given four-byte tag directly to the stream.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        /// <param name="b3">The third byte of the encoded tag</param>
+        /// <param name="b4">The fourth byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2, byte b3, byte b4)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3, b4);
+        }
+
+        /// <summary>
+        /// Writes the given five-byte tag directly to the stream.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        /// <param name="b3">The third byte of the encoded tag</param>
+        /// <param name="b4">The fourth byte of the encoded tag</param>
+        /// <param name="b5">The fifth byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3, b4, b5);
+        }
+        #endregion
+
+        #region Underlying writing primitives
+        
+        /// <summary>
+        /// Writes a 32 bit value as a varint. The fast route is taken when
+        /// there's enough buffer space left to whizz through without checking
+        /// for each byte; otherwise, we resort to calling WriteRawByte each time.
+        /// </summary>
+        internal void WriteRawVarint32(uint value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawVarint32(ref span, ref state, value);
+        }
+
+        internal void WriteRawVarint64(ulong value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawVarint64(ref span, ref state, value);
+        }
+
+        internal void WriteRawLittleEndian32(uint value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawLittleEndian32(ref span, ref state, value);
+        }
+
+        internal void WriteRawLittleEndian64(ulong value)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawLittleEndian64(ref span, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes out an array of bytes.
+        /// </summary>
+        internal void WriteRawBytes(byte[] value)
+        {
+            WriteRawBytes(value, 0, value.Length);
+        }
+
+        /// <summary>
+        /// Writes out part of an array of bytes.
+        /// </summary>
+        internal void WriteRawBytes(byte[] value, int offset, int length)
+        {
+            var span = new Span<byte>(buffer);
+            WritingPrimitives.WriteRawBytes(ref span, ref state, value, offset, length);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Indicates that a CodedOutputStream wrapping a flat byte array
+        /// ran out of space.
+        /// </summary>
+        public sealed class OutOfSpaceException : IOException
+        {
+            internal OutOfSpaceException()
+                : base("CodedOutputStream was writing to a flat byte array and ran out of space.")
+            {
+            }
+        }
+
+        /// <summary>
+        /// Flushes any buffered data and optionally closes the underlying stream, if any.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// By default, any underlying stream is closed by this method. To configure this behaviour,
+        /// use a constructor overload with a <c>leaveOpen</c> parameter. If this instance does not
+        /// have an underlying stream, this method does nothing.
+        /// </para>
+        /// <para>
+        /// For the sake of efficiency, calling this method does not prevent future write calls - but
+        /// if a later write ends up writing to a stream which has been disposed, that is likely to
+        /// fail. It is recommend that you not call any other methods after this.
+        /// </para>
+        /// </remarks>
+        public void Dispose()
+        {
+            Flush();
+            if (!leaveOpen)
+            {
+                output.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Flushes any buffered data to the underlying stream (if there is one).
+        /// </summary>
+        public void Flush()
+        {
+            var span = new Span<byte>(buffer);
+            WriteBufferHelper.Flush(ref span, ref state);
+        }
+
+        /// <summary>
+        /// Verifies that SpaceLeft returns zero. It's common to create a byte array
+        /// that is exactly big enough to hold a message, then write to it with
+        /// a CodedOutputStream. Calling CheckNoSpaceLeft after writing verifies that
+        /// the message was actually as big as expected, which can help finding bugs.
+        /// </summary>
+        public void CheckNoSpaceLeft()
+        {
+            WriteBufferHelper.CheckNoSpaceLeft(ref state);
+        }
+
+        /// <summary>
+        /// If writing to a flat array, returns the space left in the array. Otherwise,
+        /// throws an InvalidOperationException.
+        /// </summary>
+        public int SpaceLeft => WriteBufferHelper.GetSpaceLeft(ref state);
+
+        internal byte[] InternalBuffer => buffer;
+
+        internal Stream InternalOutputStream => output;
+
+        internal ref WriterInternalState InternalState => ref state;
+    }
+}
diff --git a/Libs/Google.Protobuf/Collections/Lists.cs b/Libs/Google.Protobuf/Collections/Lists.cs
new file mode 100644
index 0000000..5790294
--- /dev/null
+++ b/Libs/Google.Protobuf/Collections/Lists.cs
@@ -0,0 +1,89 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2017 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace LC.Google.Protobuf.Collections
+{
+    /// <summary>
+    /// Utility to compare if two Lists are the same, and the hash code
+    /// of a List.
+    /// </summary>
+    public static class Lists
+    {
+        /// <summary>
+        /// Checks if two lists are equal.
+        /// </summary>
+        public static bool Equals<T>(List<T> left, List<T> right)
+        {
+            if (left == right)
+            {
+                return true;
+            }
+            if (left == null || right == null)
+            {
+                return false;
+            }
+            if (left.Count != right.Count)
+            {
+                return false;
+            }
+            IEqualityComparer<T> comparer = EqualityComparer<T>.Default;
+            for (int i = 0; i < left.Count; i++)
+            {
+                if (!comparer.Equals(left[i], right[i]))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the list's hash code.
+        /// </summary>
+        public static int GetHashCode<T>(List<T> list)
+        {
+            if (list == null)
+            {
+                return 0;
+            }
+            int hash = 31;
+            foreach (T element in list)
+            {
+                hash = hash * 29 + element.GetHashCode();
+            }
+            return hash;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Collections/MapField.cs b/Libs/Google.Protobuf/Collections/MapField.cs
new file mode 100644
index 0000000..07ada24
--- /dev/null
+++ b/Libs/Google.Protobuf/Collections/MapField.cs
@@ -0,0 +1,762 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Compatibility;
+using LC.Google.Protobuf.Reflection;
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security;
+
+namespace LC.Google.Protobuf.Collections
+{
+    /// <summary>
+    /// Representation of a map field in a Protocol Buffer message.
+    /// </summary>
+    /// <typeparam name="TKey">Key type in the map. Must be a type supported by Protocol Buffer map keys.</typeparam>
+    /// <typeparam name="TValue">Value type in the map. Must be a type supported by Protocol Buffers.</typeparam>
+    /// <remarks>
+    /// <para>
+    /// For string keys, the equality comparison is provided by <see cref="StringComparer.Ordinal" />.
+    /// </para>
+    /// <para>
+    /// Null values are not permitted in the map, either for wrapper types or regular messages.
+    /// If a map is deserialized from a data stream and the value is missing from an entry, a default value
+    /// is created instead. For primitive types, that is the regular default value (0, the empty string and so
+    /// on); for message types, an empty instance of the message is created, as if the map entry contained a 0-length
+    /// encoded value for the field.
+    /// </para>
+    /// <para>
+    /// This implementation does not generally prohibit the use of key/value types which are not
+    /// supported by Protocol Buffers (e.g. using a key type of <code>byte</code>) but nor does it guarantee
+    /// that all operations will work in such cases.
+    /// </para>
+    /// <para>
+    /// The order in which entries are returned when iterating over this object is undefined, and may change
+    /// in future versions.
+    /// </para>
+    /// </remarks>
+    public sealed class MapField<TKey, TValue> : IDeepCloneable<MapField<TKey, TValue>>, IDictionary<TKey, TValue>, IEquatable<MapField<TKey, TValue>>, IDictionary
+#if !NET35
+        , IReadOnlyDictionary<TKey, TValue>
+#endif
+    {
+        private static readonly EqualityComparer<TValue> ValueEqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<TValue>();
+        private static readonly EqualityComparer<TKey> KeyEqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<TKey>();
+
+        // TODO: Don't create the map/list until we have an entry. (Assume many maps will be empty.)
+        private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> map =
+            new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>(KeyEqualityComparer);
+        private readonly LinkedList<KeyValuePair<TKey, TValue>> list = new LinkedList<KeyValuePair<TKey, TValue>>();
+
+        /// <summary>
+        /// Creates a deep clone of this object.
+        /// </summary>
+        /// <returns>
+        /// A deep clone of this object.
+        /// </returns>
+        public MapField<TKey, TValue> Clone()
+        {
+            var clone = new MapField<TKey, TValue>();
+            // Keys are never cloneable. Values might be.
+            if (typeof(IDeepCloneable<TValue>).IsAssignableFrom(typeof(TValue)))
+            {
+                foreach (var pair in list)
+                {
+                    clone.Add(pair.Key, ((IDeepCloneable<TValue>)pair.Value).Clone());
+                }
+            }
+            else
+            {
+                // Nothing is cloneable, so we don't need to worry.
+                clone.Add(this);
+            }
+            return clone;
+        }
+
+        /// <summary>
+        /// Adds the specified key/value pair to the map.
+        /// </summary>
+        /// <remarks>
+        /// This operation fails if the key already exists in the map. To replace an existing entry, use the indexer.
+        /// </remarks>
+        /// <param name="key">The key to add</param>
+        /// <param name="value">The value to add.</param>
+        /// <exception cref="System.ArgumentException">The given key already exists in map.</exception>
+        public void Add(TKey key, TValue value)
+        {
+            // Validation of arguments happens in ContainsKey and the indexer
+            if (ContainsKey(key))
+            {
+                throw new ArgumentException("Key already exists in map", nameof(key));
+            }
+            this[key] = value;
+        }
+
+        /// <summary>
+        /// Determines whether the specified key is present in the map.
+        /// </summary>
+        /// <param name="key">The key to check.</param>
+        /// <returns><c>true</c> if the map contains the given key; <c>false</c> otherwise.</returns>
+        public bool ContainsKey(TKey key)
+        {
+            ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
+            return map.ContainsKey(key);
+        }
+
+        private bool ContainsValue(TValue value) =>
+            list.Any(pair => ValueEqualityComparer.Equals(pair.Value, value));
+
+        /// <summary>
+        /// Removes the entry identified by the given key from the map.
+        /// </summary>
+        /// <param name="key">The key indicating the entry to remove from the map.</param>
+        /// <returns><c>true</c> if the map contained the given key before the entry was removed; <c>false</c> otherwise.</returns>
+        public bool Remove(TKey key)
+        {
+            ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
+            LinkedListNode<KeyValuePair<TKey, TValue>> node;
+            if (map.TryGetValue(key, out node))
+            {
+                map.Remove(key);
+                node.List.Remove(node);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the value associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key whose value to get.</param>
+        /// <param name="value">When this method returns, the value associated with the specified key, if the key is found;
+        /// otherwise, the default value for the type of the <paramref name="value"/> parameter.
+        /// This parameter is passed uninitialized.</param>
+        /// <returns><c>true</c> if the map contains an element with the specified key; otherwise, <c>false</c>.</returns>
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            LinkedListNode<KeyValuePair<TKey, TValue>> node;
+            if (map.TryGetValue(key, out node))
+            {
+                value = node.Value.Value;
+                return true;
+            }
+            else
+            {
+                value = default(TValue);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the value associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key of the value to get or set.</param>
+        /// <exception cref="KeyNotFoundException">The property is retrieved and key does not exist in the collection.</exception>
+        /// <returns>The value associated with the specified key. If the specified key is not found,
+        /// a get operation throws a <see cref="KeyNotFoundException"/>, and a set operation creates a new element with the specified key.</returns>
+        public TValue this[TKey key]
+        {
+            get
+            {
+                ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
+                TValue value;
+                if (TryGetValue(key, out value))
+                {
+                    return value;
+                }
+                throw new KeyNotFoundException();
+            }
+            set
+            {
+                ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
+                // value == null check here is redundant, but avoids boxing.
+                if (value == null)
+                {
+                    ProtoPreconditions.CheckNotNullUnconstrained(value, nameof(value));
+                }
+                LinkedListNode<KeyValuePair<TKey, TValue>> node;
+                var pair = new KeyValuePair<TKey, TValue>(key, value);
+                if (map.TryGetValue(key, out node))
+                {
+                    node.Value = pair;
+                }
+                else
+                {
+                    node = list.AddLast(pair);
+                    map[key] = node;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection containing the keys in the map.
+        /// </summary>
+        public ICollection<TKey> Keys { get { return new MapView<TKey>(this, pair => pair.Key, ContainsKey); } }
+
+        /// <summary>
+        /// Gets a collection containing the values in the map.
+        /// </summary>
+        public ICollection<TValue> Values { get { return new MapView<TValue>(this, pair => pair.Value, ContainsValue); } }
+
+        /// <summary>
+        /// Adds the specified entries to the map. The keys and values are not automatically cloned.
+        /// </summary>
+        /// <param name="entries">The entries to add to the map.</param>
+        public void Add(IDictionary<TKey, TValue> entries)
+        {
+            ProtoPreconditions.CheckNotNull(entries, nameof(entries));
+            foreach (var pair in entries)
+            {
+                Add(pair.Key, pair.Value);
+            }
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>
+        /// An enumerator that can be used to iterate through the collection.
+        /// </returns>
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            return list.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through a collection.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.
+        /// </returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// Adds the specified item to the map.
+        /// </summary>
+        /// <param name="item">The item to add to the map.</param>
+        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
+        {
+            Add(item.Key, item.Value);
+        }
+
+        /// <summary>
+        /// Removes all items from the map.
+        /// </summary>
+        public void Clear()
+        {
+            list.Clear();
+            map.Clear();
+        }
+
+        /// <summary>
+        /// Determines whether map contains an entry equivalent to the given key/value pair.
+        /// </summary>
+        /// <param name="item">The key/value pair to find.</param>
+        /// <returns></returns>
+        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
+        {
+            TValue value;
+            return TryGetValue(item.Key, out value) && ValueEqualityComparer.Equals(item.Value, value);
+        }
+
+        /// <summary>
+        /// Copies the key/value pairs in this map to an array.
+        /// </summary>
+        /// <param name="array">The array to copy the entries into.</param>
+        /// <param name="arrayIndex">The index of the array at which to start copying values.</param>
+        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            list.CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Removes the specified key/value pair from the map.
+        /// </summary>
+        /// <remarks>Both the key and the value must be found for the entry to be removed.</remarks>
+        /// <param name="item">The key/value pair to remove.</param>
+        /// <returns><c>true</c> if the key/value pair was found and removed; <c>false</c> otherwise.</returns>
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
+        {
+            if (item.Key == null)
+            {
+                throw new ArgumentException("Key is null", nameof(item));
+            }
+            LinkedListNode<KeyValuePair<TKey, TValue>> node;
+            if (map.TryGetValue(item.Key, out node) &&
+                EqualityComparer<TValue>.Default.Equals(item.Value, node.Value.Value))
+            {
+                map.Remove(item.Key);
+                node.List.Remove(node);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of elements contained in the map.
+        /// </summary>
+        public int Count { get { return list.Count; } }
+
+        /// <summary>
+        /// Gets a value indicating whether the map is read-only.
+        /// </summary>
+        public bool IsReadOnly { get { return false; } }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="System.Object" />, is equal to this instance.
+        /// </summary>
+        /// <param name="other">The <see cref="System.Object" /> to compare with this instance.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object other)
+        {
+            return Equals(other as MapField<TKey, TValue>);
+        }
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode()
+        {
+            var keyComparer = KeyEqualityComparer;
+            var valueComparer = ValueEqualityComparer;
+            int hash = 0;
+            foreach (var pair in list)
+            {
+                hash ^= keyComparer.GetHashCode(pair.Key) * 31 + valueComparer.GetHashCode(pair.Value);
+            }
+            return hash;
+        }
+
+        /// <summary>
+        /// Compares this map with another for equality.
+        /// </summary>
+        /// <remarks>
+        /// The order of the key/value pairs in the maps is not deemed significant in this comparison.
+        /// </remarks>
+        /// <param name="other">The map to compare this with.</param>
+        /// <returns><c>true</c> if <paramref name="other"/> refers to an equal map; <c>false</c> otherwise.</returns>
+        public bool Equals(MapField<TKey, TValue> other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+            if (other == this)
+            {
+                return true;
+            }
+            if (other.Count != this.Count)
+            {
+                return false;
+            }
+            var valueComparer = ValueEqualityComparer;
+            foreach (var pair in this)
+            {
+                TValue value;
+                if (!other.TryGetValue(pair.Key, out value))
+                {
+                    return false;
+                }
+                if (!valueComparer.Equals(value, pair.Value))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Adds entries to the map from the given stream.
+        /// </summary>
+        /// <remarks>
+        /// It is assumed that the stream is initially positioned after the tag specified by the codec.
+        /// This method will continue reading entries from the stream until the end is reached, or
+        /// a different tag is encountered.
+        /// </remarks>
+        /// <param name="input">Stream to read from</param>
+        /// <param name="codec">Codec describing how the key/value pairs are encoded</param>
+        public void AddEntriesFrom(CodedInputStream input, Codec codec)
+        {
+            ParseContext.Initialize(input, out ParseContext ctx);
+            try
+            {
+                AddEntriesFrom(ref ctx, codec);
+            }
+            finally
+            {
+                ctx.CopyStateTo(input);
+            }
+        }
+
+        /// <summary>
+        /// Adds entries to the map from the given parse context.
+        /// </summary>
+        /// <remarks>
+        /// It is assumed that the input is initially positioned after the tag specified by the codec.
+        /// This method will continue reading entries from the input until the end is reached, or
+        /// a different tag is encountered.
+        /// </remarks>
+        /// <param name="ctx">Input to read from</param>
+        /// <param name="codec">Codec describing how the key/value pairs are encoded</param>
+        [SecuritySafeCritical]
+        public void AddEntriesFrom(ref ParseContext ctx, Codec codec)
+        {
+            do
+            {
+                KeyValuePair<TKey, TValue> entry = ParsingPrimitivesMessages.ReadMapEntry(ref ctx, codec);
+                this[entry.Key] = entry.Value;
+            } while (ParsingPrimitives.MaybeConsumeTag(ref ctx.buffer, ref ctx.state, codec.MapTag));
+        }
+
+        /// <summary>
+        /// Writes the contents of this map to the given coded output stream, using the specified codec
+        /// to encode each entry.
+        /// </summary>
+        /// <param name="output">The output stream to write to.</param>
+        /// <param name="codec">The codec to use for each entry.</param>
+        public void WriteTo(CodedOutputStream output, Codec codec)
+        {
+            WriteContext.Initialize(output, out WriteContext ctx);
+            try
+            {
+                WriteTo(ref ctx, codec);
+            }
+            finally
+            {
+                ctx.CopyStateTo(output);
+            }
+        }
+
+        /// <summary>
+        /// Writes the contents of this map to the given write context, using the specified codec
+        /// to encode each entry.
+        /// </summary>
+        /// <param name="ctx">The write context to write to.</param>
+        /// <param name="codec">The codec to use for each entry.</param>
+        [SecuritySafeCritical]
+        public void WriteTo(ref WriteContext ctx, Codec codec)
+        {
+            foreach (var entry in list)
+            {
+                ctx.WriteTag(codec.MapTag);
+
+                WritingPrimitives.WriteLength(ref ctx.buffer, ref ctx.state, CalculateEntrySize(codec, entry));
+                codec.KeyCodec.WriteTagAndValue(ref ctx, entry.Key);
+                codec.ValueCodec.WriteTagAndValue(ref ctx, entry.Value);
+            }
+        }
+
+        /// <summary>
+        /// Calculates the size of this map based on the given entry codec.
+        /// </summary>
+        /// <param name="codec">The codec to use to encode each entry.</param>
+        /// <returns></returns>
+        public int CalculateSize(Codec codec)
+        {
+            if (Count == 0)
+            {
+                return 0;
+            }
+            int size = 0;
+            foreach (var entry in list)
+            {
+                int entrySize = CalculateEntrySize(codec, entry);
+
+                size += CodedOutputStream.ComputeRawVarint32Size(codec.MapTag);
+                size += CodedOutputStream.ComputeLengthSize(entrySize) + entrySize;
+            }
+            return size;
+        }
+
+        private static int CalculateEntrySize(Codec codec, KeyValuePair<TKey, TValue> entry)
+        {
+            return codec.KeyCodec.CalculateSizeWithTag(entry.Key) + codec.ValueCodec.CalculateSizeWithTag(entry.Value);
+        }
+
+        /// <summary>
+        /// Returns a string representation of this repeated field, in the same
+        /// way as it would be represented by the default JSON formatter.
+        /// </summary>
+        public override string ToString()
+        {
+            var writer = new StringWriter();
+            JsonFormatter.Default.WriteDictionary(writer, this);
+            return writer.ToString();
+        }
+
+        #region IDictionary explicit interface implementation
+        void IDictionary.Add(object key, object value)
+        {
+            Add((TKey)key, (TValue)value);
+        }
+
+        bool IDictionary.Contains(object key)
+        {
+            if (!(key is TKey))
+            {
+                return false;
+            }
+            return ContainsKey((TKey)key);
+        }
+
+        IDictionaryEnumerator IDictionary.GetEnumerator()
+        {
+            return new DictionaryEnumerator(GetEnumerator());
+        }
+
+        void IDictionary.Remove(object key)
+        {
+            ProtoPreconditions.CheckNotNull(key, nameof(key));
+            if (!(key is TKey))
+            {
+                return;
+            }
+            Remove((TKey)key);
+        }
+
+        void ICollection.CopyTo(Array array, int index)
+        {
+            // This is ugly and slow as heck, but with any luck it will never be used anyway.
+            ICollection temp = this.Select(pair => new DictionaryEntry(pair.Key, pair.Value)).ToList();
+            temp.CopyTo(array, index);
+        }
+
+        bool IDictionary.IsFixedSize { get { return false; } }
+
+        ICollection IDictionary.Keys { get { return (ICollection)Keys; } }
+
+        ICollection IDictionary.Values { get { return (ICollection)Values; } }
+
+        bool ICollection.IsSynchronized { get { return false; } }
+
+        object ICollection.SyncRoot { get { return this; } }
+
+        object IDictionary.this[object key]
+        {
+            get
+            {
+                ProtoPreconditions.CheckNotNull(key, nameof(key));
+                if (!(key is TKey))
+                {
+                    return null;
+                }
+                TValue value;
+                TryGetValue((TKey)key, out value);
+                return value;
+            }
+
+            set
+            {
+                this[(TKey)key] = (TValue)value;
+            }
+        }
+        #endregion
+
+        #region IReadOnlyDictionary explicit interface implementation
+#if !NET35
+        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => Keys;
+
+        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => Values;
+#endif
+        #endregion
+
+        private class DictionaryEnumerator : IDictionaryEnumerator
+        {
+            private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;
+
+            internal DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
+            {
+                this.enumerator = enumerator;
+            }
+
+            public bool MoveNext()
+            {
+                return enumerator.MoveNext();
+            }
+
+            public void Reset()
+            {
+                enumerator.Reset();
+            }
+
+            public object Current { get { return Entry; } }
+            public DictionaryEntry Entry { get { return new DictionaryEntry(Key, Value); } }
+            public object Key { get { return enumerator.Current.Key; } }
+            public object Value { get { return enumerator.Current.Value; } }
+        }
+
+        /// <summary>
+        /// A codec for a specific map field. This contains all the information required to encode and
+        /// decode the nested messages.
+        /// </summary>
+        public sealed class Codec
+        {
+            private readonly FieldCodec<TKey> keyCodec;
+            private readonly FieldCodec<TValue> valueCodec;
+            private readonly uint mapTag;
+
+            /// <summary>
+            /// Creates a new entry codec based on a separate key codec and value codec,
+            /// and the tag to use for each map entry.
+            /// </summary>
+            /// <param name="keyCodec">The key codec.</param>
+            /// <param name="valueCodec">The value codec.</param>
+            /// <param name="mapTag">The map tag to use to introduce each map entry.</param>
+            public Codec(FieldCodec<TKey> keyCodec, FieldCodec<TValue> valueCodec, uint mapTag)
+            {
+                this.keyCodec = keyCodec;
+                this.valueCodec = valueCodec;
+                this.mapTag = mapTag;
+            }
+
+            /// <summary>
+            /// The key codec.
+            /// </summary>
+            internal FieldCodec<TKey> KeyCodec => keyCodec;
+
+            /// <summary>
+            /// The value codec.
+            /// </summary>
+            internal FieldCodec<TValue> ValueCodec => valueCodec;
+
+            /// <summary>
+            /// The tag used in the enclosing message to indicate map entries.
+            /// </summary>
+            internal uint MapTag => mapTag;
+        }
+
+        private class MapView<T> : ICollection<T>, ICollection
+        {
+            private readonly MapField<TKey, TValue> parent;
+            private readonly Func<KeyValuePair<TKey, TValue>, T> projection;
+            private readonly Func<T, bool> containsCheck;
+
+            internal MapView(
+                MapField<TKey, TValue> parent,
+                Func<KeyValuePair<TKey, TValue>, T> projection,
+                Func<T, bool> containsCheck)
+            {
+                this.parent = parent;
+                this.projection = projection;
+                this.containsCheck = containsCheck;
+            }
+
+            public int Count { get { return parent.Count; } }
+
+            public bool IsReadOnly { get { return true; } }
+
+            public bool IsSynchronized { get { return false; } }
+
+            public object SyncRoot { get { return parent; } }
+
+            public void Add(T item)
+            {
+                throw new NotSupportedException();
+            }
+
+            public void Clear()
+            {
+                throw new NotSupportedException();
+            }
+
+            public bool Contains(T item)
+            {
+                return containsCheck(item);
+            }
+
+            public void CopyTo(T[] array, int arrayIndex)
+            {
+                if (arrayIndex < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+                }
+                if (arrayIndex + Count > array.Length)
+                {
+                    throw new ArgumentException("Not enough space in the array", nameof(array));
+                }
+                foreach (var item in this)
+                {
+                    array[arrayIndex++] = item;
+                }
+            }
+
+            public IEnumerator<T> GetEnumerator()
+            {
+                return parent.list.Select(projection).GetEnumerator();
+            }
+
+            public bool Remove(T item)
+            {
+                throw new NotSupportedException();
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            public void CopyTo(Array array, int index)
+            {
+                if (index < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index));
+                }
+                if (index + Count > array.Length)
+                {
+                    throw new ArgumentException("Not enough space in the array", nameof(array));
+                }
+                foreach (var item in this)
+                {
+                    array.SetValue(item, index++);
+                }
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Collections/ProtobufEqualityComparers.cs b/Libs/Google.Protobuf/Collections/ProtobufEqualityComparers.cs
new file mode 100644
index 0000000..830b0f5
--- /dev/null
+++ b/Libs/Google.Protobuf/Collections/ProtobufEqualityComparers.cs
@@ -0,0 +1,130 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2017 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+
+namespace LC.Google.Protobuf.Collections
+{
+    /// <summary>
+    /// Provides a central place to implement equality comparisons, primarily for bitwise float/double equality.
+    /// </summary>
+    public static class ProtobufEqualityComparers
+    {
+        /// <summary>
+        /// Returns an equality comparer for <typeparamref name="T"/> suitable for Protobuf equality comparisons.
+        /// This is usually just the default equality comparer for the type, but floating point numbers are compared
+        /// bitwise.
+        /// </summary>
+        /// <typeparam name="T">The type of equality comparer to return.</typeparam>
+        /// <returns>The equality comparer.</returns>
+        public static EqualityComparer<T> GetEqualityComparer<T>()
+        {
+            return typeof(T) == typeof(double) ? (EqualityComparer<T>) (object) BitwiseDoubleEqualityComparer
+                : typeof(T) == typeof(float) ? (EqualityComparer<T>) (object) BitwiseSingleEqualityComparer
+                : typeof(T) == typeof(double?) ? (EqualityComparer<T>) (object) BitwiseNullableDoubleEqualityComparer
+                : typeof(T) == typeof(float?) ? (EqualityComparer<T>) (object) BitwiseNullableSingleEqualityComparer
+                : EqualityComparer<T>.Default;
+        }
+
+        /// <summary>
+        /// Returns an equality comparer suitable for comparing 64-bit floating point values, by bitwise comparison.
+        /// (NaN values are considered equal, but only when they have the same representation.)
+        /// </summary>
+        public static EqualityComparer<double> BitwiseDoubleEqualityComparer { get; } = new BitwiseDoubleEqualityComparerImpl();
+
+        /// <summary>
+        /// Returns an equality comparer suitable for comparing 32-bit floating point values, by bitwise comparison.
+        /// (NaN values are considered equal, but only when they have the same representation.)
+        /// </summary>
+        public static EqualityComparer<float> BitwiseSingleEqualityComparer { get; } = new BitwiseSingleEqualityComparerImpl();
+
+        /// <summary>
+        /// Returns an equality comparer suitable for comparing nullable 64-bit floating point values, by bitwise comparison.
+        /// (NaN values are considered equal, but only when they have the same representation.)
+        /// </summary>
+        public static EqualityComparer<double?> BitwiseNullableDoubleEqualityComparer { get; } = new BitwiseNullableDoubleEqualityComparerImpl();
+
+        /// <summary>
+        /// Returns an equality comparer suitable for comparing nullable 32-bit floating point values, by bitwise comparison.
+        /// (NaN values are considered equal, but only when they have the same representation.)
+        /// </summary>
+        public static EqualityComparer<float?> BitwiseNullableSingleEqualityComparer { get; } = new BitwiseNullableSingleEqualityComparerImpl();
+
+        private class BitwiseDoubleEqualityComparerImpl : EqualityComparer<double>
+        {
+            public override bool Equals(double x, double y) =>
+                BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y);
+
+            public override int GetHashCode(double obj) =>
+                BitConverter.DoubleToInt64Bits(obj).GetHashCode();
+        }
+
+        private class BitwiseSingleEqualityComparerImpl : EqualityComparer<float>
+        {
+            // Just promote values to double and use BitConverter.DoubleToInt64Bits,
+            // as there's no BitConverter.SingleToInt32Bits, unfortunately.
+
+            public override bool Equals(float x, float y) =>
+                BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y);
+
+            public override int GetHashCode(float obj) =>
+                BitConverter.DoubleToInt64Bits(obj).GetHashCode();
+        }
+
+        private class BitwiseNullableDoubleEqualityComparerImpl : EqualityComparer<double?>
+        {
+            public override bool Equals(double? x, double? y) =>
+                x == null && y == null ? true
+                : x == null || y == null ? false
+                : BitwiseDoubleEqualityComparer.Equals(x.Value, y.Value);
+
+            // The hash code for null is just a constant which is at least *unlikely* to be used
+            // elsewhere. (Compared with 0, say.)
+            public override int GetHashCode(double? obj) =>
+                obj == null ? 293864 : BitwiseDoubleEqualityComparer.GetHashCode(obj.Value);
+        }
+
+        private class BitwiseNullableSingleEqualityComparerImpl : EqualityComparer<float?>
+        {
+            public override bool Equals(float? x, float? y) =>
+                x == null && y == null ? true
+                : x == null || y == null ? false
+                : BitwiseSingleEqualityComparer.Equals(x.Value, y.Value);
+
+            // The hash code for null is just a constant which is at least *unlikely* to be used
+            // elsewhere. (Compared with 0, say.)
+            public override int GetHashCode(float? obj) =>
+                obj == null ? 293864 : BitwiseSingleEqualityComparer.GetHashCode(obj.Value);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Collections/ReadOnlyDictionary.cs b/Libs/Google.Protobuf/Collections/ReadOnlyDictionary.cs
new file mode 100644
index 0000000..e589b89
--- /dev/null
+++ b/Libs/Google.Protobuf/Collections/ReadOnlyDictionary.cs
@@ -0,0 +1,147 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace LC.Google.Protobuf.Collections
+{
+    /// <summary>
+    /// Read-only wrapper around another dictionary.
+    /// </summary>
+    internal sealed class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+    {
+        private readonly IDictionary<TKey, TValue> wrapped;
+
+        public ReadOnlyDictionary(IDictionary<TKey, TValue> wrapped)
+        {
+            this.wrapped = wrapped;
+        }
+
+        public void Add(TKey key, TValue value)
+        {
+            throw new InvalidOperationException();
+        }
+
+        public bool ContainsKey(TKey key)
+        {
+            return wrapped.ContainsKey(key);
+        }
+
+        public ICollection<TKey> Keys
+        {
+            get { return wrapped.Keys; }
+        }
+
+        public bool Remove(TKey key)
+        {
+            throw new InvalidOperationException();
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            return wrapped.TryGetValue(key, out value);
+        }
+
+        public ICollection<TValue> Values
+        {
+            get { return wrapped.Values; }
+        }
+
+        public TValue this[TKey key]
+        {
+            get { return wrapped[key]; }
+            set { throw new InvalidOperationException(); }
+        }
+
+        public void Add(KeyValuePair<TKey, TValue> item)
+        {
+            throw new InvalidOperationException();
+        }
+
+        public void Clear()
+        {
+            throw new InvalidOperationException();
+        }
+
+        public bool Contains(KeyValuePair<TKey, TValue> item)
+        {
+            return wrapped.Contains(item);
+        }
+
+        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            wrapped.CopyTo(array, arrayIndex);
+        }
+
+        public int Count
+        {
+            get { return wrapped.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return true; }
+        }
+
+        public bool Remove(KeyValuePair<TKey, TValue> item)
+        {
+            throw new InvalidOperationException();
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            return wrapped.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable) wrapped).GetEnumerator();
+        }
+
+        public override bool Equals(object obj)
+        {
+            return wrapped.Equals(obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return wrapped.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return wrapped.ToString();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Collections/RepeatedField.cs b/Libs/Google.Protobuf/Collections/RepeatedField.cs
new file mode 100644
index 0000000..30e2e57
--- /dev/null
+++ b/Libs/Google.Protobuf/Collections/RepeatedField.cs
@@ -0,0 +1,698 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Security;
+using System.Threading;
+
+namespace LC.Google.Protobuf.Collections
+{
+    /// <summary>
+    /// The contents of a repeated field: essentially, a collection with some extra
+    /// restrictions (no null values) and capabilities (deep cloning).
+    /// </summary>
+    /// <remarks>
+    /// This implementation does not generally prohibit the use of types which are not
+    /// supported by Protocol Buffers but nor does it guarantee that all operations will work in such cases.
+    /// </remarks>
+    /// <typeparam name="T">The element type of the repeated field.</typeparam>
+    public sealed class RepeatedField<T> : IList<T>, IList, IDeepCloneable<RepeatedField<T>>, IEquatable<RepeatedField<T>>
+#if !NET35
+        , IReadOnlyList<T>
+#endif
+    {
+        private static readonly EqualityComparer<T> EqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<T>();
+        private static readonly T[] EmptyArray = new T[0];
+        private const int MinArraySize = 8;
+
+        private T[] array = EmptyArray;
+        private int count = 0;
+
+        /// <summary>
+        /// Creates a deep clone of this repeated field.
+        /// </summary>
+        /// <remarks>
+        /// If the field type is
+        /// a message type, each element is also cloned; otherwise, it is
+        /// assumed that the field type is primitive (including string and
+        /// bytes, both of which are immutable) and so a simple copy is
+        /// equivalent to a deep clone.
+        /// </remarks>
+        /// <returns>A deep clone of this repeated field.</returns>
+        public RepeatedField<T> Clone()
+        {
+            RepeatedField<T> clone = new RepeatedField<T>();
+            if (array != EmptyArray)
+            {
+                clone.array = (T[])array.Clone();
+                IDeepCloneable<T>[] cloneableArray = clone.array as IDeepCloneable<T>[];
+                if (cloneableArray != null)
+                {
+                    for (int i = 0; i < count; i++)
+                    {
+                        clone.array[i] = cloneableArray[i].Clone();
+                    }
+                }
+            }
+            clone.count = count;
+            return clone;
+        }
+
+        /// <summary>
+        /// Adds the entries from the given input stream, decoding them with the specified codec.
+        /// </summary>
+        /// <param name="input">The input stream to read from.</param>
+        /// <param name="codec">The codec to use in order to read each entry.</param>
+        public void AddEntriesFrom(CodedInputStream input, FieldCodec<T> codec)
+        {
+            ParseContext.Initialize(input, out ParseContext ctx);
+            try
+            {
+                AddEntriesFrom(ref ctx, codec);
+            }
+            finally
+            {
+                ctx.CopyStateTo(input);
+            }
+        }
+
+        /// <summary>
+        /// Adds the entries from the given parse context, decoding them with the specified codec.
+        /// </summary>
+        /// <param name="ctx">The input to read from.</param>
+        /// <param name="codec">The codec to use in order to read each entry.</param>
+        [SecuritySafeCritical]
+        public void AddEntriesFrom(ref ParseContext ctx, FieldCodec<T> codec)
+        {
+            // TODO: Inline some of the Add code, so we can avoid checking the size on every
+            // iteration.
+            uint tag = ctx.state.lastTag;
+            var reader = codec.ValueReader;
+            // Non-nullable value types can be packed or not.
+            if (FieldCodec<T>.IsPackedRepeatedField(tag))
+            {
+                int length = ctx.ReadLength();
+                if (length > 0)
+                {
+                    int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, length);
+
+                    // If the content is fixed size then we can calculate the length
+                    // of the repeated field and pre-initialize the underlying collection.
+                    //
+                    // Check that the supplied length doesn't exceed the underlying buffer.
+                    // That prevents a malicious length from initializing a very large collection.
+                    if (codec.FixedSize > 0 && length % codec.FixedSize == 0 && ParsingPrimitives.IsDataAvailable(ref ctx.state, length))
+                    {
+                        EnsureSize(count + (length / codec.FixedSize));
+
+                        while (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
+                        {
+                            // Only FieldCodecs with a fixed size can reach here, and they are all known
+                            // types that don't allow the user to specify a custom reader action.
+                            // reader action will never return null.
+                            array[count++] = reader(ref ctx);
+                        }
+                    }
+                    else
+                    {
+                        // Content is variable size so add until we reach the limit.
+                        while (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
+                        {
+                            Add(reader(ref ctx));
+                        }
+                    }
+                    SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
+                }
+                // Empty packed field. Odd, but valid - just ignore.
+            }
+            else
+            {
+                // Not packed... (possibly not packable)
+                do
+                {
+                    Add(reader(ref ctx));
+                } while (ParsingPrimitives.MaybeConsumeTag(ref ctx.buffer, ref ctx.state, tag));
+            }
+        }
+
+        /// <summary>
+        /// Calculates the size of this collection based on the given codec.
+        /// </summary>
+        /// <param name="codec">The codec to use when encoding each field.</param>
+        /// <returns>The number of bytes that would be written to an output by one of the <c>WriteTo</c> methods,
+        /// using the same codec.</returns>
+        public int CalculateSize(FieldCodec<T> codec)
+        {
+            if (count == 0)
+            {
+                return 0;
+            }
+            uint tag = codec.Tag;
+            if (codec.PackedRepeatedField)
+            {
+                int dataSize = CalculatePackedDataSize(codec);
+                return CodedOutputStream.ComputeRawVarint32Size(tag) +
+                    CodedOutputStream.ComputeLengthSize(dataSize) +
+                    dataSize;
+            }
+            else
+            {
+                var sizeCalculator = codec.ValueSizeCalculator;
+                int size = count * CodedOutputStream.ComputeRawVarint32Size(tag);
+                if (codec.EndTag != 0)
+                {
+                    size += count * CodedOutputStream.ComputeRawVarint32Size(codec.EndTag);
+                }
+                for (int i = 0; i < count; i++)
+                {
+                    size += sizeCalculator(array[i]);
+                }
+                return size;
+            }
+        }
+
+        private int CalculatePackedDataSize(FieldCodec<T> codec)
+        {
+            int fixedSize = codec.FixedSize;
+            if (fixedSize == 0)
+            {
+                var calculator = codec.ValueSizeCalculator;
+                int tmp = 0;
+                for (int i = 0; i < count; i++)
+                {
+                    tmp += calculator(array[i]);
+                }
+                return tmp;
+            }
+            else
+            {
+                return fixedSize * Count;
+            }
+        }
+
+        /// <summary>
+        /// Writes the contents of this collection to the given <see cref="CodedOutputStream"/>,
+        /// encoding each value using the specified codec.
+        /// </summary>
+        /// <param name="output">The output stream to write to.</param>
+        /// <param name="codec">The codec to use when encoding each value.</param>
+        public void WriteTo(CodedOutputStream output, FieldCodec<T> codec)
+        {
+            WriteContext.Initialize(output, out WriteContext ctx);
+            try
+            {
+                WriteTo(ref ctx, codec);
+            }
+            finally
+            {
+                ctx.CopyStateTo(output);
+            }
+        }
+
+        /// <summary>
+        /// Writes the contents of this collection to the given write context,
+        /// encoding each value using the specified codec.
+        /// </summary>
+        /// <param name="ctx">The write context to write to.</param>
+        /// <param name="codec">The codec to use when encoding each value.</param>
+        [SecuritySafeCritical]
+        public void WriteTo(ref WriteContext ctx, FieldCodec<T> codec)
+        {
+            if (count == 0)
+            {
+                return;
+            }
+            var writer = codec.ValueWriter;
+            var tag = codec.Tag;
+            if (codec.PackedRepeatedField)
+            {
+                // Packed primitive type
+                int size = CalculatePackedDataSize(codec);
+                ctx.WriteTag(tag);
+                ctx.WriteLength(size);
+                for (int i = 0; i < count; i++)
+                {
+                    writer(ref ctx, array[i]);
+                }
+            }
+            else
+            {
+                // Not packed: a simple tag/value pair for each value.
+                // Can't use codec.WriteTagAndValue, as that omits default values.
+                for (int i = 0; i < count; i++)
+                {
+                    ctx.WriteTag(tag);
+                    writer(ref ctx, array[i]);
+                    if (codec.EndTag != 0)
+                    {
+                        ctx.WriteTag(codec.EndTag);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets and sets the capacity of the RepeatedField's internal array.  WHen set, the internal array is reallocated to the given capacity.
+        /// <exception cref="ArgumentOutOfRangeException">The new value is less than Count -or- when Count is less than 0.</exception>
+        /// </summary>
+        public int Capacity
+        {
+            get { return array.Length; }
+            set
+            {
+                if (value < count)
+                {
+                    throw new ArgumentOutOfRangeException("Capacity", value,
+                        $"Cannot set Capacity to a value smaller than the current item count, {count}");
+                }
+
+                if (value >= 0 && value != array.Length)
+                {
+                    SetSize(value);
+                }
+            }
+        }
+
+        // May increase the size of the internal array, but will never shrink it.
+        private void EnsureSize(int size)
+        {
+            if (array.Length < size)
+            {
+                size = Math.Max(size, MinArraySize);
+                int newSize = Math.Max(array.Length * 2, size);
+                SetSize(newSize);
+            }
+        }
+
+        // Sets the internal array to an exact size.
+        private void SetSize(int size)
+        {
+            if (size != array.Length)
+            {
+                var tmp = new T[size];
+                Array.Copy(array, 0, tmp, 0, count);
+                array = tmp;
+            }
+        }
+
+        /// <summary>
+        /// Adds the specified item to the collection.
+        /// </summary>
+        /// <param name="item">The item to add.</param>
+        public void Add(T item)
+        {
+            ProtoPreconditions.CheckNotNullUnconstrained(item, nameof(item));
+            EnsureSize(count + 1);
+            array[count++] = item;
+        }
+
+        /// <summary>
+        /// Removes all items from the collection.
+        /// </summary>
+        public void Clear()
+        {
+            array = EmptyArray;
+            count = 0;
+        }
+
+        /// <summary>
+        /// Determines whether this collection contains the given item.
+        /// </summary>
+        /// <param name="item">The item to find.</param>
+        /// <returns><c>true</c> if this collection contains the given item; <c>false</c> otherwise.</returns>
+        public bool Contains(T item)
+        {
+            return IndexOf(item) != -1;
+        }
+
+        /// <summary>
+        /// Copies this collection to the given array.
+        /// </summary>
+        /// <param name="array">The array to copy to.</param>
+        /// <param name="arrayIndex">The first index of the array to copy to.</param>
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            Array.Copy(this.array, 0, array, arrayIndex, count);
+        }
+
+        /// <summary>
+        /// Removes the specified item from the collection
+        /// </summary>
+        /// <param name="item">The item to remove.</param>
+        /// <returns><c>true</c> if the item was found and removed; <c>false</c> otherwise.</returns>
+        public bool Remove(T item)
+        {
+            int index = IndexOf(item);
+            if (index == -1)
+            {
+                return false;
+            }            
+            Array.Copy(array, index + 1, array, index, count - index - 1);
+            count--;
+            array[count] = default(T);
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the number of elements contained in the collection.
+        /// </summary>
+        public int Count => count;
+
+        /// <summary>
+        /// Gets a value indicating whether the collection is read-only.
+        /// </summary>
+        public bool IsReadOnly => false;
+
+        /// <summary>
+        /// Adds all of the specified values into this collection.
+        /// </summary>
+        /// <param name="values">The values to add to this collection.</param>
+        public void AddRange(IEnumerable<T> values)
+        {
+            ProtoPreconditions.CheckNotNull(values, nameof(values));
+
+            // Optimization 1: If the collection we're adding is already a RepeatedField<T>,
+            // we know the values are valid.
+            var otherRepeatedField = values as RepeatedField<T>;
+            if (otherRepeatedField != null)
+            {
+                EnsureSize(count + otherRepeatedField.count);
+                Array.Copy(otherRepeatedField.array, 0, array, count, otherRepeatedField.count);
+                count += otherRepeatedField.count;
+                return;
+            }
+
+            // Optimization 2: The collection is an ICollection, so we can expand
+            // just once and ask the collection to copy itself into the array.
+            var collection = values as ICollection;
+            if (collection != null)
+            {
+                var extraCount = collection.Count;
+                // For reference types and nullable value types, we need to check that there are no nulls
+                // present. (This isn't a thread-safe approach, but we don't advertise this is thread-safe.)
+                // We expect the JITter to optimize this test to true/false, so it's effectively conditional
+                // specialization.
+                if (default(T) == null)
+                {
+                    // TODO: Measure whether iterating once to check and then letting the collection copy
+                    // itself is faster or slower than iterating and adding as we go. For large
+                    // collections this will not be great in terms of cache usage... but the optimized
+                    // copy may be significantly faster than doing it one at a time.
+                    foreach (var item in collection)
+                    {
+                        if (item == null)
+                        {
+                            throw new ArgumentException("Sequence contained null element", nameof(values));
+                        }
+                    }
+                }
+                EnsureSize(count + extraCount);
+                collection.CopyTo(array, count);
+                count += extraCount;
+                return;
+            }
+
+            // We *could* check for ICollection<T> as well, but very very few collections implement
+            // ICollection<T> but not ICollection. (HashSet<T> does, for one...)
+
+            // Fall back to a slower path of adding items one at a time.
+            foreach (T item in values)
+            {
+                Add(item);
+            }
+        }
+
+        /// <summary>
+        /// Adds all of the specified values into this collection. This method is present to
+        /// allow repeated fields to be constructed from queries within collection initializers.
+        /// Within non-collection-initializer code, consider using the equivalent <see cref="AddRange"/>
+        /// method instead for clarity.
+        /// </summary>
+        /// <param name="values">The values to add to this collection.</param>
+        public void Add(IEnumerable<T> values)
+        {
+            AddRange(values);
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>
+        /// An enumerator that can be used to iterate through the collection.
+        /// </returns>
+        public IEnumerator<T> GetEnumerator()
+        {
+            for (int i = 0; i < count; i++)
+            {
+                yield return array[i];
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="System.Object" />, is equal to this instance.
+        /// </summary>
+        /// <param name="obj">The <see cref="System.Object" /> to compare with this instance.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as RepeatedField<T>);
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through a collection.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.
+        /// </returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode()
+        {
+            int hash = 0;
+            for (int i = 0; i < count; i++)
+            {
+                hash = hash * 31 + array[i].GetHashCode();
+            }
+            return hash;
+        }
+
+        /// <summary>
+        /// Compares this repeated field with another for equality.
+        /// </summary>
+        /// <param name="other">The repeated field to compare this with.</param>
+        /// <returns><c>true</c> if <paramref name="other"/> refers to an equal repeated field; <c>false</c> otherwise.</returns>
+        public bool Equals(RepeatedField<T> other)
+        {
+            if (ReferenceEquals(other, null))
+            {
+                return false;
+            }
+            if (ReferenceEquals(other, this))
+            {
+                return true;
+            }
+            if (other.Count != this.Count)
+            {
+                return false;
+            }
+            EqualityComparer<T> comparer = EqualityComparer;
+            for (int i = 0; i < count; i++)
+            {
+                if (!comparer.Equals(array[i], other.array[i]))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Returns the index of the given item within the collection, or -1 if the item is not
+        /// present.
+        /// </summary>
+        /// <param name="item">The item to find in the collection.</param>
+        /// <returns>The zero-based index of the item, or -1 if it is not found.</returns>
+        public int IndexOf(T item)
+        {
+            ProtoPreconditions.CheckNotNullUnconstrained(item, nameof(item));
+            EqualityComparer<T> comparer = EqualityComparer;
+            for (int i = 0; i < count; i++)
+            {
+                if (comparer.Equals(array[i], item))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        /// <summary>
+        /// Inserts the given item at the specified index.
+        /// </summary>
+        /// <param name="index">The index at which to insert the item.</param>
+        /// <param name="item">The item to insert.</param>
+        public void Insert(int index, T item)
+        {
+            ProtoPreconditions.CheckNotNullUnconstrained(item, nameof(item));
+            if (index < 0 || index > count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+            EnsureSize(count + 1);
+            Array.Copy(array, index, array, index + 1, count - index);
+            array[index] = item;
+            count++;
+        }
+
+        /// <summary>
+        /// Removes the item at the given index.
+        /// </summary>
+        /// <param name="index">The zero-based index of the item to remove.</param>
+        public void RemoveAt(int index)
+        {
+            if (index < 0 || index >= count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+            Array.Copy(array, index + 1, array, index, count - index - 1);
+            count--;
+            array[count] = default(T);
+        }
+
+        /// <summary>
+        /// Returns a string representation of this repeated field, in the same
+        /// way as it would be represented by the default JSON formatter.
+        /// </summary>
+        public override string ToString()
+        {
+            var writer = new StringWriter();
+            JsonFormatter.Default.WriteList(writer, this);
+            return writer.ToString();
+        }
+
+        /// <summary>
+        /// Gets or sets the item at the specified index.
+        /// </summary>
+        /// <value>
+        /// The element at the specified index.
+        /// </value>
+        /// <param name="index">The zero-based index of the element to get or set.</param>
+        /// <returns>The item at the specified index.</returns>
+        public T this[int index]
+        {
+            get
+            {
+                if (index < 0 || index >= count)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index));
+                }
+                return array[index];
+            }
+            set
+            {
+                if (index < 0 || index >= count)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index));
+                }
+                ProtoPreconditions.CheckNotNullUnconstrained(value, nameof(value));
+                array[index] = value;
+            }
+        }
+
+        #region Explicit interface implementation for IList and ICollection.
+        bool IList.IsFixedSize => false;
+
+        void ICollection.CopyTo(Array array, int index)
+        {
+            Array.Copy(this.array, 0, array, index, count);
+        }
+
+        bool ICollection.IsSynchronized => false;
+
+        object ICollection.SyncRoot => this;
+
+        object IList.this[int index]
+        {
+            get { return this[index]; }
+            set { this[index] = (T)value; }
+        }
+
+        int IList.Add(object value)
+        {
+            Add((T) value);
+            return count - 1;
+        }
+
+        bool IList.Contains(object value)
+        {
+            return (value is T && Contains((T)value));
+        }
+
+        int IList.IndexOf(object value)
+        {
+            if (!(value is T))
+            {
+                return -1;
+            }
+            return IndexOf((T)value);
+        }
+
+        void IList.Insert(int index, object value)
+        {
+            Insert(index, (T) value);
+        }
+
+        void IList.Remove(object value)
+        {
+            if (!(value is T))
+            {
+                return;
+            }
+            Remove((T)value);
+        }
+        #endregion        
+    }
+}
diff --git a/Libs/Google.Protobuf/Compatibility/MethodInfoExtensions.cs b/Libs/Google.Protobuf/Compatibility/MethodInfoExtensions.cs
new file mode 100644
index 0000000..0fe73ee
--- /dev/null
+++ b/Libs/Google.Protobuf/Compatibility/MethodInfoExtensions.cs
@@ -0,0 +1,47 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2017 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+#if NET35
+using System;
+using System.Reflection;
+
+namespace LC.Google.Protobuf.Compatibility
+{
+    // .NET Core (at least netstandard1.0) doesn't have Delegate.CreateDelegate, and .NET 3.5 doesn't have
+    // MethodInfo.CreateDelegate. Proxy from one to the other on .NET 3.5...
+    internal static class MethodInfoExtensions
+    {
+        internal static Delegate CreateDelegate(this MethodInfo method, Type type) =>
+            Delegate.CreateDelegate(type, method);
+    }
+}
+#endif
diff --git a/Libs/Google.Protobuf/Compatibility/PropertyInfoExtensions.cs b/Libs/Google.Protobuf/Compatibility/PropertyInfoExtensions.cs
new file mode 100644
index 0000000..aa4c4dd
--- /dev/null
+++ b/Libs/Google.Protobuf/Compatibility/PropertyInfoExtensions.cs
@@ -0,0 +1,72 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Reflection;
+
+namespace LC.Google.Protobuf.Compatibility
+{
+    /// <summary>
+    /// Extension methods for <see cref="PropertyInfo"/>, effectively providing
+    /// the familiar members from previous desktop framework versions while
+    /// targeting the newer releases, .NET Core etc.
+    /// </summary>
+    internal static class PropertyInfoExtensions
+    {
+        /// <summary>
+        /// Returns the public getter of a property, or null if there is no such getter
+        /// (either because it's read-only, or the getter isn't public).
+        /// </summary>
+        internal static MethodInfo GetGetMethod(this PropertyInfo target)
+        {
+#if NET35
+            var method = target.GetGetMethod();
+#else
+            var method = target.GetMethod;
+#endif
+            return method != null && method.IsPublic ? method : null;
+        }
+
+        /// <summary>
+        /// Returns the public setter of a property, or null if there is no such setter
+        /// (either because it's write-only, or the setter isn't public).
+        /// </summary>
+        internal static MethodInfo GetSetMethod(this PropertyInfo target)
+        {
+#if NET35
+            var method = target.GetSetMethod();
+#else
+            var method = target.SetMethod;
+#endif
+            return method != null && method.IsPublic ? method : null;
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Compatibility/StreamExtensions.cs b/Libs/Google.Protobuf/Compatibility/StreamExtensions.cs
new file mode 100644
index 0000000..f475c94
--- /dev/null
+++ b/Libs/Google.Protobuf/Compatibility/StreamExtensions.cs
@@ -0,0 +1,66 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+#if NET35
+using System;
+using System.IO;
+
+namespace LC.Google.Protobuf.Compatibility
+{
+    /// <summary>
+    /// Extension methods for <see cref="Stream"/> in order to provide
+    /// backwards compatibility with .NET 3.5
+    /// </summary>
+    public static class StreamExtensions
+    {
+        // 81920 seems to be the default buffer size used in .NET 4.5.1
+        private const int BUFFER_SIZE = 81920;
+
+        /// <summary>
+        /// Write the contents of the current stream to the destination stream
+        /// </summary>
+        public static void CopyTo(this Stream source, Stream destination)
+        {
+            if (destination == null)
+            {
+                throw new ArgumentNullException(nameof(destination));
+            }
+
+            byte[] buffer = new byte[BUFFER_SIZE];
+            int numBytesRead;
+            while ((numBytesRead = source.Read(buffer, 0, buffer.Length)) > 0) {
+                destination.Write(buffer, 0, numBytesRead);
+            }
+        }
+    }
+}
+#endif
diff --git a/Libs/Google.Protobuf/Compatibility/TypeExtensions.cs b/Libs/Google.Protobuf/Compatibility/TypeExtensions.cs
new file mode 100644
index 0000000..be67850
--- /dev/null
+++ b/Libs/Google.Protobuf/Compatibility/TypeExtensions.cs
@@ -0,0 +1,106 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Reflection;
+
+#if !NET35
+namespace LC.Google.Protobuf.Compatibility
+{
+    /// <summary>
+    /// Provides extension methods on Type that just proxy to TypeInfo.
+    /// These are used to support the new type system from .NET 4.5, without
+    /// having calls to GetTypeInfo all over the place. While the methods here are meant to be
+    /// broadly compatible with the desktop framework, there are some subtle differences in behaviour - but
+    /// they're not expected to affect our use cases. While the class is internal, that should be fine: we can
+    /// evaluate each new use appropriately.
+    /// </summary>
+    internal static class TypeExtensions
+    {
+        /// <summary>
+        /// See https://msdn.microsoft.com/en-us/library/system.type.isassignablefrom
+        /// </summary>
+        internal static bool IsAssignableFrom(this Type target, Type c)
+        {
+            return target.GetTypeInfo().IsAssignableFrom(c.GetTypeInfo());
+        }
+
+        /// <summary>
+        /// Returns a representation of the public property associated with the given name in the given type,
+        /// including inherited properties or null if there is no such public property.
+        /// Here, "public property" means a property where either the getter, or the setter, or both, is public.
+        /// </summary>
+        internal static PropertyInfo GetProperty(this Type target, string name)
+        {
+            // GetDeclaredProperty only returns properties declared in the given type, so we need to recurse.
+            while (target != null)
+            {
+                var typeInfo = target.GetTypeInfo();
+                var ret = typeInfo.GetDeclaredProperty(name);
+                if (ret != null && ((ret.CanRead && ret.GetMethod.IsPublic) || (ret.CanWrite && ret.SetMethod.IsPublic)))
+                {
+                    return ret;
+                }
+                target = typeInfo.BaseType;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a representation of the public method associated with the given name in the given type,
+        /// including inherited methods.
+        /// </summary>
+        /// <remarks>
+        /// This has a few differences compared with Type.GetMethod in the desktop framework. It will throw
+        /// if there is an ambiguous match even between a private method and a public one, but it *won't* throw
+        /// if there are two overloads at different levels in the type hierarchy (e.g. class Base declares public void Foo(int) and
+        /// class Child : Base declares public void Foo(long)).
+        /// </remarks>
+        /// <exception cref="AmbiguousMatchException">One type in the hierarchy declared more than one method with the same name</exception>
+        internal static MethodInfo GetMethod(this Type target, string name)
+        {
+            // GetDeclaredMethod only returns methods declared in the given type, so we need to recurse.
+            while (target != null)
+            {
+                var typeInfo = target.GetTypeInfo();
+                var ret = typeInfo.GetDeclaredMethod(name);
+                if (ret != null && ret.IsPublic)
+                {
+                    return ret;
+                }
+                target = typeInfo.BaseType;
+            }
+            return null;
+        }
+    }
+}
+#endif
diff --git a/Libs/Google.Protobuf/Extension.cs b/Libs/Google.Protobuf/Extension.cs
new file mode 100644
index 0000000..8feee04
--- /dev/null
+++ b/Libs/Google.Protobuf/Extension.cs
@@ -0,0 +1,119 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Represents a non-generic extension definition. This API is experimental and subject to change.
+    /// </summary>
+    public abstract class Extension
+    {
+        internal abstract Type TargetType { get; }
+
+        /// <summary>
+        /// Internal use. Creates a new extension with the specified field number.
+        /// </summary>
+        protected Extension(int fieldNumber)
+        {
+            FieldNumber = fieldNumber;
+        }
+
+        internal abstract IExtensionValue CreateValue();
+
+        /// <summary>
+        /// Gets the field number of this extension
+        /// </summary>
+        public int FieldNumber { get; }
+
+        internal abstract bool IsRepeated { get; }
+    }
+
+    /// <summary>
+    /// Represents a type-safe extension identifier used for getting and setting single extension values in <see cref="IExtendableMessage{T}"/> instances. 
+    /// This API is experimental and subject to change.
+    /// </summary>
+    /// <typeparam name="TTarget">The message type this field applies to</typeparam>
+    /// <typeparam name="TValue">The field value type of this extension</typeparam>
+    public sealed class Extension<TTarget, TValue> : Extension where TTarget : IExtendableMessage<TTarget>
+    {
+        private readonly FieldCodec<TValue> codec;
+
+        /// <summary>
+        /// Creates a new extension identifier with the specified field number and codec
+        /// </summary>
+        public Extension(int fieldNumber, FieldCodec<TValue> codec) : base(fieldNumber)
+        {
+            this.codec = codec;
+        }
+
+        internal TValue DefaultValue => codec.DefaultValue;
+
+        internal override Type TargetType => typeof(TTarget);
+
+        internal override bool IsRepeated => false;
+
+        internal override IExtensionValue CreateValue()
+        {
+            return new ExtensionValue<TValue>(codec);
+        }
+    }
+
+    /// <summary>
+    /// Represents a type-safe extension identifier used for getting repeated extension values in <see cref="IExtendableMessage{T}"/> instances.
+    /// This API is experimental and subject to change.
+    /// </summary>
+    /// <typeparam name="TTarget">The message type this field applies to</typeparam>
+    /// <typeparam name="TValue">The repeated field value type of this extension</typeparam>
+    public sealed class RepeatedExtension<TTarget, TValue> : Extension where TTarget : IExtendableMessage<TTarget>
+    {
+        private readonly FieldCodec<TValue> codec;
+
+        /// <summary>
+        /// Creates a new repeated extension identifier with the specified field number and codec
+        /// </summary>
+        public RepeatedExtension(int fieldNumber, FieldCodec<TValue> codec) : base(fieldNumber)
+        {
+            this.codec = codec;
+        }
+
+        internal override Type TargetType => typeof(TTarget);
+
+        internal override bool IsRepeated => true;
+
+        internal override IExtensionValue CreateValue()
+        {
+            return new RepeatedExtensionValue<TValue>(codec);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/ExtensionRegistry.cs b/Libs/Google.Protobuf/ExtensionRegistry.cs
new file mode 100644
index 0000000..44667db
--- /dev/null
+++ b/Libs/Google.Protobuf/ExtensionRegistry.cs
@@ -0,0 +1,184 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Provides extensions to messages while parsing. This API is experimental and subject to change.
+    /// </summary>
+    public sealed class ExtensionRegistry : ICollection<Extension>, IDeepCloneable<ExtensionRegistry>
+    {
+        internal sealed class ExtensionComparer : IEqualityComparer<Extension>
+        {
+            public bool Equals(Extension a, Extension b)
+            {
+                return new ObjectIntPair<Type>(a.TargetType, a.FieldNumber).Equals(new ObjectIntPair<Type>(b.TargetType, b.FieldNumber));
+            }
+            public int GetHashCode(Extension a)
+            {
+                return new ObjectIntPair<Type>(a.TargetType, a.FieldNumber).GetHashCode();
+            }
+
+            internal static ExtensionComparer Instance = new ExtensionComparer();
+        }
+        private IDictionary<ObjectIntPair<Type>, Extension> extensions;
+
+        /// <summary>
+        /// Creates a new empty extension registry
+        /// </summary>
+        public ExtensionRegistry()
+        {
+            extensions = new Dictionary<ObjectIntPair<Type>, Extension>();
+        }
+
+        private ExtensionRegistry(IDictionary<ObjectIntPair<Type>, Extension> collection)
+        {
+            extensions = collection.ToDictionary(k => k.Key, v => v.Value);
+        }
+
+        /// <summary>
+        /// Gets the total number of extensions in this extension registry
+        /// </summary>
+        public int Count => extensions.Count;
+
+        /// <summary>
+        /// Returns whether the registry is readonly
+        /// </summary>
+        bool ICollection<Extension>.IsReadOnly => false;
+
+        internal bool ContainsInputField(uint lastTag, Type target, out Extension extension)
+        {
+            return extensions.TryGetValue(new ObjectIntPair<Type>(target, WireFormat.GetTagFieldNumber(lastTag)), out extension);
+        }
+
+        /// <summary>
+        /// Adds the specified extension to the registry
+        /// </summary>
+        public void Add(Extension extension)
+        {
+            ProtoPreconditions.CheckNotNull(extension, nameof(extension));
+
+            extensions.Add(new ObjectIntPair<Type>(extension.TargetType, extension.FieldNumber), extension);
+        }
+
+        /// <summary>
+        /// Adds the specified extensions to the registry
+        /// </summary>
+        public void AddRange(IEnumerable<Extension> extensions)
+        {
+            ProtoPreconditions.CheckNotNull(extensions, nameof(extensions));
+
+            foreach (var extension in extensions)
+            {
+                Add(extension);
+            }
+        }
+
+        /// <summary>
+        /// Clears the registry of all values
+        /// </summary>
+        public void Clear()
+        {
+            extensions.Clear();
+        }
+
+        /// <summary>
+        /// Gets whether the extension registry contains the specified extension
+        /// </summary>
+        public bool Contains(Extension item)
+        {
+            ProtoPreconditions.CheckNotNull(item, nameof(item));
+
+            return extensions.ContainsKey(new ObjectIntPair<Type>(item.TargetType, item.FieldNumber));
+        }
+
+        /// <summary>
+        /// Copies the arrays in the registry set to the specified array at the specified index
+        /// </summary>
+        /// <param name="array">The array to copy to</param>
+        /// <param name="arrayIndex">The array index to start at</param>
+        void ICollection<Extension>.CopyTo(Extension[] array, int arrayIndex)
+        {
+            ProtoPreconditions.CheckNotNull(array, nameof(array));
+            if (arrayIndex < 0 || arrayIndex >= array.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+            }
+            if (array.Length - arrayIndex < Count)
+            {
+                throw new ArgumentException("The provided array is shorter than the number of elements in the registry");
+            }
+
+            for (int i = 0; i < array.Length; i++)
+            {
+                Extension extension = array[i];
+                extensions.Add(new ObjectIntPair<Type>(extension.TargetType, extension.FieldNumber), extension);
+            }
+        }
+
+        /// <summary>
+        /// Returns an enumerator to enumerate through the items in the registry
+        /// </summary>
+        /// <returns>Returns an enumerator for the extensions in this registry</returns>
+        public IEnumerator<Extension> GetEnumerator()
+        {
+            return extensions.Values.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Removes the specified extension from the set
+        /// </summary>
+        /// <param name="item">The extension</param>
+        /// <returns><c>true</c> if the extension was removed, otherwise <c>false</c></returns>
+        public bool Remove(Extension item)
+        {
+            ProtoPreconditions.CheckNotNull(item, nameof(item));
+
+            return extensions.Remove(new ObjectIntPair<Type>(item.TargetType, item.FieldNumber));
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary>
+        /// Clones the registry into a new registry
+        /// </summary>
+        public ExtensionRegistry Clone()
+        {
+            return new ExtensionRegistry(extensions);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/ExtensionSet.cs b/Libs/Google.Protobuf/ExtensionSet.cs
new file mode 100644
index 0000000..1f1917b
--- /dev/null
+++ b/Libs/Google.Protobuf/ExtensionSet.cs
@@ -0,0 +1,377 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Methods for managing <see cref="ExtensionSet{TTarget}"/>s with null checking.
+    /// 
+    /// Most users will not use this class directly and its API is experimental and subject to change.
+    /// </summary>
+    public static class ExtensionSet
+    {
+        private static bool TryGetValue<TTarget>(ref ExtensionSet<TTarget> set, Extension extension, out IExtensionValue value) where TTarget : IExtendableMessage<TTarget>
+        {
+            if (set == null)
+            {
+                value = null;
+                return false;
+            }
+            return set.ValuesByNumber.TryGetValue(extension.FieldNumber, out value);
+        }
+
+        /// <summary>
+        /// Gets the value of the specified extension
+        /// </summary>
+        public static TValue Get<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
+        {
+            IExtensionValue value;
+            if (TryGetValue(ref set, extension, out value))
+            {
+                return ((ExtensionValue<TValue>)value).GetValue();
+            }
+            else 
+            {
+                return extension.DefaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Gets the value of the specified repeated extension or null if it doesn't exist in this set
+        /// </summary>
+        public static RepeatedField<TValue> Get<TTarget, TValue>(ref ExtensionSet<TTarget> set, RepeatedExtension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
+        {
+            IExtensionValue value;
+            if (TryGetValue(ref set, extension, out value))
+            {
+                return ((RepeatedExtensionValue<TValue>)value).GetValue();
+            }
+            else 
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the value of the specified repeated extension, registering it if it doesn't exist
+        /// </summary>
+        public static RepeatedField<TValue> GetOrInitialize<TTarget, TValue>(ref ExtensionSet<TTarget> set, RepeatedExtension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
+        {
+            IExtensionValue value;
+            if (set == null)
+            {
+                value = extension.CreateValue();
+                set = new ExtensionSet<TTarget>();
+                set.ValuesByNumber.Add(extension.FieldNumber, value);
+            }
+            else
+            {
+                if (!set.ValuesByNumber.TryGetValue(extension.FieldNumber, out value))
+                {
+                    value = extension.CreateValue();
+                    set.ValuesByNumber.Add(extension.FieldNumber, value);
+                }
+            }
+
+            return ((RepeatedExtensionValue<TValue>)value).GetValue();
+        }
+
+        /// <summary>
+        /// Sets the value of the specified extension. This will make a new instance of ExtensionSet if the set is null.
+        /// </summary>
+        public static void Set<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension, TValue value) where TTarget : IExtendableMessage<TTarget>
+        {
+            ProtoPreconditions.CheckNotNullUnconstrained(value, nameof(value));
+
+            IExtensionValue extensionValue;
+            if (set == null)
+            {
+                extensionValue = extension.CreateValue();
+                set = new ExtensionSet<TTarget>();
+                set.ValuesByNumber.Add(extension.FieldNumber, extensionValue);
+            }
+            else
+            {
+                if (!set.ValuesByNumber.TryGetValue(extension.FieldNumber, out extensionValue))
+                {
+                    extensionValue = extension.CreateValue();
+                    set.ValuesByNumber.Add(extension.FieldNumber, extensionValue);
+                }
+            }
+            
+            ((ExtensionValue<TValue>)extensionValue).SetValue(value);
+        }
+
+        /// <summary>
+        /// Gets whether the value of the specified extension is set
+        /// </summary>
+        public static bool Has<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
+        {
+            IExtensionValue value;
+            return TryGetValue(ref set, extension, out value);
+        }
+
+        /// <summary>
+        /// Clears the value of the specified extension
+        /// </summary>
+        public static void Clear<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
+        {
+            if (set == null)
+            {
+                return;
+            }
+            set.ValuesByNumber.Remove(extension.FieldNumber);
+            if (set.ValuesByNumber.Count == 0)
+            {
+                set = null;
+            }
+        }
+
+        /// <summary>
+        /// Clears the value of the specified extension
+        /// </summary>
+        public static void Clear<TTarget, TValue>(ref ExtensionSet<TTarget> set, RepeatedExtension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
+        {
+            if (set == null)
+            {
+                return;
+            }
+            set.ValuesByNumber.Remove(extension.FieldNumber);
+            if (set.ValuesByNumber.Count == 0)
+            {
+                set = null;
+            }
+        }
+
+        /// <summary>
+        /// Tries to merge a field from the coded input, returning true if the field was merged.
+        /// If the set is null or the field was not otherwise merged, this returns false.
+        /// </summary>
+        public static bool TryMergeFieldFrom<TTarget>(ref ExtensionSet<TTarget> set, CodedInputStream stream) where TTarget : IExtendableMessage<TTarget>
+        {
+            ParseContext.Initialize(stream, out ParseContext ctx);
+            try
+            {
+                return TryMergeFieldFrom<TTarget>(ref set, ref ctx);
+            }
+            finally
+            {
+                ctx.CopyStateTo(stream);
+            }
+        }
+
+        /// <summary>
+        /// Tries to merge a field from the coded input, returning true if the field was merged.
+        /// If the set is null or the field was not otherwise merged, this returns false.
+        /// </summary>
+        public static bool TryMergeFieldFrom<TTarget>(ref ExtensionSet<TTarget> set, ref ParseContext ctx) where TTarget : IExtendableMessage<TTarget>
+        {
+            Extension extension;
+            int lastFieldNumber = WireFormat.GetTagFieldNumber(ctx.LastTag);
+
+            IExtensionValue extensionValue;
+            if (set != null && set.ValuesByNumber.TryGetValue(lastFieldNumber, out extensionValue))
+            {
+                extensionValue.MergeFrom(ref ctx);
+                return true;
+            }
+            else if (ctx.ExtensionRegistry != null && ctx.ExtensionRegistry.ContainsInputField(ctx.LastTag, typeof(TTarget), out extension))
+            {
+                IExtensionValue value = extension.CreateValue();
+                value.MergeFrom(ref ctx);
+                set = (set ?? new ExtensionSet<TTarget>());
+                set.ValuesByNumber.Add(extension.FieldNumber, value);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Merges the second set into the first set, creating a new instance if first is null
+        /// </summary>
+        public static void MergeFrom<TTarget>(ref ExtensionSet<TTarget> first, ExtensionSet<TTarget> second) where TTarget : IExtendableMessage<TTarget>
+        {
+            if (second == null)
+            {
+                return;
+            }
+            if (first == null)
+            {
+                first = new ExtensionSet<TTarget>();
+            }
+            foreach (var pair in second.ValuesByNumber)
+            {
+                IExtensionValue value;
+                if (first.ValuesByNumber.TryGetValue(pair.Key, out value))
+                {
+                    value.MergeFrom(pair.Value);
+                }
+                else
+                {
+                    var cloned = pair.Value.Clone();
+                    first.ValuesByNumber[pair.Key] = cloned;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Clones the set into a new set. If the set is null, this returns null
+        /// </summary>
+        public static ExtensionSet<TTarget> Clone<TTarget>(ExtensionSet<TTarget> set) where TTarget : IExtendableMessage<TTarget>
+        {
+            if (set == null)
+            {
+                return null;
+            }
+
+            var newSet = new ExtensionSet<TTarget>();
+            foreach (var pair in set.ValuesByNumber)
+            {
+                var cloned = pair.Value.Clone();
+                newSet.ValuesByNumber[pair.Key] = cloned;
+            }
+            return newSet;
+        }
+    }
+
+    /// <summary>
+    /// Used for keeping track of extensions in messages. 
+    /// <see cref="IExtendableMessage{T}"/> methods route to this set.
+    /// 
+    /// Most users will not need to use this class directly
+    /// </summary>
+    /// <typeparam name="TTarget">The message type that extensions in this set target</typeparam>
+    public sealed class ExtensionSet<TTarget> where TTarget : IExtendableMessage<TTarget>
+    {
+        internal Dictionary<int, IExtensionValue> ValuesByNumber { get; } = new Dictionary<int, IExtensionValue>();
+
+        /// <summary>
+        /// Gets a hash code of the set
+        /// </summary>
+        public override int GetHashCode()
+        {
+            int ret = typeof(TTarget).GetHashCode();
+            foreach (KeyValuePair<int, IExtensionValue> field in ValuesByNumber)
+            {
+                // Use ^ here to make the field order irrelevant.
+                int hash = field.Key.GetHashCode() ^ field.Value.GetHashCode();
+                ret ^= hash;
+            }
+            return ret;
+        }
+
+        /// <summary>
+        /// Returns whether this set is equal to the other object
+        /// </summary>
+        public override bool Equals(object other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+            ExtensionSet<TTarget> otherSet = other as ExtensionSet<TTarget>;
+            if (ValuesByNumber.Count != otherSet.ValuesByNumber.Count)
+            {
+                return false;
+            }
+            foreach (var pair in ValuesByNumber)
+            {
+                IExtensionValue secondValue;
+                if (!otherSet.ValuesByNumber.TryGetValue(pair.Key, out secondValue))
+                {
+                    return false;
+                }
+                if (!pair.Value.Equals(secondValue))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Calculates the size of this extension set
+        /// </summary>
+        public int CalculateSize()
+        {
+            int size = 0;
+            foreach (var value in ValuesByNumber.Values)
+            {
+                size += value.CalculateSize();
+            }
+            return size;
+        }
+
+        /// <summary>
+        /// Writes the extension values in this set to the output stream
+        /// </summary>
+        public void WriteTo(CodedOutputStream stream)
+        {
+            
+            WriteContext.Initialize(stream, out WriteContext ctx);
+            try
+            {
+                WriteTo(ref ctx);
+            }
+            finally
+            {
+                ctx.CopyStateTo(stream);
+            }
+        }
+
+        /// <summary>
+        /// Writes the extension values in this set to the write context
+        /// </summary>
+        [SecuritySafeCritical]
+        public void WriteTo(ref WriteContext ctx)
+        {
+            foreach (var value in ValuesByNumber.Values)
+            {
+                value.WriteTo(ref ctx);
+            }
+        }
+
+        internal bool IsInitialized()
+        {
+            return ValuesByNumber.Values.All(v => v.IsInitialized());
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/ExtensionValue.cs b/Libs/Google.Protobuf/ExtensionValue.cs
new file mode 100644
index 0000000..2b35159
--- /dev/null
+++ b/Libs/Google.Protobuf/ExtensionValue.cs
@@ -0,0 +1,225 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+using System.Linq;
+
+namespace LC.Google.Protobuf
+{
+    internal interface IExtensionValue : IEquatable<IExtensionValue>, IDeepCloneable<IExtensionValue>
+    {
+        void MergeFrom(ref ParseContext ctx);
+
+        void MergeFrom(IExtensionValue value);
+        void WriteTo(ref WriteContext ctx);
+        int CalculateSize();
+        bool IsInitialized();
+    }
+
+    internal sealed class ExtensionValue<T> : IExtensionValue
+    {
+        private T field;
+        private FieldCodec<T> codec;
+
+        internal ExtensionValue(FieldCodec<T> codec)
+        {
+            this.codec = codec;
+            field = codec.DefaultValue;
+        }
+
+        public int CalculateSize()
+        {
+            return codec.CalculateUnconditionalSizeWithTag(field);
+        }
+
+        public IExtensionValue Clone()
+        {
+            return new ExtensionValue<T>(codec)
+            {
+                field = field is IDeepCloneable<T> ? (field as IDeepCloneable<T>).Clone() : field
+            };
+        }
+
+        public bool Equals(IExtensionValue other)
+        {
+            if (ReferenceEquals(this, other))
+                return true;
+
+            return other is ExtensionValue<T>
+                && codec.Equals((other as ExtensionValue<T>).codec)
+                && Equals(field, (other as ExtensionValue<T>).field);
+            // we check for equality in the codec since we could have equal field values however the values could be written in different ways
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 31 + field.GetHashCode();
+                hash = hash * 31 + codec.GetHashCode();
+                return hash;
+            }
+        }
+
+        public void MergeFrom(ref ParseContext ctx)
+        {
+            codec.ValueMerger(ref ctx, ref field);
+        }
+
+        public void MergeFrom(IExtensionValue value)
+        {
+            if (value is ExtensionValue<T>)
+            {
+                var extensionValue = value as ExtensionValue<T>;
+                codec.FieldMerger(ref field, extensionValue.field);
+            }
+        }
+
+        public void WriteTo(ref WriteContext ctx)
+        {
+            ctx.WriteTag(codec.Tag);
+            codec.ValueWriter(ref ctx, field);
+            if (codec.EndTag != 0)
+            {
+                ctx.WriteTag(codec.EndTag);
+            }
+        }
+
+        public T GetValue() => field;
+
+        public void SetValue(T value)
+        {
+            field = value;
+        }
+
+        public bool IsInitialized()
+        {
+            if (field is IMessage)
+            {
+                return (field as IMessage).IsInitialized();
+            }
+            else
+            {
+                return true;
+            }
+        }
+    }
+
+    internal sealed class RepeatedExtensionValue<T> : IExtensionValue
+    {
+        private RepeatedField<T> field;
+        private readonly FieldCodec<T> codec;
+
+        internal RepeatedExtensionValue(FieldCodec<T> codec)
+        {
+            this.codec = codec;
+            field = new RepeatedField<T>();
+        }
+
+        public int CalculateSize()
+        {
+            return field.CalculateSize(codec);
+        }
+
+        public IExtensionValue Clone()
+        {
+            return new RepeatedExtensionValue<T>(codec)
+            {
+                field = field.Clone()
+            };
+        }
+
+        public bool Equals(IExtensionValue other)
+        {
+            if (ReferenceEquals(this, other))
+                return true;
+
+            return other is RepeatedExtensionValue<T> 
+                && field.Equals((other as RepeatedExtensionValue<T>).field) 
+                && codec.Equals((other as RepeatedExtensionValue<T>).codec);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 31 + field.GetHashCode();
+                hash = hash * 31 + codec.GetHashCode();
+                return hash;
+            }
+        }
+
+        public void MergeFrom(ref ParseContext ctx)
+        {
+            field.AddEntriesFrom(ref ctx, codec);
+        }
+
+        public void MergeFrom(IExtensionValue value)
+        {
+            if (value is RepeatedExtensionValue<T>)
+            {
+                field.Add((value as RepeatedExtensionValue<T>).field);
+            }
+        }
+
+        public void WriteTo(ref WriteContext ctx)
+        {
+            field.WriteTo(ref ctx, codec);
+        }
+
+        public RepeatedField<T> GetValue() => field;
+
+        public bool IsInitialized()
+        {
+            for (int i = 0; i < field.Count; i++)
+            {
+                var element = field[i];
+                if (element is IMessage)
+                {
+                    if (!(element as IMessage).IsInitialized())
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/FieldCodec.cs b/Libs/Google.Protobuf/FieldCodec.cs
new file mode 100644
index 0000000..b2447ac
--- /dev/null
+++ b/Libs/Google.Protobuf/FieldCodec.cs
@@ -0,0 +1,887 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using LC.Google.Protobuf.Compatibility;
+using LC.Google.Protobuf.WellKnownTypes;
+using System;
+using System.Collections.Generic;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Factory methods for <see cref="FieldCodec{T}"/>.
+    /// </summary>
+    public static class FieldCodec
+    {
+        // TODO: Avoid the "dual hit" of lambda expressions: create open delegates instead. (At least test...)
+
+        /// <summary>
+        /// Retrieves a codec suitable for a string field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<string> ForString(uint tag)
+        {
+            return FieldCodec.ForString(tag, "");
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a bytes field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<ByteString> ForBytes(uint tag)
+        {
+            return FieldCodec.ForBytes(tag, ByteString.Empty);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a bool field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<bool> ForBool(uint tag)
+        {
+            return FieldCodec.ForBool(tag, false);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an int32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<int> ForInt32(uint tag)
+        {
+            return FieldCodec.ForInt32(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sint32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<int> ForSInt32(uint tag)
+        {
+            return FieldCodec.ForSInt32(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a fixed32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<uint> ForFixed32(uint tag)
+        {
+            return FieldCodec.ForFixed32(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sfixed32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<int> ForSFixed32(uint tag)
+        {
+            return FieldCodec.ForSFixed32(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a uint32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<uint> ForUInt32(uint tag)
+        {
+            return FieldCodec.ForUInt32(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an int64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<long> ForInt64(uint tag)
+        {
+            return FieldCodec.ForInt64(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sint64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<long> ForSInt64(uint tag)
+        {
+            return FieldCodec.ForSInt64(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a fixed64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<ulong> ForFixed64(uint tag)
+        {
+            return FieldCodec.ForFixed64(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sfixed64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<long> ForSFixed64(uint tag)
+        {
+            return FieldCodec.ForSFixed64(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a uint64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<ulong> ForUInt64(uint tag)
+        {
+            return FieldCodec.ForUInt64(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a float field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<float> ForFloat(uint tag)
+        {
+            return FieldCodec.ForFloat(tag, 0);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a double field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<double> ForDouble(uint tag)
+        {
+            return FieldCodec.ForDouble(tag, 0);
+        }
+
+        // Enums are tricky. We can probably use expression trees to build these delegates automatically,
+        // but it's easy to generate the code for it.
+
+        /// <summary>
+        /// Retrieves a codec suitable for an enum field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="toInt32">A conversion function from <see cref="Int32"/> to the enum type.</param>
+        /// <param name="fromInt32">A conversion function from the enum type to <see cref="Int32"/>.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<T> ForEnum<T>(uint tag, Func<T, int> toInt32, Func<int, T> fromInt32)
+        {
+            return FieldCodec.ForEnum(tag, toInt32, fromInt32, default(T));
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a string field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<string> ForString(uint tag, string defaultValue)
+        {
+            return new FieldCodec<string>((ref ParseContext ctx) => ctx.ReadString(), (ref WriteContext ctx, string value) => ctx.WriteString(value), CodedOutputStream.ComputeStringSize, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a bytes field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<ByteString> ForBytes(uint tag, ByteString defaultValue)
+        {
+            return new FieldCodec<ByteString>((ref ParseContext ctx) => ctx.ReadBytes(), (ref WriteContext ctx, ByteString value) => ctx.WriteBytes(value), CodedOutputStream.ComputeBytesSize, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a bool field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<bool> ForBool(uint tag, bool defaultValue)
+        {
+            return new FieldCodec<bool>((ref ParseContext ctx) => ctx.ReadBool(), (ref WriteContext ctx, bool value) => ctx.WriteBool(value), CodedOutputStream.BoolSize, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an int32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<int> ForInt32(uint tag, int defaultValue)
+        {
+            return new FieldCodec<int>((ref ParseContext ctx) => ctx.ReadInt32(), (ref WriteContext output, int value) => output.WriteInt32(value), CodedOutputStream.ComputeInt32Size, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sint32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<int> ForSInt32(uint tag, int defaultValue)
+        {
+            return new FieldCodec<int>((ref ParseContext ctx) => ctx.ReadSInt32(), (ref WriteContext output, int value) => output.WriteSInt32(value), CodedOutputStream.ComputeSInt32Size, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a fixed32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<uint> ForFixed32(uint tag, uint defaultValue)
+        {
+            return new FieldCodec<uint>((ref ParseContext ctx) => ctx.ReadFixed32(), (ref WriteContext output, uint value) => output.WriteFixed32(value), 4, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sfixed32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<int> ForSFixed32(uint tag, int defaultValue)
+        {
+            return new FieldCodec<int>((ref ParseContext ctx) => ctx.ReadSFixed32(), (ref WriteContext output, int value) => output.WriteSFixed32(value), 4, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a uint32 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<uint> ForUInt32(uint tag, uint defaultValue)
+        {
+            return new FieldCodec<uint>((ref ParseContext ctx) => ctx.ReadUInt32(), (ref WriteContext output, uint value) => output.WriteUInt32(value), CodedOutputStream.ComputeUInt32Size, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an int64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<long> ForInt64(uint tag, long defaultValue)
+        {
+            return new FieldCodec<long>((ref ParseContext ctx) => ctx.ReadInt64(), (ref WriteContext output, long value) => output.WriteInt64(value), CodedOutputStream.ComputeInt64Size, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sint64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<long> ForSInt64(uint tag, long defaultValue)
+        {
+            return new FieldCodec<long>((ref ParseContext ctx) => ctx.ReadSInt64(), (ref WriteContext output, long value) => output.WriteSInt64(value), CodedOutputStream.ComputeSInt64Size, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a fixed64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<ulong> ForFixed64(uint tag, ulong defaultValue)
+        {
+            return new FieldCodec<ulong>((ref ParseContext ctx) => ctx.ReadFixed64(), (ref WriteContext output, ulong value) => output.WriteFixed64(value), 8, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for an sfixed64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<long> ForSFixed64(uint tag, long defaultValue)
+        {
+            return new FieldCodec<long>((ref ParseContext ctx) => ctx.ReadSFixed64(), (ref WriteContext output, long value) => output.WriteSFixed64(value), 8, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a uint64 field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<ulong> ForUInt64(uint tag, ulong defaultValue)
+        {
+            return new FieldCodec<ulong>((ref ParseContext ctx) => ctx.ReadUInt64(), (ref WriteContext output, ulong value) => output.WriteUInt64(value), CodedOutputStream.ComputeUInt64Size, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a float field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<float> ForFloat(uint tag, float defaultValue)
+        {
+            return new FieldCodec<float>((ref ParseContext ctx) => ctx.ReadFloat(), (ref WriteContext output, float value) => output.WriteFloat(value), CodedOutputStream.FloatSize, tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a double field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<double> ForDouble(uint tag, double defaultValue)
+        {
+            return new FieldCodec<double>((ref ParseContext ctx) => ctx.ReadDouble(), (ref WriteContext output, double value) => output.WriteDouble(value), CodedOutputStream.DoubleSize, tag, defaultValue);
+        }
+
+        // Enums are tricky. We can probably use expression trees to build these delegates automatically,
+        // but it's easy to generate the code for it.
+
+        /// <summary>
+        /// Retrieves a codec suitable for an enum field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="toInt32">A conversion function from <see cref="Int32"/> to the enum type.</param>
+        /// <param name="fromInt32">A conversion function from the enum type to <see cref="Int32"/>.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<T> ForEnum<T>(uint tag, Func<T, int> toInt32, Func<int, T> fromInt32, T defaultValue)
+        {
+            return new FieldCodec<T>((ref ParseContext ctx) => fromInt32(
+                ctx.ReadEnum()),
+                (ref WriteContext output, T value) => output.WriteEnum(toInt32(value)),
+                value => CodedOutputStream.ComputeEnumSize(toInt32(value)), tag, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a message field with the given tag.
+        /// </summary>
+        /// <param name="tag">The tag.</param>
+        /// <param name="parser">A parser to use for the message type.</param>
+        /// <returns>A codec for the given tag.</returns>
+        public static FieldCodec<T> ForMessage<T>(uint tag, MessageParser<T> parser) where T : class, IMessage<T>
+        {
+            return new FieldCodec<T>(
+                (ref ParseContext ctx) => 
+                { 
+                    T message = parser.CreateTemplate(); 
+                    ctx.ReadMessage(message); 
+                    return message; 
+                },
+                (ref WriteContext output, T value) => output.WriteMessage(value),
+                (ref ParseContext ctx, ref T v) => 
+                {
+                    if (v == null)
+                    {
+                        v = parser.CreateTemplate();
+                    }
+
+                    ctx.ReadMessage(v);
+                },
+                (ref T v, T v2) =>
+                {
+                    if (v2 == null)
+                    {
+                        return false;
+                    }
+                    else if (v == null)
+                    {
+                        v = v2.Clone();
+                    }
+                    else
+                    {
+                        v.MergeFrom(v2);
+                    }
+                    return true;
+                }, 
+                message => CodedOutputStream.ComputeMessageSize(message), tag);
+        }
+
+        /// <summary>
+        /// Retrieves a codec suitable for a group field with the given tag.
+        /// </summary>
+        /// <param name="startTag">The start group tag.</param>
+        /// <param name="endTag">The end group tag.</param>
+        /// <param name="parser">A parser to use for the group message type.</param>
+        /// <returns>A codec for given tag</returns>
+        public static FieldCodec<T> ForGroup<T>(uint startTag, uint endTag, MessageParser<T> parser) where T : class, IMessage<T>
+        {
+            return new FieldCodec<T>(
+                (ref ParseContext ctx) => 
+                { 
+                    T message = parser.CreateTemplate();
+                    ctx.ReadGroup(message);
+                    return message;
+                },
+                (ref WriteContext output, T value) => output.WriteGroup(value), 
+                (ref ParseContext ctx, ref T v) => 
+                {
+                    if (v == null)
+                    {
+                        v = parser.CreateTemplate();
+                    }
+
+                    ctx.ReadGroup(v);
+                },
+                (ref T v, T v2) =>
+                {
+                    if (v2 == null)
+                    {
+                        return v == null;
+                    }
+                    else if (v == null)
+                    {
+                        v = v2.Clone();
+                    }
+                    else
+                    {
+                        v.MergeFrom(v2);
+                    }
+                    return true;
+                }, 
+                message => CodedOutputStream.ComputeGroupSize(message), startTag, endTag);
+        }
+
+        /// <summary>
+        /// Creates a codec for a wrapper type of a class - which must be string or ByteString.
+        /// </summary>
+        public static FieldCodec<T> ForClassWrapper<T>(uint tag) where T : class
+        {
+            var nestedCodec = WrapperCodecs.GetCodec<T>();
+            return new FieldCodec<T>(
+                (ref ParseContext ctx) => WrapperCodecs.Read<T>(ref ctx, nestedCodec),
+                (ref WriteContext output, T value) => WrapperCodecs.Write<T>(ref output, value, nestedCodec),
+                (ref ParseContext ctx, ref T v) => v = WrapperCodecs.Read<T>(ref ctx, nestedCodec),
+                (ref T v, T v2) => { v = v2; return v == null; },
+                value => WrapperCodecs.CalculateSize<T>(value, nestedCodec),
+                tag, 0,
+                null); // Default value for the wrapper
+        }
+
+        /// <summary>
+        /// Creates a codec for a wrapper type of a struct - which must be Int32, Int64, UInt32, UInt64,
+        /// Bool, Single or Double.
+        /// </summary>
+        public static FieldCodec<T?> ForStructWrapper<T>(uint tag) where T : struct
+        {
+            var nestedCodec = WrapperCodecs.GetCodec<T>();
+            return new FieldCodec<T?>(
+                WrapperCodecs.GetReader<T>(),
+                (ref WriteContext output, T? value) => WrapperCodecs.Write<T>(ref output, value.Value, nestedCodec),
+                (ref ParseContext ctx, ref T? v) => v = WrapperCodecs.Read<T>(ref ctx, nestedCodec),
+                (ref T? v, T? v2) => { if (v2.HasValue) { v = v2; } return v.HasValue; },
+                value => value == null ? 0 : WrapperCodecs.CalculateSize<T>(value.Value, nestedCodec),
+                tag, 0,
+                null); // Default value for the wrapper
+        }
+
+        /// <summary>
+        /// Helper code to create codecs for wrapper types.
+        /// </summary>
+        /// <remarks>
+        /// Somewhat ugly with all the static methods, but the conversions involved to/from nullable types make it
+        /// slightly tricky to improve. So long as we keep the public API (ForClassWrapper, ForStructWrapper) in place,
+        /// we can refactor later if we come up with something cleaner.
+        /// </remarks>
+        private static class WrapperCodecs
+        {
+            private static readonly Dictionary<System.Type, object> Codecs = new Dictionary<System.Type, object>
+            {
+                { typeof(bool), ForBool(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+                { typeof(int), ForInt32(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+                { typeof(long), ForInt64(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+                { typeof(uint), ForUInt32(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+                { typeof(ulong), ForUInt64(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+                { typeof(float), ForFloat(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Fixed32)) },
+                { typeof(double), ForDouble(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.Fixed64)) },
+                { typeof(string), ForString(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.LengthDelimited)) },
+                { typeof(ByteString), ForBytes(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.LengthDelimited)) }
+            };
+
+            private static readonly Dictionary<System.Type, object> Readers = new Dictionary<System.Type, object>
+            {
+                // TODO: Provide more optimized readers.
+                { typeof(bool), (ValueReader<bool?>)ParsingPrimitivesWrappers.ReadBoolWrapper },
+                { typeof(int), (ValueReader<int?>)ParsingPrimitivesWrappers.ReadInt32Wrapper },
+                { typeof(long), (ValueReader<long?>)ParsingPrimitivesWrappers.ReadInt64Wrapper },
+                { typeof(uint), (ValueReader<uint?>)ParsingPrimitivesWrappers.ReadUInt32Wrapper },
+                { typeof(ulong), (ValueReader<ulong?>)ParsingPrimitivesWrappers.ReadUInt64Wrapper },
+                { typeof(float), BitConverter.IsLittleEndian ?
+                    (ValueReader<float?>)ParsingPrimitivesWrappers.ReadFloatWrapperLittleEndian :
+                    (ValueReader<float?>)ParsingPrimitivesWrappers.ReadFloatWrapperSlow },
+                { typeof(double), BitConverter.IsLittleEndian ?
+                    (ValueReader<double?>)ParsingPrimitivesWrappers.ReadDoubleWrapperLittleEndian :
+                    (ValueReader<double?>)ParsingPrimitivesWrappers.ReadDoubleWrapperSlow },
+                // `string` and `ByteString` less performance-sensitive. Do not implement for now.
+                { typeof(string), null },
+                { typeof(ByteString), null },
+            };
+
+            /// <summary>
+            /// Returns a field codec which effectively wraps a value of type T in a message.
+            ///
+            /// </summary>
+            internal static FieldCodec<T> GetCodec<T>()
+            {
+                object value;
+                if (!Codecs.TryGetValue(typeof(T), out value))
+                {
+                    throw new InvalidOperationException("Invalid type argument requested for wrapper codec: " + typeof(T));
+                }
+                return (FieldCodec<T>) value;
+            }
+
+            internal static ValueReader<T?> GetReader<T>() where T : struct
+            {
+                object value;
+                if (!Readers.TryGetValue(typeof(T), out value))
+                {
+                    throw new InvalidOperationException("Invalid type argument requested for wrapper reader: " + typeof(T));
+                }
+                if (value == null)
+                {
+                    // Return default unoptimized reader for the wrapper type.
+                    var nestedCoded = GetCodec<T>();
+                    return (ref ParseContext ctx) => Read<T>(ref ctx, nestedCoded);
+                }
+                // Return optimized read for the wrapper type.
+                return (ValueReader<T?>)value;
+            }
+
+            [SecuritySafeCritical]
+            internal static T Read<T>(ref ParseContext ctx, FieldCodec<T> codec)
+            {
+                int length = ctx.ReadLength();
+                int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, length);
+
+                uint tag;
+                T value = codec.DefaultValue;
+                while ((tag = ctx.ReadTag()) != 0)
+                {
+                    if (tag == codec.Tag)
+                    {
+                        value = codec.Read(ref ctx);
+                    }
+                    else
+                    {
+                        ParsingPrimitivesMessages.SkipLastField(ref ctx.buffer, ref ctx.state);
+                    }
+
+                }
+                ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref ctx.state);
+                SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
+
+                return value;
+            }
+
+            internal static void Write<T>(ref WriteContext ctx, T value, FieldCodec<T> codec)
+            {
+                ctx.WriteLength(codec.CalculateSizeWithTag(value));
+                codec.WriteTagAndValue(ref ctx, value);
+            }
+
+            internal  static int CalculateSize<T>(T value, FieldCodec<T> codec)
+            {
+                int fieldLength = codec.CalculateSizeWithTag(value);
+                return CodedOutputStream.ComputeLengthSize(fieldLength) + fieldLength;
+            }
+        }
+    }
+
+    internal delegate TValue ValueReader<out TValue>(ref ParseContext ctx);
+    internal delegate void ValueWriter<T>(ref WriteContext ctx, T value);
+
+    /// <summary>
+    /// <para>
+    /// An encode/decode pair for a single field. This effectively encapsulates
+    /// all the information needed to read or write the field value from/to a coded
+    /// stream.
+    /// </para>
+    /// <para>
+    /// This class is public and has to be as it is used by generated code, but its public
+    /// API is very limited - just what the generated code needs to call directly.
+    /// </para>
+    /// </summary>
+    /// <remarks>
+    /// This never writes default values to the stream, and does not address "packedness"
+    /// in repeated fields itself, other than to know whether or not the field *should* be packed.
+    /// </remarks>
+    public sealed class FieldCodec<T>
+    {
+        private static readonly EqualityComparer<T> EqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<T>();
+        private static readonly T DefaultDefault;
+        // Only non-nullable value types support packing. This is the simplest way of detecting that.
+        private static readonly bool TypeSupportsPacking = default(T) != null;
+
+        /// <summary>
+        /// Merges an input stream into a value
+        /// </summary>
+        internal delegate void InputMerger(ref ParseContext ctx, ref T value);
+
+        /// <summary>
+        /// Merges a value into a reference to another value, returning a boolean if the value was set
+        /// </summary>
+        internal delegate bool ValuesMerger(ref T value, T other);
+
+        static FieldCodec()
+        {
+            if (typeof(T) == typeof(string))
+            {
+                DefaultDefault = (T)(object)"";
+            }
+            else if (typeof(T) == typeof(ByteString))
+            {
+                DefaultDefault = (T)(object)ByteString.Empty;
+            }
+            // Otherwise it's the default value of the CLR type
+        }
+
+        internal static bool IsPackedRepeatedField(uint tag) =>
+            TypeSupportsPacking && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited;
+
+        internal bool PackedRepeatedField { get; }
+
+        /// <summary>
+        /// Returns a delegate to write a value (unconditionally) to a coded output stream.
+        /// </summary>
+        internal ValueWriter<T> ValueWriter { get; }
+
+        /// <summary>
+        /// Returns the size calculator for just a value.
+        /// </summary>
+        internal Func<T, int> ValueSizeCalculator { get; }
+
+        /// <summary>
+        /// Returns a delegate to read a value from a coded input stream. It is assumed that
+        /// the stream is already positioned on the appropriate tag.
+        /// </summary>
+        internal ValueReader<T> ValueReader { get; }
+
+        /// <summary>
+        /// Returns a delegate to merge a value from a coded input stream.
+        /// It is assumed that the stream is already positioned on the appropriate tag
+        /// </summary>
+        internal InputMerger ValueMerger { get; }
+
+        /// <summary>
+        /// Returns a delegate to merge two values together.
+        /// </summary>
+        internal ValuesMerger FieldMerger { get; }
+
+        /// <summary>
+        /// Returns the fixed size for an entry, or 0 if sizes vary.
+        /// </summary>
+        internal int FixedSize { get; }
+
+        /// <summary>
+        /// Gets the tag of the codec.
+        /// </summary>
+        /// <value>
+        /// The tag of the codec.
+        /// </value>
+        internal uint Tag { get; }
+
+        /// <summary>
+        /// Gets the end tag of the codec or 0 if there is no end tag
+        /// </summary>
+        /// <value>
+        /// The end tag of the codec.
+        /// </value>
+        internal uint EndTag { get; }
+
+        /// <summary>
+        /// Default value for this codec. Usually the same for every instance of the same type, but
+        /// for string/ByteString wrapper fields the codec's default value is null, whereas for
+        /// other string/ByteString fields it's "" or ByteString.Empty.
+        /// </summary>
+        /// <value>
+        /// The default value of the codec's type.
+        /// </value>
+        internal T DefaultValue { get; }
+
+        private readonly int tagSize;
+
+        internal FieldCodec(
+                ValueReader<T> reader,
+                ValueWriter<T> writer,
+                int fixedSize,
+                uint tag,
+                T defaultValue) : this(reader, writer, _ => fixedSize, tag, defaultValue)
+        {
+            FixedSize = fixedSize;
+        }
+
+        internal FieldCodec(
+            ValueReader<T> reader,
+            ValueWriter<T> writer,
+            Func<T, int> sizeCalculator,
+            uint tag,
+            T defaultValue) : this(reader, writer, (ref ParseContext ctx, ref T v) => v = reader(ref ctx), (ref T v, T v2) => { v = v2; return true; }, sizeCalculator, tag, 0, defaultValue)
+        {
+        }
+
+        internal FieldCodec(
+            ValueReader<T> reader,
+            ValueWriter<T> writer,
+            InputMerger inputMerger,
+            ValuesMerger valuesMerger,
+            Func<T, int> sizeCalculator,
+            uint tag,
+            uint endTag = 0) : this(reader, writer, inputMerger, valuesMerger, sizeCalculator, tag, endTag, DefaultDefault)
+        {
+        }
+
+        internal FieldCodec(
+            ValueReader<T> reader,
+            ValueWriter<T> writer,
+            InputMerger inputMerger,
+            ValuesMerger valuesMerger,
+            Func<T, int> sizeCalculator,
+            uint tag,
+            uint endTag,
+            T defaultValue)
+        {
+            ValueReader = reader;
+            ValueWriter = writer;
+            ValueMerger = inputMerger;
+            FieldMerger = valuesMerger;
+            ValueSizeCalculator = sizeCalculator;
+            FixedSize = 0;
+            Tag = tag;
+            EndTag = endTag;
+            DefaultValue = defaultValue;
+            tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
+            if (endTag != 0)
+                tagSize += CodedOutputStream.ComputeRawVarint32Size(endTag);
+            // Detect packed-ness once, so we can check for it within RepeatedField<T>.
+            PackedRepeatedField = IsPackedRepeatedField(tag);
+        }
+
+        /// <summary>
+        /// Write a tag and the given value, *if* the value is not the default.
+        /// </summary>
+        public void WriteTagAndValue(CodedOutputStream output, T value)
+        {
+            WriteContext.Initialize(output, out WriteContext ctx);
+            try
+            {
+                WriteTagAndValue(ref ctx, value);
+            }
+            finally
+            {
+                ctx.CopyStateTo(output);
+            }
+
+
+            //if (!IsDefault(value))
+            //{
+            //    output.WriteTag(Tag);
+            //    ValueWriter(output, value);
+            //    if (EndTag != 0)
+            //    {
+            //        output.WriteTag(EndTag);
+            //    }
+            //}
+        }
+
+        /// <summary>
+        /// Write a tag and the given value, *if* the value is not the default.
+        /// </summary>
+        public void WriteTagAndValue(ref WriteContext ctx, T value)
+        {
+            if (!IsDefault(value))
+            {
+                ctx.WriteTag(Tag);
+                ValueWriter(ref ctx, value);
+                if (EndTag != 0)
+                {
+                    ctx.WriteTag(EndTag);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads a value of the codec type from the given <see cref="CodedInputStream"/>.
+        /// </summary>
+        /// <param name="input">The input stream to read from.</param>
+        /// <returns>The value read from the stream.</returns>
+        public T Read(CodedInputStream input)
+        {
+            ParseContext.Initialize(input, out ParseContext ctx);
+            try
+            {
+                return ValueReader(ref ctx);
+            }
+            finally
+            {
+                ctx.CopyStateTo(input);
+            }
+        }
+
+        /// <summary>
+        /// Reads a value of the codec type from the given <see cref="ParseContext"/>.
+        /// </summary>
+        /// <param name="ctx">The parse context to read from.</param>
+        /// <returns>The value read.</returns>
+        public T Read(ref ParseContext ctx)
+        {
+            return ValueReader(ref ctx);
+        }
+
+        /// <summary>
+        /// Calculates the size required to write the given value, with a tag,
+        /// if the value is not the default.
+        /// </summary>
+        public int CalculateSizeWithTag(T value) => IsDefault(value) ? 0 : ValueSizeCalculator(value) + tagSize;
+
+        /// <summary>
+        /// Calculates the size required to write the given value, with a tag, even
+        /// if the value is the default.
+        /// </summary>
+        internal int CalculateUnconditionalSizeWithTag(T value) => ValueSizeCalculator(value) + tagSize;
+
+        private bool IsDefault(T value) => EqualityComparer.Equals(value, DefaultValue);
+    }
+}
diff --git a/Libs/Google.Protobuf/FieldMaskTree.cs b/Libs/Google.Protobuf/FieldMaskTree.cs
new file mode 100644
index 0000000..068efa1
--- /dev/null
+++ b/Libs/Google.Protobuf/FieldMaskTree.cs
@@ -0,0 +1,365 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using LC.Google.Protobuf.Reflection;
+using LC.Google.Protobuf.WellKnownTypes;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// <para>A tree representation of a FieldMask. Each leaf node in this tree represent
+    /// a field path in the FieldMask.</para>
+    ///
+    /// <para>For example, FieldMask "foo.bar,foo.baz,bar.baz" as a tree will be:</para>
+    /// <code>
+    ///   [root] -+- foo -+- bar
+    ///           |       |
+    ///           |       +- baz
+    ///           |
+    ///           +- bar --- baz
+    /// </code>
+    ///
+    /// <para>By representing FieldMasks with this tree structure we can easily convert
+    /// a FieldMask to a canonical form, merge two FieldMasks, calculate the
+    /// intersection to two FieldMasks and traverse all fields specified by the
+    /// FieldMask in a message tree.</para>
+    /// </summary>
+    internal sealed class FieldMaskTree
+    {
+        private const char FIELD_PATH_SEPARATOR = '.';
+
+        internal sealed class Node
+        {
+            public Dictionary<string, Node> Children { get; } = new Dictionary<string, Node>();
+        }
+
+        private readonly Node root = new Node();
+
+        /// <summary>
+        /// Creates an empty FieldMaskTree.
+        /// </summary>
+        public FieldMaskTree()
+        {
+        }
+
+        /// <summary>
+        /// Creates a FieldMaskTree for a given FieldMask.
+        /// </summary>
+        public FieldMaskTree(FieldMask mask)
+        {
+            MergeFromFieldMask(mask);
+        }
+
+        public override string ToString()
+        {
+            return ToFieldMask().ToString();
+        }
+
+        /// <summary>
+        /// Adds a field path to the tree. In a FieldMask, every field path matches the
+        /// specified field as well as all its sub-fields. For example, a field path
+        /// "foo.bar" matches field "foo.bar" and also "foo.bar.baz", etc. When adding
+        /// a field path to the tree, redundant sub-paths will be removed. That is,
+        /// after adding "foo.bar" to the tree, "foo.bar.baz" will be removed if it
+        /// exists, which will turn the tree node for "foo.bar" to a leaf node.
+        /// Likewise, if the field path to add is a sub-path of an existing leaf node,
+        /// nothing will be changed in the tree.
+        /// </summary>
+        public FieldMaskTree AddFieldPath(string path)
+        {
+            var parts = path.Split(FIELD_PATH_SEPARATOR);
+            if (parts.Length == 0)
+            {
+                return this;
+            }
+
+            var node = root;
+            var createNewBranch = false;
+
+            // Find the matching node in the tree.
+            foreach (var part in parts)
+            {
+                // Check whether the path matches an existing leaf node.
+                if (!createNewBranch
+                    && node != root
+                    && node.Children.Count == 0)
+                {
+                    // The path to add is a sub-path of an existing leaf node.
+                    return this;
+                }
+
+                Node childNode;
+                if (!node.Children.TryGetValue(part, out childNode))
+                {
+                    createNewBranch = true;
+                    childNode = new Node();
+                    node.Children.Add(part, childNode);
+                }
+                node = childNode;
+            }
+
+            // Turn the matching node into a leaf node (i.e., remove sub-paths).
+            node.Children.Clear();
+            return this;
+        }
+
+        /// <summary>
+        /// Merges all field paths in a FieldMask into this tree.
+        /// </summary>
+        public FieldMaskTree MergeFromFieldMask(FieldMask mask)
+        {
+            foreach (var path in mask.Paths)
+            {
+                AddFieldPath(path);
+            }
+
+            return this;
+        }
+
+        /// <summary>
+        /// Converts this tree to a FieldMask.
+        /// </summary>
+        public FieldMask ToFieldMask()
+        {
+            var mask = new FieldMask();
+            if (root.Children.Count != 0)
+            {
+                var paths = new List<string>();
+                GetFieldPaths(root, "", paths);
+                mask.Paths.AddRange(paths);
+            }
+
+            return mask;
+        }
+
+        /// <summary>
+        /// Gathers all field paths in a sub-tree.
+        /// </summary>
+        private void GetFieldPaths(Node node, string path, List<string> paths)
+        {
+            if (node.Children.Count == 0)
+            {
+                paths.Add(path);
+                return;
+            }
+
+            foreach (var entry in node.Children)
+            {
+                var childPath = path.Length == 0 ? entry.Key : path + "." + entry.Key;
+                GetFieldPaths(entry.Value, childPath, paths);
+            }
+        }
+
+        /// <summary>
+        /// Adds the intersection of this tree with the given <paramref name="path"/> to <paramref name="output"/>.
+        /// </summary>
+        public void IntersectFieldPath(string path, FieldMaskTree output)
+        {
+            if (root.Children.Count == 0)
+            {
+                return;
+            }
+
+            var parts = path.Split(FIELD_PATH_SEPARATOR);
+            if (parts.Length == 0)
+            {
+                return;
+            }
+
+            var node = root;
+            foreach (var part in parts)
+            {
+                if (node != root
+                    && node.Children.Count == 0)
+                {
+                    // The given path is a sub-path of an existing leaf node in the tree.
+                    output.AddFieldPath(path);
+                    return;
+                }
+
+                if (!node.Children.TryGetValue(part, out node))
+                {
+                    return;
+                }
+            }
+
+            // We found a matching node for the path. All leaf children of this matching
+            // node is in the intersection.
+            var paths = new List<string>();
+            GetFieldPaths(node, path, paths);
+            foreach (var value in paths)
+            {
+                output.AddFieldPath(value);
+            }
+        }
+
+        /// <summary>
+        /// Merges all fields specified by this FieldMaskTree from <paramref name="source"/> to <paramref name="destination"/>.
+        /// </summary>
+        public void Merge(IMessage source, IMessage destination, FieldMask.MergeOptions options)
+        {
+            if (source.Descriptor != destination.Descriptor)
+            {
+                throw new InvalidProtocolBufferException("Cannot merge messages of different types.");
+            }
+
+            if (root.Children.Count == 0)
+            {
+                return;
+            }
+
+            Merge(root, "", source, destination, options);
+        }
+
+        /// <summary>
+        /// Merges all fields specified by a sub-tree from <paramref name="source"/> to <paramref name="destination"/>.
+        /// </summary>
+        private void Merge(
+            Node node,
+            string path,
+            IMessage source,
+            IMessage destination,
+            FieldMask.MergeOptions options)
+        {
+            if (source.Descriptor != destination.Descriptor)
+            {
+                throw new InvalidProtocolBufferException($"source ({source.Descriptor}) and destination ({destination.Descriptor}) descriptor must be equal");
+            }
+
+            var descriptor = source.Descriptor;
+            foreach (var entry in node.Children)
+            {
+                var field = descriptor.FindFieldByName(entry.Key);
+                if (field == null)
+                {
+                    Debug.WriteLine($"Cannot find field \"{entry.Key}\" in message type \"{descriptor.FullName}\"");
+                    continue;
+                }
+
+                if (entry.Value.Children.Count != 0)
+                {
+                    if (field.IsRepeated
+                        || field.FieldType != FieldType.Message)
+                    {
+                        Debug.WriteLine($"Field \"{field.FullName}\" is not a singular message field and cannot have sub-fields.");
+                        continue;
+                    }
+
+                    var sourceField = field.Accessor.GetValue(source);
+                    var destinationField = field.Accessor.GetValue(destination);
+                    if (sourceField == null
+                        && destinationField == null)
+                    {
+                        // If the message field is not present in both source and destination, skip recursing
+                        // so we don't create unnecessary empty messages.
+                        continue;
+                    }
+
+                    if (destinationField == null)
+                    {
+                        // If we have to merge but the destination does not contain the field, create it.
+                        destinationField = field.MessageType.Parser.CreateTemplate();
+                        field.Accessor.SetValue(destination, destinationField);
+                    }
+
+                    var childPath = path.Length == 0 ? entry.Key : path + "." + entry.Key;
+                    Merge(entry.Value, childPath, (IMessage)sourceField, (IMessage)destinationField, options);
+                    continue;
+                }
+
+                if (field.IsRepeated)
+                {
+                    if (options.ReplaceRepeatedFields)
+                    {
+                        field.Accessor.Clear(destination);
+                    }
+
+                    var sourceField = (IList)field.Accessor.GetValue(source);
+                    var destinationField = (IList)field.Accessor.GetValue(destination);
+                    foreach (var element in sourceField)
+                    {
+                        destinationField.Add(element);
+                    }
+                }
+                else
+                {
+                    var sourceField = field.Accessor.GetValue(source);
+                    if (field.FieldType == FieldType.Message)
+                    {
+                        if (options.ReplaceMessageFields)
+                        {
+                            if (sourceField == null)
+                            {
+                                field.Accessor.Clear(destination);
+                            }
+                            else
+                            {
+                                field.Accessor.SetValue(destination, sourceField);
+                            }
+                        }
+                        else
+                        {
+                            if (sourceField != null)
+                            {
+                                var sourceByteString = ((IMessage)sourceField).ToByteString();
+                                var destinationValue = (IMessage)field.Accessor.GetValue(destination);
+                                if (destinationValue != null)
+                                {
+                                    destinationValue.MergeFrom(sourceByteString);
+                                }
+                                else
+                                {
+                                    field.Accessor.SetValue(destination, field.MessageType.Parser.ParseFrom(sourceByteString));
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if (sourceField != null
+                            || !options.ReplacePrimitiveFields)
+                        {
+                            field.Accessor.SetValue(destination, sourceField);
+                        }
+                        else
+                        {
+                            field.Accessor.Clear(destination);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/FrameworkPortability.cs b/Libs/Google.Protobuf/FrameworkPortability.cs
new file mode 100644
index 0000000..e931031
--- /dev/null
+++ b/Libs/Google.Protobuf/FrameworkPortability.cs
@@ -0,0 +1,49 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Text.RegularExpressions;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Class containing helpful workarounds for various platform compatibility
+    /// </summary>
+    internal static class FrameworkPortability
+    {
+        // The value of RegexOptions.Compiled is 8. We can test for the presence at
+        // execution time using Enum.IsDefined, so a single build will do the right thing
+        // on each platform. (RegexOptions.Compiled isn't supported by PCLs.)
+        internal static readonly RegexOptions CompiledRegexWhereAvailable =
+            Enum.IsDefined(typeof(RegexOptions), 8) ? (RegexOptions)8 : RegexOptions.None;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/IBufferMessage.cs b/Libs/Google.Protobuf/IBufferMessage.cs
new file mode 100644
index 0000000..7bd62d4
--- /dev/null
+++ b/Libs/Google.Protobuf/IBufferMessage.cs
@@ -0,0 +1,53 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Interface for a Protocol Buffers message, supporting
+    /// parsing from <see cref="ParseContext"/> and writing to <see cref="WriteContext"/>.
+    /// </summary>
+    public interface IBufferMessage : IMessage
+    {
+        /// <summary>
+        /// Internal implementation of merging data from given parse context into this message.
+        /// Users should never invoke this method directly.
+        /// </summary>        
+        void InternalMergeFrom(ref ParseContext ctx);
+
+        /// <summary>
+        /// Internal implementation of writing this message to a given write context.
+        /// Users should never invoke this method directly.
+        /// </summary>        
+        void InternalWriteTo(ref WriteContext ctx);
+    }
+}
diff --git a/Libs/Google.Protobuf/ICustomDiagnosticMessage.cs b/Libs/Google.Protobuf/ICustomDiagnosticMessage.cs
new file mode 100644
index 0000000..976688f
--- /dev/null
+++ b/Libs/Google.Protobuf/ICustomDiagnosticMessage.cs
@@ -0,0 +1,69 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2016 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// A message type that has a custom string format for diagnostic purposes.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Calling <see cref="object.ToString"/> on a generated message type normally
+    /// returns the JSON representation. If a message type implements this interface,
+    /// then the <see cref="ToDiagnosticString"/> method will be called instead of the regular
+    /// JSON formatting code, but only when <c>ToString()</c> is called either on the message itself
+    /// or on another message which contains it. This does not affect the normal JSON formatting of
+    /// the message.
+    /// </para>
+    /// <para>
+    /// For example, if you create a proto message representing a GUID, the internal
+    /// representation may be a <c>bytes</c> field or four <c>fixed32</c> fields. However, when debugging
+    /// it may be more convenient to see a result in the same format as <see cref="System.Guid"/> provides.
+    /// </para>
+    /// <para>This interface extends <see cref="IMessage"/> to avoid it accidentally being implemented
+    /// on types other than messages, where it would not be used by anything in the framework.</para>
+    /// </remarks>
+    public interface ICustomDiagnosticMessage : IMessage
+    {
+        /// <summary>
+        /// Returns a string representation of this object, for diagnostic purposes.
+        /// </summary>
+        /// <remarks>
+        /// This method is called when a message is formatted as part of a <see cref="object.ToString"/>
+        /// call. It does not affect the JSON representation used by <see cref="JsonFormatter"/> other than
+        /// in calls to <see cref="JsonFormatter.ToDiagnosticString(IMessage)"/>. While it is recommended
+        /// that the result is valid JSON, this is never assumed by the Protobuf library.
+        /// </remarks>
+        /// <returns>A string representation of this object, for diagnostic purposes.</returns>
+        string ToDiagnosticString();
+    }
+}
diff --git a/Libs/Google.Protobuf/IDeepCloneable.cs b/Libs/Google.Protobuf/IDeepCloneable.cs
new file mode 100644
index 0000000..183571d
--- /dev/null
+++ b/Libs/Google.Protobuf/IDeepCloneable.cs
@@ -0,0 +1,54 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Generic interface for a deeply cloneable type.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// All generated messages implement this interface, but so do some non-message types.
+    /// Additionally, due to the type constraint on <c>T</c> in <see cref="IMessage{T}"/>,
+    /// it is simpler to keep this as a separate interface.
+    /// </para>
+    /// </remarks>
+    /// <typeparam name="T">The type itself, returned by the <see cref="Clone"/> method.</typeparam>
+    public interface IDeepCloneable<T>
+    {
+        /// <summary>
+        /// Creates a deep clone of this object.
+        /// </summary>
+        /// <returns>A deep clone of this object.</returns>
+        T Clone();
+    }
+}
diff --git a/Libs/Google.Protobuf/IExtendableMessage.cs b/Libs/Google.Protobuf/IExtendableMessage.cs
new file mode 100644
index 0000000..b5e1adc
--- /dev/null
+++ b/Libs/Google.Protobuf/IExtendableMessage.cs
@@ -0,0 +1,79 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Generic interface for a Protocol Buffers message containing one or more extensions, where the type parameter is expected to be the same type as the implementation class.
+    /// This interface is experiemental and is subject to change.
+    /// </summary>
+    public interface IExtendableMessage<T> : IMessage<T> where T : IExtendableMessage<T>
+    {
+        /// <summary>
+        /// Gets the value of the specified extension
+        /// </summary>
+        TValue GetExtension<TValue>(Extension<T, TValue> extension);
+
+        /// <summary>
+        /// Gets the value of the specified repeated extension or null if the extension isn't registered in this set.
+        /// For a version of this method that never returns null, use <see cref="IExtendableMessage{T}.GetOrInitializeExtension{TValue}(RepeatedExtension{T, TValue})"/>
+        /// </summary>
+        RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<T, TValue> extension);
+
+        /// <summary>
+        /// Gets the value of the specified repeated extension, registering it if it hasn't already been registered.
+        /// </summary>
+        RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<T, TValue> extension);
+
+        /// <summary>
+        /// Sets the value of the specified extension
+        /// </summary>
+        void SetExtension<TValue>(Extension<T, TValue> extension, TValue value);
+
+        /// <summary>
+        /// Gets whether the value of the specified extension is set
+        /// </summary>
+        bool HasExtension<TValue>(Extension<T, TValue> extension);
+
+        /// <summary>
+        /// Clears the value of the specified extension
+        /// </summary>
+        void ClearExtension<TValue>(Extension<T, TValue> extension);
+
+        /// <summary>
+        /// Clears the value of the specified repeated extension
+        /// </summary>
+        void ClearExtension<TValue>(RepeatedExtension<T, TValue> extension);
+    }
+}
diff --git a/Libs/Google.Protobuf/IMessage.cs b/Libs/Google.Protobuf/IMessage.cs
new file mode 100644
index 0000000..d4c3b36
--- /dev/null
+++ b/Libs/Google.Protobuf/IMessage.cs
@@ -0,0 +1,87 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using LC.Google.Protobuf.Reflection;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Interface for a Protocol Buffers message, supporting
+    /// basic operations required for serialization.
+    /// </summary>
+    public interface IMessage
+    {
+        /// <summary>
+        /// Merges the data from the specified coded input stream with the current message.
+        /// </summary>
+        /// <remarks>See the user guide for precise merge semantics.</remarks>
+        /// <param name="input"></param>
+        void MergeFrom(CodedInputStream input);
+
+        /// <summary>
+        /// Writes the data to the given coded output stream.
+        /// </summary>
+        /// <param name="output">Coded output stream to write the data to. Must not be null.</param>
+        void WriteTo(CodedOutputStream output);
+
+        /// <summary>
+        /// Calculates the size of this message in Protocol Buffer wire format, in bytes.
+        /// </summary>
+        /// <returns>The number of bytes required to write this message
+        /// to a coded output stream.</returns>
+        int CalculateSize();
+
+        /// <summary>
+        /// Descriptor for this message. All instances are expected to return the same descriptor,
+        /// and for generated types this will be an explicitly-implemented member, returning the
+        /// same value as the static property declared on the type.
+        /// </summary>
+        MessageDescriptor Descriptor { get; }
+    }
+
+    /// <summary>
+    /// Generic interface for a Protocol Buffers message,
+    /// where the type parameter is expected to be the same type as
+    /// the implementation class.
+    /// </summary>
+    /// <typeparam name="T">The message type.</typeparam>
+    public interface IMessage<T> : IMessage, IEquatable<T>, IDeepCloneable<T> where T : IMessage<T>
+    {
+        /// <summary>
+        /// Merges the given message into this one.
+        /// </summary>
+        /// <remarks>See the user guide for precise merge semantics.</remarks>
+        /// <param name="message">The message to merge with this one. Must not be null.</param>
+        void MergeFrom(T message);
+    }
+}
diff --git a/Libs/Google.Protobuf/InvalidJsonException.cs b/Libs/Google.Protobuf/InvalidJsonException.cs
new file mode 100644
index 0000000..8a8c242
--- /dev/null
+++ b/Libs/Google.Protobuf/InvalidJsonException.cs
@@ -0,0 +1,53 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.IO;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Thrown when an attempt is made to parse invalid JSON, e.g. using
+    /// a non-string property key, or including a redundant comma. Parsing a protocol buffer
+    /// message represented in JSON using <see cref="JsonParser"/> can throw both this
+    /// exception and <see cref="InvalidProtocolBufferException"/> depending on the situation. This
+    /// exception is only thrown for "pure JSON" errors, whereas <c>InvalidProtocolBufferException</c>
+    /// is thrown when the JSON may be valid in and of itself, but cannot be parsed as a protocol buffer
+    /// message.
+    /// </summary>
+    public sealed class InvalidJsonException : IOException
+    {
+        internal InvalidJsonException(string message)
+            : base(message)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/InvalidProtocolBufferException.cs b/Libs/Google.Protobuf/InvalidProtocolBufferException.cs
new file mode 100644
index 0000000..22dc559
--- /dev/null
+++ b/Libs/Google.Protobuf/InvalidProtocolBufferException.cs
@@ -0,0 +1,140 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.IO;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Thrown when a protocol message being parsed is invalid in some way,
+    /// e.g. it contains a malformed varint or a negative byte length.
+    /// </summary>
+    public sealed class InvalidProtocolBufferException : IOException
+    {
+        internal InvalidProtocolBufferException(string message)
+            : base(message)
+        {
+        }
+
+        internal InvalidProtocolBufferException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        internal static InvalidProtocolBufferException MoreDataAvailable()
+        {
+            return new InvalidProtocolBufferException(
+                "Completed reading a message while more data was available in the stream.");
+        }
+
+        internal static InvalidProtocolBufferException TruncatedMessage()
+        {
+            return new InvalidProtocolBufferException(
+                "While parsing a protocol message, the input ended unexpectedly " +
+                "in the middle of a field.  This could mean either that the " +
+                "input has been truncated or that an embedded message " +
+                "misreported its own length.");
+        }
+
+        internal static InvalidProtocolBufferException NegativeSize()
+        {
+            return new InvalidProtocolBufferException(
+                "CodedInputStream encountered an embedded string or message " +
+                "which claimed to have negative size.");
+        }
+
+        internal static InvalidProtocolBufferException MalformedVarint()
+        {
+            return new InvalidProtocolBufferException(
+                "CodedInputStream encountered a malformed varint.");
+        }
+
+        /// <summary>
+        /// Creates an exception for an error condition of an invalid tag being encountered.
+        /// </summary>
+        internal static InvalidProtocolBufferException InvalidTag()
+        {
+            return new InvalidProtocolBufferException(
+                "Protocol message contained an invalid tag (zero).");
+        }
+
+        internal static InvalidProtocolBufferException InvalidWireType()
+        {
+            return new InvalidProtocolBufferException(
+                "Protocol message contained a tag with an invalid wire type.");
+        }
+
+        internal static InvalidProtocolBufferException InvalidBase64(Exception innerException)
+        {
+            return new InvalidProtocolBufferException("Invalid base64 data", innerException);
+        }
+
+        internal static InvalidProtocolBufferException InvalidEndTag()
+        {
+            return new InvalidProtocolBufferException(
+                "Protocol message end-group tag did not match expected tag.");
+        }
+
+        internal static InvalidProtocolBufferException RecursionLimitExceeded()
+        {
+            return new InvalidProtocolBufferException(
+                "Protocol message had too many levels of nesting.  May be malicious.  " +
+                "Use CodedInputStream.SetRecursionLimit() to increase the depth limit.");
+        }
+
+        internal static InvalidProtocolBufferException JsonRecursionLimitExceeded()
+        {
+            return new InvalidProtocolBufferException(
+                "Protocol message had too many levels of nesting.  May be malicious.  " +
+                "Use JsonParser.Settings to increase the depth limit.");
+        }
+
+        internal static InvalidProtocolBufferException SizeLimitExceeded()
+        {
+            return new InvalidProtocolBufferException(
+                "Protocol message was too large.  May be malicious.  " +
+                "Use CodedInputStream.SetSizeLimit() to increase the size limit.");
+        }
+
+        internal static InvalidProtocolBufferException InvalidMessageStreamTag()
+        {
+            return new InvalidProtocolBufferException(
+                "Stream of protocol messages had invalid tag. Expected tag is length-delimited field 1.");
+        }
+
+        internal static InvalidProtocolBufferException MissingFields()
+        {
+            return new InvalidProtocolBufferException("Message was missing required fields");
+        }
+}
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/JsonFormatter.cs b/Libs/Google.Protobuf/JsonFormatter.cs
new file mode 100644
index 0000000..9d39fd2
--- /dev/null
+++ b/Libs/Google.Protobuf/JsonFormatter.cs
@@ -0,0 +1,927 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Globalization;
+using System.Text;
+using LC.Google.Protobuf.Reflection;
+using LC.Google.Protobuf.WellKnownTypes;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Reflection-based converter from messages to JSON.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Instances of this class are thread-safe, with no mutable state.
+    /// </para>
+    /// <para>
+    /// This is a simple start to get JSON formatting working. As it's reflection-based,
+    /// it's not as quick as baking calls into generated messages - but is a simpler implementation.
+    /// (This code is generally not heavily optimized.)
+    /// </para>
+    /// </remarks>
+    public sealed class JsonFormatter
+    {
+        internal const string AnyTypeUrlField = "@type";
+        internal const string AnyDiagnosticValueField = "@value";
+        internal const string AnyWellKnownTypeValueField = "value";
+        private const string TypeUrlPrefix = "type.googleapis.com";
+        private const string NameValueSeparator = ": ";
+        private const string PropertySeparator = ", ";
+
+        /// <summary>
+        /// Returns a formatter using the default settings.
+        /// </summary>
+        public static JsonFormatter Default { get; } = new JsonFormatter(Settings.Default);
+
+        // A JSON formatter which *only* exists
+        private static readonly JsonFormatter diagnosticFormatter = new JsonFormatter(Settings.Default);
+
+        /// <summary>
+        /// The JSON representation of the first 160 characters of Unicode.
+        /// Empty strings are replaced by the static constructor.
+        /// </summary>
+        private static readonly string[] CommonRepresentations = {
+            // C0 (ASCII and derivatives) control characters
+            "\\u0000", "\\u0001", "\\u0002", "\\u0003",  // 0x00
+          "\\u0004", "\\u0005", "\\u0006", "\\u0007",
+          "\\b",     "\\t",     "\\n",     "\\u000b",
+          "\\f",     "\\r",     "\\u000e", "\\u000f",
+          "\\u0010", "\\u0011", "\\u0012", "\\u0013",  // 0x10
+          "\\u0014", "\\u0015", "\\u0016", "\\u0017",
+          "\\u0018", "\\u0019", "\\u001a", "\\u001b",
+          "\\u001c", "\\u001d", "\\u001e", "\\u001f",
+            // Escaping of " and \ are required by www.json.org string definition.
+            // Escaping of < and > are required for HTML security.
+            "", "", "\\\"", "", "",        "", "",        "",  // 0x20
+          "", "", "",     "", "",        "", "",        "",
+          "", "", "",     "", "",        "", "",        "",  // 0x30
+          "", "", "",     "", "\\u003c", "", "\\u003e", "",
+          "", "", "",     "", "",        "", "",        "",  // 0x40
+          "", "", "",     "", "",        "", "",        "",
+          "", "", "",     "", "",        "", "",        "",  // 0x50
+          "", "", "",     "", "\\\\",    "", "",        "",
+          "", "", "",     "", "",        "", "",        "",  // 0x60
+          "", "", "",     "", "",        "", "",        "",
+          "", "", "",     "", "",        "", "",        "",  // 0x70
+          "", "", "",     "", "",        "", "",        "\\u007f",
+            // C1 (ISO 8859 and Unicode) extended control characters
+            "\\u0080", "\\u0081", "\\u0082", "\\u0083",  // 0x80
+          "\\u0084", "\\u0085", "\\u0086", "\\u0087",
+          "\\u0088", "\\u0089", "\\u008a", "\\u008b",
+          "\\u008c", "\\u008d", "\\u008e", "\\u008f",
+          "\\u0090", "\\u0091", "\\u0092", "\\u0093",  // 0x90
+          "\\u0094", "\\u0095", "\\u0096", "\\u0097",
+          "\\u0098", "\\u0099", "\\u009a", "\\u009b",
+          "\\u009c", "\\u009d", "\\u009e", "\\u009f"
+        };
+
+        static JsonFormatter()
+        {
+            for (int i = 0; i < CommonRepresentations.Length; i++)
+            {
+                if (CommonRepresentations[i] == "")
+                {
+                    CommonRepresentations[i] = ((char) i).ToString();
+                }
+            }
+        }
+
+        private readonly Settings settings;
+
+        private bool DiagnosticOnly => ReferenceEquals(this, diagnosticFormatter);
+
+        /// <summary>
+        /// Creates a new formatted with the given settings.
+        /// </summary>
+        /// <param name="settings">The settings.</param>
+        public JsonFormatter(Settings settings)
+        {
+            this.settings = ProtoPreconditions.CheckNotNull(settings, nameof(settings));
+        }
+
+        /// <summary>
+        /// Formats the specified message as JSON.
+        /// </summary>
+        /// <param name="message">The message to format.</param>
+        /// <returns>The formatted message.</returns>
+        public string Format(IMessage message)
+        {
+            var writer = new StringWriter();
+            Format(message, writer);
+            return writer.ToString();
+        }
+
+        /// <summary>
+        /// Formats the specified message as JSON.
+        /// </summary>
+        /// <param name="message">The message to format.</param>
+        /// <param name="writer">The TextWriter to write the formatted message to.</param>
+        /// <returns>The formatted message.</returns>
+        public void Format(IMessage message, TextWriter writer)
+        {
+            ProtoPreconditions.CheckNotNull(message, nameof(message));
+            ProtoPreconditions.CheckNotNull(writer, nameof(writer));
+
+            if (message.Descriptor.IsWellKnownType)
+            {
+                WriteWellKnownTypeValue(writer, message.Descriptor, message);
+            }
+            else
+            {
+                WriteMessage(writer, message);
+            }
+        }
+
+        /// <summary>
+        /// Converts a message to JSON for diagnostic purposes with no extra context.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This differs from calling <see cref="Format(IMessage)"/> on the default JSON
+        /// formatter in its handling of <see cref="Any"/>. As no type registry is available
+        /// in <see cref="object.ToString"/> calls, the normal way of resolving the type of
+        /// an <c>Any</c> message cannot be applied. Instead, a JSON property named <c>@value</c>
+        /// is included with the base64 data from the <see cref="Any.Value"/> property of the message.
+        /// </para>
+        /// <para>The value returned by this method is only designed to be used for diagnostic
+        /// purposes. It may not be parsable by <see cref="JsonParser"/>, and may not be parsable
+        /// by other Protocol Buffer implementations.</para>
+        /// </remarks>
+        /// <param name="message">The message to format for diagnostic purposes.</param>
+        /// <returns>The diagnostic-only JSON representation of the message</returns>
+        public static string ToDiagnosticString(IMessage message)
+        {
+            ProtoPreconditions.CheckNotNull(message, nameof(message));
+            return diagnosticFormatter.Format(message);
+        }
+
+        private void WriteMessage(TextWriter writer, IMessage message)
+        {
+            if (message == null)
+            {
+                WriteNull(writer);
+                return;
+            }
+            if (DiagnosticOnly)
+            {
+                ICustomDiagnosticMessage customDiagnosticMessage = message as ICustomDiagnosticMessage;
+                if (customDiagnosticMessage != null)
+                {
+                    writer.Write(customDiagnosticMessage.ToDiagnosticString());
+                    return;
+                }
+            }
+            writer.Write("{ ");
+            bool writtenFields = WriteMessageFields(writer, message, false);
+            writer.Write(writtenFields ? " }" : "}");
+        }
+
+        private bool WriteMessageFields(TextWriter writer, IMessage message, bool assumeFirstFieldWritten)
+        {
+            var fields = message.Descriptor.Fields;
+            bool first = !assumeFirstFieldWritten;
+            // First non-oneof fields
+            foreach (var field in fields.InFieldNumberOrder())
+            {
+                var accessor = field.Accessor;
+                var value = accessor.GetValue(message);
+                if (!ShouldFormatFieldValue(message, field, value))
+                {
+                    continue;
+                }
+
+                if (!first)
+                {
+                    writer.Write(PropertySeparator);
+                }
+
+                WriteString(writer, accessor.Descriptor.JsonName);
+                writer.Write(NameValueSeparator);
+                WriteValue(writer, value);
+
+                first = false;
+            }
+            return !first;
+        }
+
+        /// <summary>
+        /// Determines whether or not a field value should be serialized according to the field,
+        /// its value in the message, and the settings of this formatter.
+        /// </summary>
+        private bool ShouldFormatFieldValue(IMessage message, FieldDescriptor field, object value) =>
+            field.HasPresence
+            // Fields that support presence *just* use that
+            ? field.Accessor.HasValue(message)
+            // Otherwise, format if either we've been asked to format default values, or if it's
+            // not a default value anyway.
+            : settings.FormatDefaultValues || !IsDefaultValue(field, value);
+
+        // Converted from java/core/src/main/java/com/google/protobuf/Descriptors.java
+        internal static string ToJsonName(string name)
+        {
+            StringBuilder result = new StringBuilder(name.Length);
+            bool isNextUpperCase = false;
+            foreach (char ch in name)
+            {
+                if (ch == '_')
+                {
+                    isNextUpperCase = true;
+                }
+                else if (isNextUpperCase)
+                {
+                    result.Append(char.ToUpperInvariant(ch));
+                    isNextUpperCase = false;
+                }
+                else
+                {
+                    result.Append(ch);
+                }
+            }
+            return result.ToString();
+        }
+
+        internal static string FromJsonName(string name)
+        {
+            StringBuilder result = new StringBuilder(name.Length);
+            foreach (char ch in name)
+            {
+                if (char.IsUpper(ch))
+                {
+                    result.Append('_');
+                    result.Append(char.ToLowerInvariant(ch));
+                }
+                else
+                {
+                    result.Append(ch);
+                }
+            }
+            return result.ToString();
+        }
+
+        private static void WriteNull(TextWriter writer)
+        {
+            writer.Write("null");
+        }
+
+        private static bool IsDefaultValue(FieldDescriptor descriptor, object value)
+        {
+            if (descriptor.IsMap)
+            {
+                IDictionary dictionary = (IDictionary) value;
+                return dictionary.Count == 0;
+            }
+            if (descriptor.IsRepeated)
+            {
+                IList list = (IList) value;
+                return list.Count == 0;
+            }
+            switch (descriptor.FieldType)
+            {
+                case FieldType.Bool:
+                    return (bool) value == false;
+                case FieldType.Bytes:
+                    return (ByteString) value == ByteString.Empty;
+                case FieldType.String:
+                    return (string) value == "";
+                case FieldType.Double:
+                    return (double) value == 0.0;
+                case FieldType.SInt32:
+                case FieldType.Int32:
+                case FieldType.SFixed32:
+                case FieldType.Enum:
+                    return (int) value == 0;
+                case FieldType.Fixed32:
+                case FieldType.UInt32:
+                    return (uint) value == 0;
+                case FieldType.Fixed64:
+                case FieldType.UInt64:
+                    return (ulong) value == 0;
+                case FieldType.SFixed64:
+                case FieldType.Int64:
+                case FieldType.SInt64:
+                    return (long) value == 0;
+                case FieldType.Float:
+                    return (float) value == 0f;
+                case FieldType.Message:
+                case FieldType.Group: // Never expect to get this, but...
+                    return value == null;
+                default:
+                    throw new ArgumentException("Invalid field type");
+            }
+        }
+
+        /// <summary>
+        /// Writes a single value to the given writer as JSON. Only types understood by
+        /// Protocol Buffers can be written in this way. This method is only exposed for
+        /// advanced use cases; most users should be using <see cref="Format(IMessage)"/>
+        /// or <see cref="Format(IMessage, TextWriter)"/>.
+        /// </summary>
+        /// <param name="writer">The writer to write the value to. Must not be null.</param>
+        /// <param name="value">The value to write. May be null.</param>
+        public void WriteValue(TextWriter writer, object value)
+        {
+            if (value == null || value is NullValue)
+            {
+                WriteNull(writer);
+            }
+            else if (value is bool)
+            {
+                writer.Write((bool)value ? "true" : "false");
+            }
+            else if (value is ByteString)
+            {
+                // Nothing in Base64 needs escaping
+                writer.Write('"');
+                writer.Write(((ByteString)value).ToBase64());
+                writer.Write('"');
+            }
+            else if (value is string)
+            {
+                WriteString(writer, (string)value);
+            }
+            else if (value is IDictionary)
+            {
+                WriteDictionary(writer, (IDictionary)value);
+            }
+            else if (value is IList)
+            {
+                WriteList(writer, (IList)value);
+            }
+            else if (value is int || value is uint)
+            {
+                IFormattable formattable = (IFormattable) value;
+                writer.Write(formattable.ToString("d", CultureInfo.InvariantCulture));
+            }
+            else if (value is long || value is ulong)
+            {
+                writer.Write('"');
+                IFormattable formattable = (IFormattable) value;
+                writer.Write(formattable.ToString("d", CultureInfo.InvariantCulture));
+                writer.Write('"');
+            }
+            else if (value is System.Enum)
+            {
+                if (settings.FormatEnumsAsIntegers)
+                {
+                    WriteValue(writer, (int)value);
+                }
+                else
+                {
+                    string name = OriginalEnumValueHelper.GetOriginalName(value);
+                    if (name != null)
+                    {
+                        WriteString(writer, name);
+                    }
+                    else
+                    {
+                        WriteValue(writer, (int)value);
+                    }
+                }
+            }
+            else if (value is float || value is double)
+            {
+                string text = ((IFormattable) value).ToString("r", CultureInfo.InvariantCulture);
+                if (text == "NaN" || text == "Infinity" || text == "-Infinity")
+                {
+                    writer.Write('"');
+                    writer.Write(text);
+                    writer.Write('"');
+                }
+                else
+                {
+                    writer.Write(text);
+                }
+            }
+            else if (value is IMessage)
+            {
+                Format((IMessage)value, writer);
+            }
+            else
+            {
+                throw new ArgumentException("Unable to format value of type " + value.GetType());
+            }
+        }
+
+        /// <summary>
+        /// Central interception point for well-known type formatting. Any well-known types which
+        /// don't need special handling can fall back to WriteMessage. We avoid assuming that the
+        /// values are using the embedded well-known types, in order to allow for dynamic messages
+        /// in the future.
+        /// </summary>
+        private void WriteWellKnownTypeValue(TextWriter writer, MessageDescriptor descriptor, object value)
+        {
+            // Currently, we can never actually get here, because null values are always handled by the caller. But if we *could*,
+            // this would do the right thing.
+            if (value == null)
+            {
+                WriteNull(writer);
+                return;
+            }
+            // For wrapper types, the value will either be the (possibly boxed) "native" value,
+            // or the message itself if we're formatting it at the top level (e.g. just calling ToString on the object itself).
+            // If it's the message form, we can extract the value first, which *will* be the (possibly boxed) native value,
+            // and then proceed, writing it as if we were definitely in a field. (We never need to wrap it in an extra string...
+            // WriteValue will do the right thing.)
+            if (descriptor.IsWrapperType)
+            {
+                if (value is IMessage)
+                {
+                    var message = (IMessage) value;
+                    value = message.Descriptor.Fields[WrappersReflection.WrapperValueFieldNumber].Accessor.GetValue(message);
+                }
+                WriteValue(writer, value);
+                return;
+            }
+            if (descriptor.FullName == Timestamp.Descriptor.FullName)
+            {
+                WriteTimestamp(writer, (IMessage)value);
+                return;
+            }
+            if (descriptor.FullName == Duration.Descriptor.FullName)
+            {
+                WriteDuration(writer, (IMessage)value);
+                return;
+            }
+            if (descriptor.FullName == FieldMask.Descriptor.FullName)
+            {
+                WriteFieldMask(writer, (IMessage)value);
+                return;
+            }
+            if (descriptor.FullName == Struct.Descriptor.FullName)
+            {
+                WriteStruct(writer, (IMessage)value);
+                return;
+            }
+            if (descriptor.FullName == ListValue.Descriptor.FullName)
+            {
+                var fieldAccessor = descriptor.Fields[ListValue.ValuesFieldNumber].Accessor;
+                WriteList(writer, (IList)fieldAccessor.GetValue((IMessage)value));
+                return;
+            }
+            if (descriptor.FullName == Value.Descriptor.FullName)
+            {
+                WriteStructFieldValue(writer, (IMessage)value);
+                return;
+            }
+            if (descriptor.FullName == Any.Descriptor.FullName)
+            {
+                WriteAny(writer, (IMessage)value);
+                return;
+            }
+            WriteMessage(writer, (IMessage)value);
+        }
+
+        private void WriteTimestamp(TextWriter writer, IMessage value)
+        {
+            // TODO: In the common case where this *is* using the built-in Timestamp type, we could
+            // avoid all the reflection at this point, by casting to Timestamp. In the interests of
+            // avoiding subtle bugs, don't do that until we've implemented DynamicMessage so that we can prove
+            // it still works in that case.
+            int nanos = (int) value.Descriptor.Fields[Timestamp.NanosFieldNumber].Accessor.GetValue(value);
+            long seconds = (long) value.Descriptor.Fields[Timestamp.SecondsFieldNumber].Accessor.GetValue(value);
+            writer.Write(Timestamp.ToJson(seconds, nanos, DiagnosticOnly));
+        }
+
+        private void WriteDuration(TextWriter writer, IMessage value)
+        {
+            // TODO: Same as for WriteTimestamp
+            int nanos = (int) value.Descriptor.Fields[Duration.NanosFieldNumber].Accessor.GetValue(value);
+            long seconds = (long) value.Descriptor.Fields[Duration.SecondsFieldNumber].Accessor.GetValue(value);
+            writer.Write(Duration.ToJson(seconds, nanos, DiagnosticOnly));
+        }
+
+        private void WriteFieldMask(TextWriter writer, IMessage value)
+        {
+            var paths = (IList<string>) value.Descriptor.Fields[FieldMask.PathsFieldNumber].Accessor.GetValue(value);
+            writer.Write(FieldMask.ToJson(paths, DiagnosticOnly));
+        }
+
+        private void WriteAny(TextWriter writer, IMessage value)
+        {
+            if (DiagnosticOnly)
+            {
+                WriteDiagnosticOnlyAny(writer, value);
+                return;
+            }
+
+            string typeUrl = (string) value.Descriptor.Fields[Any.TypeUrlFieldNumber].Accessor.GetValue(value);
+            ByteString data = (ByteString) value.Descriptor.Fields[Any.ValueFieldNumber].Accessor.GetValue(value);
+            string typeName = Any.GetTypeName(typeUrl);
+            MessageDescriptor descriptor = settings.TypeRegistry.Find(typeName);
+            if (descriptor == null)
+            {
+                throw new InvalidOperationException($"Type registry has no descriptor for type name '{typeName}'");
+            }
+            IMessage message = descriptor.Parser.ParseFrom(data);
+            writer.Write("{ ");
+            WriteString(writer, AnyTypeUrlField);
+            writer.Write(NameValueSeparator);
+            WriteString(writer, typeUrl);
+
+            if (descriptor.IsWellKnownType)
+            {
+                writer.Write(PropertySeparator);
+                WriteString(writer, AnyWellKnownTypeValueField);
+                writer.Write(NameValueSeparator);
+                WriteWellKnownTypeValue(writer, descriptor, message);
+            }
+            else
+            {
+                WriteMessageFields(writer, message, true);
+            }
+            writer.Write(" }");
+        }
+
+        private void WriteDiagnosticOnlyAny(TextWriter writer, IMessage value)
+        {
+            string typeUrl = (string) value.Descriptor.Fields[Any.TypeUrlFieldNumber].Accessor.GetValue(value);
+            ByteString data = (ByteString) value.Descriptor.Fields[Any.ValueFieldNumber].Accessor.GetValue(value);
+            writer.Write("{ ");
+            WriteString(writer, AnyTypeUrlField);
+            writer.Write(NameValueSeparator);
+            WriteString(writer, typeUrl);
+            writer.Write(PropertySeparator);
+            WriteString(writer, AnyDiagnosticValueField);
+            writer.Write(NameValueSeparator);
+            writer.Write('"');
+            writer.Write(data.ToBase64());
+            writer.Write('"');
+            writer.Write(" }");
+        }
+
+        private void WriteStruct(TextWriter writer, IMessage message)
+        {
+            writer.Write("{ ");
+            IDictionary fields = (IDictionary) message.Descriptor.Fields[Struct.FieldsFieldNumber].Accessor.GetValue(message);
+            bool first = true;
+            foreach (DictionaryEntry entry in fields)
+            {
+                string key = (string) entry.Key;
+                IMessage value = (IMessage) entry.Value;
+                if (string.IsNullOrEmpty(key) || value == null)
+                {
+                    throw new InvalidOperationException("Struct fields cannot have an empty key or a null value.");
+                }
+
+                if (!first)
+                {
+                    writer.Write(PropertySeparator);
+                }
+                WriteString(writer, key);
+                writer.Write(NameValueSeparator);
+                WriteStructFieldValue(writer, value);
+                first = false;
+            }
+            writer.Write(first ? "}" : " }");
+        }
+
+        private void WriteStructFieldValue(TextWriter writer, IMessage message)
+        {
+            var specifiedField = message.Descriptor.Oneofs[0].Accessor.GetCaseFieldDescriptor(message);
+            if (specifiedField == null)
+            {
+                throw new InvalidOperationException("Value message must contain a value for the oneof.");
+            }
+
+            object value = specifiedField.Accessor.GetValue(message);
+
+            switch (specifiedField.FieldNumber)
+            {
+                case Value.BoolValueFieldNumber:
+                case Value.StringValueFieldNumber:
+                case Value.NumberValueFieldNumber:
+                    WriteValue(writer, value);
+                    return;
+                case Value.StructValueFieldNumber:
+                case Value.ListValueFieldNumber:
+                    // Structs and ListValues are nested messages, and already well-known types.
+                    var nestedMessage = (IMessage) specifiedField.Accessor.GetValue(message);
+                    WriteWellKnownTypeValue(writer, nestedMessage.Descriptor, nestedMessage);
+                    return;
+                case Value.NullValueFieldNumber:
+                    WriteNull(writer);
+                    return;
+                default:
+                    throw new InvalidOperationException("Unexpected case in struct field: " + specifiedField.FieldNumber);
+            }
+        }
+
+        internal void WriteList(TextWriter writer, IList list)
+        {
+            writer.Write("[ ");
+            bool first = true;
+            foreach (var value in list)
+            {
+                if (!first)
+                {
+                    writer.Write(PropertySeparator);
+                }
+                WriteValue(writer, value);
+                first = false;
+            }
+            writer.Write(first ? "]" : " ]");
+        }
+
+        internal void WriteDictionary(TextWriter writer, IDictionary dictionary)
+        {
+            writer.Write("{ ");
+            bool first = true;
+            // This will box each pair. Could use IDictionaryEnumerator, but that's ugly in terms of disposal.
+            foreach (DictionaryEntry pair in dictionary)
+            {
+                if (!first)
+                {
+                    writer.Write(PropertySeparator);
+                }
+                string keyText;
+                if (pair.Key is string)
+                {
+                    keyText = (string) pair.Key;
+                }
+                else if (pair.Key is bool)
+                {
+                    keyText = (bool) pair.Key ? "true" : "false";
+                }
+                else if (pair.Key is int || pair.Key is uint | pair.Key is long || pair.Key is ulong)
+                {
+                    keyText = ((IFormattable) pair.Key).ToString("d", CultureInfo.InvariantCulture);
+                }
+                else
+                {
+                    if (pair.Key == null)
+                    {
+                        throw new ArgumentException("Dictionary has entry with null key");
+                    }
+                    throw new ArgumentException("Unhandled dictionary key type: " + pair.Key.GetType());
+                }
+                WriteString(writer, keyText);
+                writer.Write(NameValueSeparator);
+                WriteValue(writer, pair.Value);
+                first = false;
+            }
+            writer.Write(first ? "}" : " }");
+        }
+
+        /// <summary>
+        /// Writes a string (including leading and trailing double quotes) to a builder, escaping as required.
+        /// </summary>
+        /// <remarks>
+        /// Other than surrogate pair handling, this code is mostly taken from src/google/protobuf/util/internal/json_escaping.cc.
+        /// </remarks>
+        internal static void WriteString(TextWriter writer, string text)
+        {
+            writer.Write('"');
+            for (int i = 0; i < text.Length; i++)
+            {
+                char c = text[i];
+                if (c < 0xa0)
+                {
+                    writer.Write(CommonRepresentations[c]);
+                    continue;
+                }
+                if (char.IsHighSurrogate(c))
+                {
+                    // Encountered first part of a surrogate pair.
+                    // Check that we have the whole pair, and encode both parts as hex.
+                    i++;
+                    if (i == text.Length || !char.IsLowSurrogate(text[i]))
+                    {
+                        throw new ArgumentException("String contains low surrogate not followed by high surrogate");
+                    }
+                    HexEncodeUtf16CodeUnit(writer, c);
+                    HexEncodeUtf16CodeUnit(writer, text[i]);
+                    continue;
+                }
+                else if (char.IsLowSurrogate(c))
+                {
+                    throw new ArgumentException("String contains high surrogate not preceded by low surrogate");
+                }
+                switch ((uint) c)
+                {
+                    // These are not required by json spec
+                    // but used to prevent security bugs in javascript.
+                    case 0xfeff:  // Zero width no-break space
+                    case 0xfff9:  // Interlinear annotation anchor
+                    case 0xfffa:  // Interlinear annotation separator
+                    case 0xfffb:  // Interlinear annotation terminator
+
+                    case 0x00ad:  // Soft-hyphen
+                    case 0x06dd:  // Arabic end of ayah
+                    case 0x070f:  // Syriac abbreviation mark
+                    case 0x17b4:  // Khmer vowel inherent Aq
+                    case 0x17b5:  // Khmer vowel inherent Aa
+                        HexEncodeUtf16CodeUnit(writer, c);
+                        break;
+
+                    default:
+                        if ((c >= 0x0600 && c <= 0x0603) ||  // Arabic signs
+                            (c >= 0x200b && c <= 0x200f) ||  // Zero width etc.
+                            (c >= 0x2028 && c <= 0x202e) ||  // Separators etc.
+                            (c >= 0x2060 && c <= 0x2064) ||  // Invisible etc.
+                            (c >= 0x206a && c <= 0x206f))
+                        {
+                            HexEncodeUtf16CodeUnit(writer, c);
+                        }
+                        else
+                        {
+                            // No handling of surrogates here - that's done earlier
+                            writer.Write(c);
+                        }
+                        break;
+                }
+            }
+            writer.Write('"');
+        }
+
+        private const string Hex = "0123456789abcdef";
+        private static void HexEncodeUtf16CodeUnit(TextWriter writer, char c)
+        {
+            writer.Write("\\u");
+            writer.Write(Hex[(c >> 12) & 0xf]);
+            writer.Write(Hex[(c >> 8) & 0xf]);
+            writer.Write(Hex[(c >> 4) & 0xf]);
+            writer.Write(Hex[(c >> 0) & 0xf]);
+        }
+
+        /// <summary>
+        /// Settings controlling JSON formatting.
+        /// </summary>
+        public sealed class Settings
+        {
+            /// <summary>
+            /// Default settings, as used by <see cref="JsonFormatter.Default"/>
+            /// </summary>
+            public static Settings Default { get; }
+
+            // Workaround for the Mono compiler complaining about XML comments not being on
+            // valid language elements.
+            static Settings()
+            {
+                Default = new Settings(false);
+            }
+
+            /// <summary>
+            /// Whether fields which would otherwise not be included in the formatted data
+            /// should be formatted even when the value is not present, or has the default value.
+            /// This option only affects fields which don't support "presence" (e.g.
+            /// singular non-optional proto3 primitive fields).
+            /// </summary>
+            public bool FormatDefaultValues { get; }
+
+            /// <summary>
+            /// The type registry used to format <see cref="Any"/> messages.
+            /// </summary>
+            public TypeRegistry TypeRegistry { get; }
+
+            /// <summary>
+            /// Whether to format enums as ints. Defaults to false.
+            /// </summary>
+            public bool FormatEnumsAsIntegers { get; }
+
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified formatting of default values
+            /// and an empty type registry.
+            /// </summary>
+            /// <param name="formatDefaultValues"><c>true</c> if default values (0, empty strings etc) should be formatted; <c>false</c> otherwise.</param>
+            public Settings(bool formatDefaultValues) : this(formatDefaultValues, TypeRegistry.Empty)
+            {
+            }
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified formatting of default values
+            /// and type registry.
+            /// </summary>
+            /// <param name="formatDefaultValues"><c>true</c> if default values (0, empty strings etc) should be formatted; <c>false</c> otherwise.</param>
+            /// <param name="typeRegistry">The <see cref="TypeRegistry"/> to use when formatting <see cref="Any"/> messages.</param>
+            public Settings(bool formatDefaultValues, TypeRegistry typeRegistry) : this(formatDefaultValues, typeRegistry, false)
+            {
+            }
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified parameters.
+            /// </summary>
+            /// <param name="formatDefaultValues"><c>true</c> if default values (0, empty strings etc) should be formatted; <c>false</c> otherwise.</param>
+            /// <param name="typeRegistry">The <see cref="TypeRegistry"/> to use when formatting <see cref="Any"/> messages. TypeRegistry.Empty will be used if it is null.</param>
+            /// <param name="formatEnumsAsIntegers"><c>true</c> to format the enums as integers; <c>false</c> to format enums as enum names.</param>
+            private Settings(bool formatDefaultValues,
+                            TypeRegistry typeRegistry,
+                            bool formatEnumsAsIntegers)
+            {
+                FormatDefaultValues = formatDefaultValues;
+                TypeRegistry = typeRegistry ?? TypeRegistry.Empty;
+                FormatEnumsAsIntegers = formatEnumsAsIntegers;
+            }
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified formatting of default values and the current settings.
+            /// </summary>
+            /// <param name="formatDefaultValues"><c>true</c> if default values (0, empty strings etc) should be formatted; <c>false</c> otherwise.</param>
+            public Settings WithFormatDefaultValues(bool formatDefaultValues) => new Settings(formatDefaultValues, TypeRegistry, FormatEnumsAsIntegers);
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified type registry and the current settings.
+            /// </summary>
+            /// <param name="typeRegistry">The <see cref="TypeRegistry"/> to use when formatting <see cref="Any"/> messages.</param>
+            public Settings WithTypeRegistry(TypeRegistry typeRegistry) => new Settings(FormatDefaultValues, typeRegistry, FormatEnumsAsIntegers);
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified enums formatting option and the current settings.
+            /// </summary>
+            /// <param name="formatEnumsAsIntegers"><c>true</c> to format the enums as integers; <c>false</c> to format enums as enum names.</param>
+            public Settings WithFormatEnumsAsIntegers(bool formatEnumsAsIntegers) => new Settings(FormatDefaultValues, TypeRegistry, formatEnumsAsIntegers);
+        }
+
+        // Effectively a cache of mapping from enum values to the original name as specified in the proto file,
+        // fetched by reflection.
+        // The need for this is unfortunate, as is its unbounded size, but realistically it shouldn't cause issues.
+        private static class OriginalEnumValueHelper
+        {
+            // TODO: In the future we might want to use ConcurrentDictionary, at the point where all
+            // the platforms we target have it.
+            private static readonly Dictionary<System.Type, Dictionary<object, string>> dictionaries
+                = new Dictionary<System.Type, Dictionary<object, string>>();
+
+            internal static string GetOriginalName(object value)
+            {
+                var enumType = value.GetType();
+                Dictionary<object, string> nameMapping;
+                lock (dictionaries)
+                {
+                    if (!dictionaries.TryGetValue(enumType, out nameMapping))
+                    {
+                        nameMapping = GetNameMapping(enumType);
+                        dictionaries[enumType] = nameMapping;
+                    }
+                }
+
+                string originalName;
+                // If this returns false, originalName will be null, which is what we want.
+                nameMapping.TryGetValue(value, out originalName);
+                return originalName;
+            }
+
+#if NET35
+            // TODO: Consider adding functionality to TypeExtensions to avoid this difference.
+            private static Dictionary<object, string> GetNameMapping(System.Type enumType) =>
+                enumType.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)
+                    .Where(f => (f.GetCustomAttributes(typeof(OriginalNameAttribute), false)
+                                 .FirstOrDefault() as OriginalNameAttribute)
+                                 ?.PreferredAlias ?? true)
+                    .ToDictionary(f => f.GetValue(null),
+                                  f => (f.GetCustomAttributes(typeof(OriginalNameAttribute), false)
+                                        .FirstOrDefault() as OriginalNameAttribute)
+                                        // If the attribute hasn't been applied, fall back to the name of the field.
+                                        ?.Name ?? f.Name);
+#else
+            private static Dictionary<object, string> GetNameMapping(System.Type enumType) =>
+                enumType.GetTypeInfo().DeclaredFields
+                    .Where(f => f.IsStatic)
+                    .Where(f => f.GetCustomAttributes<OriginalNameAttribute>()
+                                 .FirstOrDefault()?.PreferredAlias ?? true)
+                    .ToDictionary(f => f.GetValue(null),
+                                  f => f.GetCustomAttributes<OriginalNameAttribute>()
+                                        .FirstOrDefault()
+                                        // If the attribute hasn't been applied, fall back to the name of the field.
+                                        ?.Name ?? f.Name);
+#endif
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/JsonParser.cs b/Libs/Google.Protobuf/JsonParser.cs
new file mode 100644
index 0000000..504cb46
--- /dev/null
+++ b/Libs/Google.Protobuf/JsonParser.cs
@@ -0,0 +1,1073 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Reflection;
+using LC.Google.Protobuf.WellKnownTypes;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Reflection-based converter from JSON to messages.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Instances of this class are thread-safe, with no mutable state.
+    /// </para>
+    /// <para>
+    /// This is a simple start to get JSON parsing working. As it's reflection-based,
+    /// it's not as quick as baking calls into generated messages - but is a simpler implementation.
+    /// (This code is generally not heavily optimized.)
+    /// </para>
+    /// </remarks>
+    public sealed class JsonParser
+    {
+        // Note: using 0-9 instead of \d to ensure no non-ASCII digits.
+        // This regex isn't a complete validator, but will remove *most* invalid input. We rely on parsing to do the rest.
+        private static readonly Regex TimestampRegex = new Regex(@"^(?<datetime>[0-9]{4}-[01][0-9]-[0-3][0-9]T[012][0-9]:[0-5][0-9]:[0-5][0-9])(?<subseconds>\.[0-9]{1,9})?(?<offset>(Z|[+-][0-1][0-9]:[0-5][0-9]))$", FrameworkPortability.CompiledRegexWhereAvailable);
+        private static readonly Regex DurationRegex = new Regex(@"^(?<sign>-)?(?<int>[0-9]{1,12})(?<subseconds>\.[0-9]{1,9})?s$", FrameworkPortability.CompiledRegexWhereAvailable);
+        private static readonly int[] SubsecondScalingFactors = { 0, 100000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1 };
+        private static readonly char[] FieldMaskPathSeparators = new[] { ',' };
+        private static readonly EnumDescriptor NullValueDescriptor = StructReflection.Descriptor.EnumTypes.Single(ed => ed.ClrType == typeof(NullValue));
+
+        private static readonly JsonParser defaultInstance = new JsonParser(Settings.Default);
+
+        // TODO: Consider introducing a class containing parse state of the parser, tokenizer and depth. That would simplify these handlers
+        // and the signatures of various methods.
+        private static readonly Dictionary<string, Action<JsonParser, IMessage, JsonTokenizer>>
+            WellKnownTypeHandlers = new Dictionary<string, Action<JsonParser, IMessage, JsonTokenizer>>
+        {
+            { Timestamp.Descriptor.FullName, (parser, message, tokenizer) => MergeTimestamp(message, tokenizer.Next()) },
+            { Duration.Descriptor.FullName, (parser, message, tokenizer) => MergeDuration(message, tokenizer.Next()) },
+            { Value.Descriptor.FullName, (parser, message, tokenizer) => parser.MergeStructValue(message, tokenizer) },
+            { ListValue.Descriptor.FullName, (parser, message, tokenizer) =>
+                parser.MergeRepeatedField(message, message.Descriptor.Fields[ListValue.ValuesFieldNumber], tokenizer) },
+            { Struct.Descriptor.FullName, (parser, message, tokenizer) => parser.MergeStruct(message, tokenizer) },
+            { Any.Descriptor.FullName, (parser, message, tokenizer) => parser.MergeAny(message, tokenizer) },
+            { FieldMask.Descriptor.FullName, (parser, message, tokenizer) => MergeFieldMask(message, tokenizer.Next()) },
+            { Int32Value.Descriptor.FullName, MergeWrapperField },
+            { Int64Value.Descriptor.FullName, MergeWrapperField },
+            { UInt32Value.Descriptor.FullName, MergeWrapperField },
+            { UInt64Value.Descriptor.FullName, MergeWrapperField },
+            { FloatValue.Descriptor.FullName, MergeWrapperField },
+            { DoubleValue.Descriptor.FullName, MergeWrapperField },
+            { BytesValue.Descriptor.FullName, MergeWrapperField },
+            { StringValue.Descriptor.FullName, MergeWrapperField },
+            { BoolValue.Descriptor.FullName, MergeWrapperField }
+        };
+
+        // Convenience method to avoid having to repeat the same code multiple times in the above
+        // dictionary initialization.
+        private static void MergeWrapperField(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
+        {
+            parser.MergeField(message, message.Descriptor.Fields[WrappersReflection.WrapperValueFieldNumber], tokenizer);
+        }
+
+        /// <summary>
+        /// Returns a formatter using the default settings.
+        /// </summary>
+        public static JsonParser Default { get { return defaultInstance; } }
+
+        private readonly Settings settings;
+
+        /// <summary>
+        /// Creates a new formatted with the given settings.
+        /// </summary>
+        /// <param name="settings">The settings.</param>
+        public JsonParser(Settings settings)
+        {
+            this.settings = ProtoPreconditions.CheckNotNull(settings, nameof(settings));
+        }
+
+        /// <summary>
+        /// Parses <paramref name="json"/> and merges the information into the given message.
+        /// </summary>
+        /// <param name="message">The message to merge the JSON information into.</param>
+        /// <param name="json">The JSON to parse.</param>
+        internal void Merge(IMessage message, string json)
+        {
+            Merge(message, new StringReader(json));
+        }
+
+        /// <summary>
+        /// Parses JSON read from <paramref name="jsonReader"/> and merges the information into the given message.
+        /// </summary>
+        /// <param name="message">The message to merge the JSON information into.</param>
+        /// <param name="jsonReader">Reader providing the JSON to parse.</param>
+        internal void Merge(IMessage message, TextReader jsonReader)
+        {
+            var tokenizer = JsonTokenizer.FromTextReader(jsonReader);
+            Merge(message, tokenizer);
+            var lastToken = tokenizer.Next();
+            if (lastToken != JsonToken.EndDocument)
+            {
+                throw new InvalidProtocolBufferException("Expected end of JSON after object");
+            }
+        }
+
+        /// <summary>
+        /// Merges the given message using data from the given tokenizer. In most cases, the next
+        /// token should be a "start object" token, but wrapper types and nullity can invalidate
+        /// that assumption. This is implemented as an LL(1) recursive descent parser over the stream
+        /// of tokens provided by the tokenizer. This token stream is assumed to be valid JSON, with the
+        /// tokenizer performing that validation - but not every token stream is valid "protobuf JSON".
+        /// </summary>
+        private void Merge(IMessage message, JsonTokenizer tokenizer)
+        {
+            if (tokenizer.ObjectDepth > settings.RecursionLimit)
+            {
+                throw InvalidProtocolBufferException.JsonRecursionLimitExceeded();
+            }
+            if (message.Descriptor.IsWellKnownType)
+            {
+                Action<JsonParser, IMessage, JsonTokenizer> handler;
+                if (WellKnownTypeHandlers.TryGetValue(message.Descriptor.FullName, out handler))
+                {
+                    handler(this, message, tokenizer);
+                    return;
+                }
+                // Well-known types with no special handling continue in the normal way.
+            }
+            var token = tokenizer.Next();
+            if (token.Type != JsonToken.TokenType.StartObject)
+            {
+                throw new InvalidProtocolBufferException("Expected an object");
+            }
+            var descriptor = message.Descriptor;
+            var jsonFieldMap = descriptor.Fields.ByJsonName();
+            // All the oneof fields we've already accounted for - we can only see each of them once.
+            // The set is created lazily to avoid the overhead of creating a set for every message
+            // we parsed, when oneofs are relatively rare.
+            HashSet<OneofDescriptor> seenOneofs = null;
+            while (true)
+            {
+                token = tokenizer.Next();
+                if (token.Type == JsonToken.TokenType.EndObject)
+                {
+                    return;
+                }
+                if (token.Type != JsonToken.TokenType.Name)
+                {
+                    throw new InvalidOperationException("Unexpected token type " + token.Type);
+                }
+                string name = token.StringValue;
+                FieldDescriptor field;
+                if (jsonFieldMap.TryGetValue(name, out field))
+                {
+                    if (field.ContainingOneof != null)
+                    {
+                        if (seenOneofs == null)
+                        {
+                            seenOneofs = new HashSet<OneofDescriptor>();
+                        }
+                        if (!seenOneofs.Add(field.ContainingOneof))
+                        {
+                            throw new InvalidProtocolBufferException($"Multiple values specified for oneof {field.ContainingOneof.Name}");
+                        }
+                    }
+                    MergeField(message, field, tokenizer);
+                }
+                else
+                {
+                    if (settings.IgnoreUnknownFields)
+                    {
+                        tokenizer.SkipValue();
+                    }
+                    else
+                    {
+                        throw new InvalidProtocolBufferException("Unknown field: " + name);
+                    }
+                }
+            }
+        }
+
+        private void MergeField(IMessage message, FieldDescriptor field, JsonTokenizer tokenizer)
+        {
+            var token = tokenizer.Next();
+            if (token.Type == JsonToken.TokenType.Null)
+            {
+                // Clear the field if we see a null token, unless it's for a singular field of type
+                // google.protobuf.Value or google.protobuf.NullValue.
+                // Note: different from Java API, which just ignores it.
+                // TODO: Bring it more in line? Discuss...
+                if (field.IsMap || field.IsRepeated ||
+                    !(IsGoogleProtobufValueField(field) || IsGoogleProtobufNullValueField(field)))
+                {
+                    field.Accessor.Clear(message);
+                    return;
+                }
+            }
+            tokenizer.PushBack(token);
+
+            if (field.IsMap)
+            {
+                MergeMapField(message, field, tokenizer);
+            }
+            else if (field.IsRepeated)
+            {
+                MergeRepeatedField(message, field, tokenizer);
+            }
+            else
+            {
+                var value = ParseSingleValue(field, tokenizer);
+                field.Accessor.SetValue(message, value);
+            }
+        }
+
+        private void MergeRepeatedField(IMessage message, FieldDescriptor field, JsonTokenizer tokenizer)
+        {
+            var token = tokenizer.Next();
+            if (token.Type != JsonToken.TokenType.StartArray)
+            {
+                throw new InvalidProtocolBufferException("Repeated field value was not an array. Token type: " + token.Type);
+            }
+
+            IList list = (IList) field.Accessor.GetValue(message);
+            while (true)
+            {
+                token = tokenizer.Next();
+                if (token.Type == JsonToken.TokenType.EndArray)
+                {
+                    return;
+                }
+                tokenizer.PushBack(token);
+                object value = ParseSingleValue(field, tokenizer);
+                if (value == null)
+                {
+                    throw new InvalidProtocolBufferException("Repeated field elements cannot be null");
+                }
+                list.Add(value);
+            }
+        }
+
+        private void MergeMapField(IMessage message, FieldDescriptor field, JsonTokenizer tokenizer)
+        {
+            // Map fields are always objects, even if the values are well-known types: ParseSingleValue handles those.
+            var token = tokenizer.Next();
+            if (token.Type != JsonToken.TokenType.StartObject)
+            {
+                throw new InvalidProtocolBufferException("Expected an object to populate a map");
+            }
+
+            var type = field.MessageType;
+            var keyField = type.FindFieldByNumber(1);
+            var valueField = type.FindFieldByNumber(2);
+            if (keyField == null || valueField == null)
+            {
+                throw new InvalidProtocolBufferException("Invalid map field: " + field.FullName);
+            }
+            IDictionary dictionary = (IDictionary) field.Accessor.GetValue(message);
+
+            while (true)
+            {
+                token = tokenizer.Next();
+                if (token.Type == JsonToken.TokenType.EndObject)
+                {
+                    return;
+                }
+                object key = ParseMapKey(keyField, token.StringValue);
+                object value = ParseSingleValue(valueField, tokenizer);
+                if (value == null)
+                {
+                    throw new InvalidProtocolBufferException("Map values must not be null");
+                }
+                dictionary[key] = value;
+            }
+        }
+
+        private static bool IsGoogleProtobufValueField(FieldDescriptor field)
+        {
+            return field.FieldType == FieldType.Message &&
+                field.MessageType.FullName == Value.Descriptor.FullName;
+        }
+
+        private static bool IsGoogleProtobufNullValueField(FieldDescriptor field)
+        {
+            return field.FieldType == FieldType.Enum &&
+                field.EnumType.FullName == NullValueDescriptor.FullName;
+        }
+
+        private object ParseSingleValue(FieldDescriptor field, JsonTokenizer tokenizer)
+        {
+            var token = tokenizer.Next();
+            if (token.Type == JsonToken.TokenType.Null)
+            {
+                // TODO: In order to support dynamic messages, we should really build this up
+                // dynamically.
+                if (IsGoogleProtobufValueField(field))
+                {
+                    return Value.ForNull();
+                }
+                if (IsGoogleProtobufNullValueField(field))
+                {
+                    return NullValue.NullValue;
+                }
+                return null;
+            }
+
+            var fieldType = field.FieldType;
+            if (fieldType == FieldType.Message)
+            {
+                // Parse wrapper types as their constituent types.
+                // TODO: What does this mean for null?
+                if (field.MessageType.IsWrapperType)
+                {
+                    field = field.MessageType.Fields[WrappersReflection.WrapperValueFieldNumber];
+                    fieldType = field.FieldType;
+                }
+                else
+                {
+                    // TODO: Merge the current value in message? (Public API currently doesn't make this relevant as we don't expose merging.)
+                    tokenizer.PushBack(token);
+                    IMessage subMessage = NewMessageForField(field);
+                    Merge(subMessage, tokenizer);
+                    return subMessage;
+                }
+            }
+
+            switch (token.Type)
+            {
+                case JsonToken.TokenType.True:
+                case JsonToken.TokenType.False:
+                    if (fieldType == FieldType.Bool)
+                    {
+                        return token.Type == JsonToken.TokenType.True;
+                    }
+                    // Fall through to "we don't support this type for this case"; could duplicate the behaviour of the default
+                    // case instead, but this way we'd only need to change one place.
+                    goto default;
+                case JsonToken.TokenType.StringValue:
+                    return ParseSingleStringValue(field, token.StringValue);
+                // Note: not passing the number value itself here, as we may end up storing the string value in the token too.
+                case JsonToken.TokenType.Number:
+                    return ParseSingleNumberValue(field, token);
+                case JsonToken.TokenType.Null:
+                    throw new NotImplementedException("Haven't worked out what to do for null yet");
+                default:
+                    throw new InvalidProtocolBufferException("Unsupported JSON token type " + token.Type + " for field type " + fieldType);
+            }
+        }
+
+        /// <summary>
+        /// Parses <paramref name="json"/> into a new message.
+        /// </summary>
+        /// <typeparam name="T">The type of message to create.</typeparam>
+        /// <param name="json">The JSON to parse.</param>
+        /// <exception cref="InvalidJsonException">The JSON does not comply with RFC 7159</exception>
+        /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
+        public T Parse<T>(string json) where T : IMessage, new()
+        {
+            ProtoPreconditions.CheckNotNull(json, nameof(json));
+            return Parse<T>(new StringReader(json));
+        }
+
+        /// <summary>
+        /// Parses JSON read from <paramref name="jsonReader"/> into a new message.
+        /// </summary>
+        /// <typeparam name="T">The type of message to create.</typeparam>
+        /// <param name="jsonReader">Reader providing the JSON to parse.</param>
+        /// <exception cref="InvalidJsonException">The JSON does not comply with RFC 7159</exception>
+        /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
+        public T Parse<T>(TextReader jsonReader) where T : IMessage, new()
+        {
+            ProtoPreconditions.CheckNotNull(jsonReader, nameof(jsonReader));
+            T message = new T();
+            Merge(message, jsonReader);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses <paramref name="json"/> into a new message.
+        /// </summary>
+        /// <param name="json">The JSON to parse.</param>
+        /// <param name="descriptor">Descriptor of message type to parse.</param>
+        /// <exception cref="InvalidJsonException">The JSON does not comply with RFC 7159</exception>
+        /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
+        public IMessage Parse(string json, MessageDescriptor descriptor)
+        {
+            ProtoPreconditions.CheckNotNull(json, nameof(json));
+            ProtoPreconditions.CheckNotNull(descriptor, nameof(descriptor));
+            return Parse(new StringReader(json), descriptor);
+        }
+
+        /// <summary>
+        /// Parses JSON read from <paramref name="jsonReader"/> into a new message.
+        /// </summary>
+        /// <param name="jsonReader">Reader providing the JSON to parse.</param>
+        /// <param name="descriptor">Descriptor of message type to parse.</param>
+        /// <exception cref="InvalidJsonException">The JSON does not comply with RFC 7159</exception>
+        /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
+        public IMessage Parse(TextReader jsonReader, MessageDescriptor descriptor)
+        {
+            ProtoPreconditions.CheckNotNull(jsonReader, nameof(jsonReader));
+            ProtoPreconditions.CheckNotNull(descriptor, nameof(descriptor));
+            IMessage message = descriptor.Parser.CreateTemplate();
+            Merge(message, jsonReader);
+            return message;
+        }
+
+        private void MergeStructValue(IMessage message, JsonTokenizer tokenizer)
+        {
+            var firstToken = tokenizer.Next();
+            var fields = message.Descriptor.Fields;
+            switch (firstToken.Type)
+            {
+                case JsonToken.TokenType.Null:
+                    fields[Value.NullValueFieldNumber].Accessor.SetValue(message, 0);
+                    return;
+                case JsonToken.TokenType.StringValue:
+                    fields[Value.StringValueFieldNumber].Accessor.SetValue(message, firstToken.StringValue);
+                    return;
+                case JsonToken.TokenType.Number:
+                    fields[Value.NumberValueFieldNumber].Accessor.SetValue(message, firstToken.NumberValue);
+                    return;
+                case JsonToken.TokenType.False:
+                case JsonToken.TokenType.True:
+                    fields[Value.BoolValueFieldNumber].Accessor.SetValue(message, firstToken.Type == JsonToken.TokenType.True);
+                    return;
+                case JsonToken.TokenType.StartObject:
+                    {
+                        var field = fields[Value.StructValueFieldNumber];
+                        var structMessage = NewMessageForField(field);
+                        tokenizer.PushBack(firstToken);
+                        Merge(structMessage, tokenizer);
+                        field.Accessor.SetValue(message, structMessage);
+                        return;
+                    }
+                case JsonToken.TokenType.StartArray:
+                    {
+                        var field = fields[Value.ListValueFieldNumber];
+                        var list = NewMessageForField(field);
+                        tokenizer.PushBack(firstToken);
+                        Merge(list, tokenizer);
+                        field.Accessor.SetValue(message, list);
+                        return;
+                    }
+                default:
+                    throw new InvalidOperationException("Unexpected token type: " + firstToken.Type);
+            }
+        }
+
+        private void MergeStruct(IMessage message, JsonTokenizer tokenizer)
+        {
+            var token = tokenizer.Next();
+            if (token.Type != JsonToken.TokenType.StartObject)
+            {
+                throw new InvalidProtocolBufferException("Expected object value for Struct");
+            }
+            tokenizer.PushBack(token);
+
+            var field = message.Descriptor.Fields[Struct.FieldsFieldNumber];
+            MergeMapField(message, field, tokenizer);
+        }
+
+        private void MergeAny(IMessage message, JsonTokenizer tokenizer)
+        {
+            // Record the token stream until we see the @type property. At that point, we can take the value, consult
+            // the type registry for the relevant message, and replay the stream, omitting the @type property.
+            var tokens = new List<JsonToken>();
+
+            var token = tokenizer.Next();
+            if (token.Type != JsonToken.TokenType.StartObject)
+            {
+                throw new InvalidProtocolBufferException("Expected object value for Any");
+            }
+            int typeUrlObjectDepth = tokenizer.ObjectDepth;
+
+            // The check for the property depth protects us from nested Any values which occur before the type URL
+            // for *this* Any.
+            while (token.Type != JsonToken.TokenType.Name ||
+                token.StringValue != JsonFormatter.AnyTypeUrlField ||
+                tokenizer.ObjectDepth != typeUrlObjectDepth)
+            {
+                tokens.Add(token);
+                token = tokenizer.Next();
+
+                if (tokenizer.ObjectDepth < typeUrlObjectDepth)
+                {
+                    throw new InvalidProtocolBufferException("Any message with no @type");
+                }
+            }
+
+            // Don't add the @type property or its value to the recorded token list
+            token = tokenizer.Next();
+            if (token.Type != JsonToken.TokenType.StringValue)
+            {
+                throw new InvalidProtocolBufferException("Expected string value for Any.@type");
+            }
+            string typeUrl = token.StringValue;
+            string typeName = Any.GetTypeName(typeUrl);
+
+            MessageDescriptor descriptor = settings.TypeRegistry.Find(typeName);
+            if (descriptor == null)
+            {
+                throw new InvalidOperationException($"Type registry has no descriptor for type name '{typeName}'");
+            }
+
+            // Now replay the token stream we've already read and anything that remains of the object, just parsing it
+            // as normal. Our original tokenizer should end up at the end of the object.
+            var replay = JsonTokenizer.FromReplayedTokens(tokens, tokenizer);
+            var body = descriptor.Parser.CreateTemplate();
+            if (descriptor.IsWellKnownType)
+            {
+                MergeWellKnownTypeAnyBody(body, replay);
+            }
+            else
+            {
+                Merge(body, replay);
+            }
+            var data = body.ToByteString();
+
+            // Now that we have the message data, we can pack it into an Any (the message received as a parameter).
+            message.Descriptor.Fields[Any.TypeUrlFieldNumber].Accessor.SetValue(message, typeUrl);
+            message.Descriptor.Fields[Any.ValueFieldNumber].Accessor.SetValue(message, data);
+        }
+
+        // Well-known types end up in a property called "value" in the JSON. As there's no longer a @type property
+        // in the given JSON token stream, we should *only* have tokens of start-object, name("value"), the value
+        // itself, and then end-object.
+        private void MergeWellKnownTypeAnyBody(IMessage body, JsonTokenizer tokenizer)
+        {
+            var token = tokenizer.Next(); // Definitely start-object; checked in previous method
+            token = tokenizer.Next();
+            // TODO: What about an absent Int32Value, for example?
+            if (token.Type != JsonToken.TokenType.Name || token.StringValue != JsonFormatter.AnyWellKnownTypeValueField)
+            {
+                throw new InvalidProtocolBufferException($"Expected '{JsonFormatter.AnyWellKnownTypeValueField}' property for well-known type Any body");
+            }
+            Merge(body, tokenizer);
+            token = tokenizer.Next();
+            if (token.Type != JsonToken.TokenType.EndObject)
+            {
+                throw new InvalidProtocolBufferException($"Expected end-object token after @type/value for well-known type");
+            }
+        }
+
+        #region Utility methods which don't depend on the state (or settings) of the parser.
+        private static object ParseMapKey(FieldDescriptor field, string keyText)
+        {
+            switch (field.FieldType)
+            {
+                case FieldType.Bool:
+                    if (keyText == "true")
+                    {
+                        return true;
+                    }
+                    if (keyText == "false")
+                    {
+                        return false;
+                    }
+                    throw new InvalidProtocolBufferException("Invalid string for bool map key: " + keyText);
+                case FieldType.String:
+                    return keyText;
+                case FieldType.Int32:
+                case FieldType.SInt32:
+                case FieldType.SFixed32:
+                    return ParseNumericString(keyText, int.Parse);
+                case FieldType.UInt32:
+                case FieldType.Fixed32:
+                    return ParseNumericString(keyText, uint.Parse);
+                case FieldType.Int64:
+                case FieldType.SInt64:
+                case FieldType.SFixed64:
+                    return ParseNumericString(keyText, long.Parse);
+                case FieldType.UInt64:
+                case FieldType.Fixed64:
+                    return ParseNumericString(keyText, ulong.Parse);
+                default:
+                    throw new InvalidProtocolBufferException("Invalid field type for map: " + field.FieldType);
+            }
+        }
+
+        private static object ParseSingleNumberValue(FieldDescriptor field, JsonToken token)
+        {
+            double value = token.NumberValue;
+            checked
+            {
+                try
+                {
+                    switch (field.FieldType)
+                    {
+                        case FieldType.Int32:
+                        case FieldType.SInt32:
+                        case FieldType.SFixed32:
+                            CheckInteger(value);
+                            return (int) value;
+                        case FieldType.UInt32:
+                        case FieldType.Fixed32:
+                            CheckInteger(value);
+                            return (uint) value;
+                        case FieldType.Int64:
+                        case FieldType.SInt64:
+                        case FieldType.SFixed64:
+                            CheckInteger(value);
+                            return (long) value;
+                        case FieldType.UInt64:
+                        case FieldType.Fixed64:
+                            CheckInteger(value);
+                            return (ulong) value;
+                        case FieldType.Double:
+                            return value;
+                        case FieldType.Float:
+                            if (double.IsNaN(value))
+                            {
+                                return float.NaN;
+                            }
+                            if (value > float.MaxValue || value < float.MinValue)
+                            {
+                                if (double.IsPositiveInfinity(value))
+                                {
+                                    return float.PositiveInfinity;
+                                }
+                                if (double.IsNegativeInfinity(value))
+                                {
+                                    return float.NegativeInfinity;
+                                }
+                                throw new InvalidProtocolBufferException($"Value out of range: {value}");
+                            }
+                            return (float) value;
+                        case FieldType.Enum:
+                            CheckInteger(value);
+                            // Just return it as an int, and let the CLR convert it.
+                            // Note that we deliberately don't check that it's a known value.
+                            return (int) value;
+                        default:
+                            throw new InvalidProtocolBufferException($"Unsupported conversion from JSON number for field type {field.FieldType}");
+                    }
+                }
+                catch (OverflowException)
+                {
+                    throw new InvalidProtocolBufferException($"Value out of range: {value}");
+                }
+            }
+        }
+
+        private static void CheckInteger(double value)
+        {
+            if (double.IsInfinity(value) || double.IsNaN(value))
+            {
+                throw new InvalidProtocolBufferException($"Value not an integer: {value}");
+            }
+            if (value != Math.Floor(value))
+            {
+                throw new InvalidProtocolBufferException($"Value not an integer: {value}");
+            }
+        }
+
+        private static object ParseSingleStringValue(FieldDescriptor field, string text)
+        {
+            switch (field.FieldType)
+            {
+                case FieldType.String:
+                    return text;
+                case FieldType.Bytes:
+                    try
+                    {
+                        return ByteString.FromBase64(text);
+                    }
+                    catch (FormatException e)
+                    {
+                        throw InvalidProtocolBufferException.InvalidBase64(e);
+                    }
+                case FieldType.Int32:
+                case FieldType.SInt32:
+                case FieldType.SFixed32:
+                    return ParseNumericString(text, int.Parse);
+                case FieldType.UInt32:
+                case FieldType.Fixed32:
+                    return ParseNumericString(text, uint.Parse);
+                case FieldType.Int64:
+                case FieldType.SInt64:
+                case FieldType.SFixed64:
+                    return ParseNumericString(text, long.Parse);
+                case FieldType.UInt64:
+                case FieldType.Fixed64:
+                    return ParseNumericString(text, ulong.Parse);
+                case FieldType.Double:
+                    double d = ParseNumericString(text, double.Parse);
+                    ValidateInfinityAndNan(text, double.IsPositiveInfinity(d), double.IsNegativeInfinity(d), double.IsNaN(d));
+                    return d;
+                case FieldType.Float:
+                    float f = ParseNumericString(text, float.Parse);
+                    ValidateInfinityAndNan(text, float.IsPositiveInfinity(f), float.IsNegativeInfinity(f), float.IsNaN(f));
+                    return f;
+                case FieldType.Enum:
+                    var enumValue = field.EnumType.FindValueByName(text);
+                    if (enumValue == null)
+                    {
+                        throw new InvalidProtocolBufferException($"Invalid enum value: {text} for enum type: {field.EnumType.FullName}");
+                    }
+                    // Just return it as an int, and let the CLR convert it.
+                    return enumValue.Number;
+                default:
+                    throw new InvalidProtocolBufferException($"Unsupported conversion from JSON string for field type {field.FieldType}");
+            }
+        }
+
+        /// <summary>
+        /// Creates a new instance of the message type for the given field.
+        /// </summary>
+        private static IMessage NewMessageForField(FieldDescriptor field)
+        {
+            return field.MessageType.Parser.CreateTemplate();
+        }
+
+        private static T ParseNumericString<T>(string text, Func<string, NumberStyles, IFormatProvider, T> parser)
+        {
+            // Can't prohibit this with NumberStyles.
+            if (text.StartsWith("+"))
+            {
+                throw new InvalidProtocolBufferException($"Invalid numeric value: {text}");
+            }
+            if (text.StartsWith("0") && text.Length > 1)
+            {
+                if (text[1] >= '0' && text[1] <= '9')
+                {
+                    throw new InvalidProtocolBufferException($"Invalid numeric value: {text}");
+                }
+            }
+            else if (text.StartsWith("-0") && text.Length > 2)
+            {
+                if (text[2] >= '0' && text[2] <= '9')
+                {
+                    throw new InvalidProtocolBufferException($"Invalid numeric value: {text}");
+                }
+            }
+            try
+            {
+                return parser(text, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
+            }
+            catch (FormatException)
+            {
+                throw new InvalidProtocolBufferException($"Invalid numeric value for type: {text}");
+            }
+            catch (OverflowException)
+            {
+                throw new InvalidProtocolBufferException($"Value out of range: {text}");
+            }
+        }
+
+        /// <summary>
+        /// Checks that any infinite/NaN values originated from the correct text.
+        /// This corrects the lenient whitespace handling of double.Parse/float.Parse, as well as the
+        /// way that Mono parses out-of-range values as infinity.
+        /// </summary>
+        private static void ValidateInfinityAndNan(string text, bool isPositiveInfinity, bool isNegativeInfinity, bool isNaN)
+        {
+            if ((isPositiveInfinity && text != "Infinity") ||
+                (isNegativeInfinity && text != "-Infinity") ||
+                (isNaN && text != "NaN"))
+            {
+                throw new InvalidProtocolBufferException($"Invalid numeric value: {text}");
+            }
+        }
+
+        private static void MergeTimestamp(IMessage message, JsonToken token)
+        {
+            if (token.Type != JsonToken.TokenType.StringValue)
+            {
+                throw new InvalidProtocolBufferException("Expected string value for Timestamp");
+            }
+            var match = TimestampRegex.Match(token.StringValue);
+            if (!match.Success)
+            {
+                throw new InvalidProtocolBufferException($"Invalid Timestamp value: {token.StringValue}");
+            }
+            var dateTime = match.Groups["datetime"].Value;
+            var subseconds = match.Groups["subseconds"].Value;
+            var offset = match.Groups["offset"].Value;
+
+            try
+            {
+                DateTime parsed = DateTime.ParseExact(
+                    dateTime,
+                    "yyyy-MM-dd'T'HH:mm:ss",
+                    CultureInfo.InvariantCulture,
+                    DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
+                // TODO: It would be nice not to have to create all these objects... easy to optimize later though.
+                Timestamp timestamp = Timestamp.FromDateTime(parsed);
+                int nanosToAdd = 0;
+                if (subseconds != "")
+                {
+                    // This should always work, as we've got 1-9 digits.
+                    int parsedFraction = int.Parse(subseconds.Substring(1), CultureInfo.InvariantCulture);
+                    nanosToAdd = parsedFraction * SubsecondScalingFactors[subseconds.Length];
+                }
+                int secondsToAdd = 0;
+                if (offset != "Z")
+                {
+                    // This is the amount we need to *subtract* from the local time to get to UTC - hence - => +1 and vice versa.
+                    int sign = offset[0] == '-' ? 1 : -1;
+                    int hours = int.Parse(offset.Substring(1, 2), CultureInfo.InvariantCulture);
+                    int minutes = int.Parse(offset.Substring(4, 2));
+                    int totalMinutes = hours * 60 + minutes;
+                    if (totalMinutes > 18 * 60)
+                    {
+                        throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
+                    }
+                    if (totalMinutes == 0 && sign == 1)
+                    {
+                        // This is an offset of -00:00, which means "unknown local offset". It makes no sense for a timestamp.
+                        throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
+                    }
+                    // We need to *subtract* the offset from local time to get UTC.
+                    secondsToAdd = sign * totalMinutes * 60;
+                }
+                // Ensure we've got the right signs. Currently unnecessary, but easy to do.
+                if (secondsToAdd < 0 && nanosToAdd > 0)
+                {
+                    secondsToAdd++;
+                    nanosToAdd = nanosToAdd - Duration.NanosecondsPerSecond;
+                }
+                if (secondsToAdd != 0 || nanosToAdd != 0)
+                {
+                    timestamp += new Duration { Nanos = nanosToAdd, Seconds = secondsToAdd };
+                    // The resulting timestamp after offset change would be out of our expected range. Currently the Timestamp message doesn't validate this
+                    // anywhere, but we shouldn't parse it.
+                    if (timestamp.Seconds < Timestamp.UnixSecondsAtBclMinValue || timestamp.Seconds > Timestamp.UnixSecondsAtBclMaxValue)
+                    {
+                        throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
+                    }
+                }
+                message.Descriptor.Fields[Timestamp.SecondsFieldNumber].Accessor.SetValue(message, timestamp.Seconds);
+                message.Descriptor.Fields[Timestamp.NanosFieldNumber].Accessor.SetValue(message, timestamp.Nanos);
+            }
+            catch (FormatException)
+            {
+                throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
+            }
+        }
+
+        private static void MergeDuration(IMessage message, JsonToken token)
+        {
+            if (token.Type != JsonToken.TokenType.StringValue)
+            {
+                throw new InvalidProtocolBufferException("Expected string value for Duration");
+            }
+            var match = DurationRegex.Match(token.StringValue);
+            if (!match.Success)
+            {
+                throw new InvalidProtocolBufferException("Invalid Duration value: " + token.StringValue);
+            }
+            var sign = match.Groups["sign"].Value;
+            var secondsText = match.Groups["int"].Value;
+            // Prohibit leading insignficant zeroes
+            if (secondsText[0] == '0' && secondsText.Length > 1)
+            {
+                throw new InvalidProtocolBufferException("Invalid Duration value: " + token.StringValue);
+            }
+            var subseconds = match.Groups["subseconds"].Value;
+            var multiplier = sign == "-" ? -1 : 1;
+
+            try
+            {
+                long seconds = long.Parse(secondsText, CultureInfo.InvariantCulture) * multiplier;
+                int nanos = 0;
+                if (subseconds != "")
+                {
+                    // This should always work, as we've got 1-9 digits.
+                    int parsedFraction = int.Parse(subseconds.Substring(1));
+                    nanos = parsedFraction * SubsecondScalingFactors[subseconds.Length] * multiplier;
+                }
+                if (!Duration.IsNormalized(seconds, nanos))
+                {
+                    throw new InvalidProtocolBufferException($"Invalid Duration value: {token.StringValue}");
+                }
+                message.Descriptor.Fields[Duration.SecondsFieldNumber].Accessor.SetValue(message, seconds);
+                message.Descriptor.Fields[Duration.NanosFieldNumber].Accessor.SetValue(message, nanos);
+            }
+            catch (FormatException)
+            {
+                throw new InvalidProtocolBufferException($"Invalid Duration value: {token.StringValue}");
+            }
+        }
+
+        private static void MergeFieldMask(IMessage message, JsonToken token)
+        {
+            if (token.Type != JsonToken.TokenType.StringValue)
+            {
+                throw new InvalidProtocolBufferException("Expected string value for FieldMask");
+            }
+            // TODO: Do we *want* to remove empty entries? Probably okay to treat "" as "no paths", but "foo,,bar"?
+            string[] jsonPaths = token.StringValue.Split(FieldMaskPathSeparators, StringSplitOptions.RemoveEmptyEntries);
+            IList messagePaths = (IList) message.Descriptor.Fields[FieldMask.PathsFieldNumber].Accessor.GetValue(message);
+            foreach (var path in jsonPaths)
+            {
+                messagePaths.Add(ToSnakeCase(path));
+            }
+        }
+
+        // Ported from src/google/protobuf/util/internal/utility.cc
+        private static string ToSnakeCase(string text)
+        {
+            var builder = new StringBuilder(text.Length * 2);
+            // Note: this is probably unnecessary now, but currently retained to be as close as possible to the
+            // C++, whilst still throwing an exception on underscores.
+            bool wasNotUnderscore = false;  // Initialize to false for case 1 (below)
+            bool wasNotCap = false;
+
+            for (int i = 0; i < text.Length; i++)
+            {
+                char c = text[i];
+                if (c >= 'A' && c <= 'Z') // ascii_isupper
+                {
+                    // Consider when the current character B is capitalized:
+                    // 1) At beginning of input:   "B..." => "b..."
+                    //    (e.g. "Biscuit" => "biscuit")
+                    // 2) Following a lowercase:   "...aB..." => "...a_b..."
+                    //    (e.g. "gBike" => "g_bike")
+                    // 3) At the end of input:     "...AB" => "...ab"
+                    //    (e.g. "GoogleLAB" => "google_lab")
+                    // 4) Followed by a lowercase: "...ABc..." => "...a_bc..."
+                    //    (e.g. "GBike" => "g_bike")
+                    if (wasNotUnderscore &&               //            case 1 out
+                        (wasNotCap ||                     // case 2 in, case 3 out
+                         (i + 1 < text.Length &&         //            case 3 out
+                          (text[i + 1] >= 'a' && text[i + 1] <= 'z')))) // ascii_islower(text[i + 1])
+                    {  // case 4 in
+                       // We add an underscore for case 2 and case 4.
+                        builder.Append('_');
+                    }
+                    // ascii_tolower, but we already know that c *is* an upper case ASCII character...
+                    builder.Append((char) (c + 'a' - 'A'));
+                    wasNotUnderscore = true;
+                    wasNotCap = false;
+                }
+                else
+                {
+                    builder.Append(c);
+                    if (c == '_')
+                    {
+                        throw new InvalidProtocolBufferException($"Invalid field mask: {text}");
+                    }
+                    wasNotUnderscore = true;
+                    wasNotCap = true;
+                }
+            }
+            return builder.ToString();
+        }
+        #endregion
+
+        /// <summary>
+        /// Settings controlling JSON parsing.
+        /// </summary>
+        public sealed class Settings
+        {
+            /// <summary>
+            /// Default settings, as used by <see cref="JsonParser.Default"/>. This has the same default
+            /// recursion limit as <see cref="CodedInputStream"/>, and an empty type registry.
+            /// </summary>
+            public static Settings Default { get; }
+
+            // Workaround for the Mono compiler complaining about XML comments not being on
+            // valid language elements.
+            static Settings()
+            {
+                Default = new Settings(CodedInputStream.DefaultRecursionLimit);
+            }
+
+            /// <summary>
+            /// The maximum depth of messages to parse. Note that this limit only applies to parsing
+            /// messages, not collections - so a message within a collection within a message only counts as
+            /// depth 2, not 3.
+            /// </summary>
+            public int RecursionLimit { get; }
+
+            /// <summary>
+            /// The type registry used to parse <see cref="Any"/> messages.
+            /// </summary>
+            public TypeRegistry TypeRegistry { get; }
+
+            /// <summary>
+            /// Whether the parser should ignore unknown fields (<c>true</c>) or throw an exception when
+            /// they are encountered (<c>false</c>).
+            /// </summary>
+            public bool IgnoreUnknownFields { get; }
+
+            private Settings(int recursionLimit, TypeRegistry typeRegistry, bool ignoreUnknownFields)
+            {
+                RecursionLimit = recursionLimit;
+                TypeRegistry = ProtoPreconditions.CheckNotNull(typeRegistry, nameof(typeRegistry));
+                IgnoreUnknownFields = ignoreUnknownFields;
+            }
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified recursion limit.
+            /// </summary>
+            /// <param name="recursionLimit">The maximum depth of messages to parse</param>
+            public Settings(int recursionLimit) : this(recursionLimit, TypeRegistry.Empty)
+            {
+            }
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object with the specified recursion limit and type registry.
+            /// </summary>
+            /// <param name="recursionLimit">The maximum depth of messages to parse</param>
+            /// <param name="typeRegistry">The type registry used to parse <see cref="Any"/> messages</param>
+            public Settings(int recursionLimit, TypeRegistry typeRegistry) : this(recursionLimit, typeRegistry, false)
+            {
+            }
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object set to either ignore unknown fields, or throw an exception
+            /// when unknown fields are encountered.
+            /// </summary>
+            /// <param name="ignoreUnknownFields"><c>true</c> if unknown fields should be ignored when parsing; <c>false</c> to throw an exception.</param>
+            public Settings WithIgnoreUnknownFields(bool ignoreUnknownFields) =>
+                new Settings(RecursionLimit, TypeRegistry, ignoreUnknownFields);
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object based on this one, but with the specified recursion limit.
+            /// </summary>
+            /// <param name="recursionLimit">The new recursion limit.</param>
+            public Settings WithRecursionLimit(int recursionLimit) =>
+                new Settings(recursionLimit, TypeRegistry, IgnoreUnknownFields);
+
+            /// <summary>
+            /// Creates a new <see cref="Settings"/> object based on this one, but with the specified type registry.
+            /// </summary>
+            /// <param name="typeRegistry">The new type registry. Must not be null.</param>
+            public Settings WithTypeRegistry(TypeRegistry typeRegistry) =>
+                new Settings(
+                    RecursionLimit,
+                    ProtoPreconditions.CheckNotNull(typeRegistry, nameof(typeRegistry)),
+                    IgnoreUnknownFields);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/JsonToken.cs b/Libs/Google.Protobuf/JsonToken.cs
new file mode 100644
index 0000000..a254ea6
--- /dev/null
+++ b/Libs/Google.Protobuf/JsonToken.cs
@@ -0,0 +1,166 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf
+{
+    internal sealed class JsonToken : IEquatable<JsonToken>
+    {
+        // Tokens with no value can be reused.
+        private static readonly JsonToken _true = new JsonToken(TokenType.True);
+        private static readonly JsonToken _false = new JsonToken(TokenType.False);
+        private static readonly JsonToken _null = new JsonToken(TokenType.Null);
+        private static readonly JsonToken startObject = new JsonToken(TokenType.StartObject);
+        private static readonly JsonToken endObject = new JsonToken(TokenType.EndObject);
+        private static readonly JsonToken startArray = new JsonToken(TokenType.StartArray);
+        private static readonly JsonToken endArray = new JsonToken(TokenType.EndArray);
+        private static readonly JsonToken endDocument = new JsonToken(TokenType.EndDocument);
+
+        internal static JsonToken Null { get { return _null; } }
+        internal static JsonToken False { get { return _false; } }
+        internal static JsonToken True { get { return _true; } }
+        internal static JsonToken StartObject{ get { return startObject; } }
+        internal static JsonToken EndObject { get { return endObject; } }
+        internal static JsonToken StartArray { get { return startArray; } }
+        internal static JsonToken EndArray { get { return endArray; } }
+        internal static JsonToken EndDocument { get { return endDocument; } }
+
+        internal static JsonToken Name(string name)
+        {
+            return new JsonToken(TokenType.Name, stringValue: name);
+        }
+
+        internal static JsonToken Value(string value)
+        {
+            return new JsonToken(TokenType.StringValue, stringValue: value);
+        }
+
+        internal static JsonToken Value(double value)
+        {
+            return new JsonToken(TokenType.Number, numberValue: value);
+        }
+
+        internal enum TokenType
+        {
+            Null,
+            False,
+            True,
+            StringValue,
+            Number,
+            Name,
+            StartObject,
+            EndObject,
+            StartArray,
+            EndArray,
+            EndDocument
+        }
+
+        // A value is a string, number, array, object, null, true or false
+        // Arrays and objects have start/end
+        // A document consists of a value
+        // Objects are name/value sequences.
+
+        private readonly TokenType type;
+        private readonly string stringValue;
+        private readonly double numberValue;
+
+        internal TokenType Type { get { return type; } }
+        internal string StringValue { get { return stringValue; } }
+        internal double NumberValue { get { return numberValue; } }
+
+        private JsonToken(TokenType type, string stringValue = null, double numberValue = 0)
+        {
+            this.type = type;
+            this.stringValue = stringValue;
+            this.numberValue = numberValue;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as JsonToken);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 31 + (int) type;
+                hash = hash * 31 + stringValue == null ? 0 : stringValue.GetHashCode();
+                hash = hash * 31 + numberValue.GetHashCode();
+                return hash;
+            }
+        }
+
+        public override string ToString()
+        {
+            switch (type)
+            {
+                case TokenType.Null:
+                    return "null";
+                case TokenType.True:
+                    return "true";
+                case TokenType.False:
+                    return "false";
+                case TokenType.Name:
+                    return "name (" + stringValue + ")";
+                case TokenType.StringValue:
+                    return "value (" + stringValue + ")";
+                case TokenType.Number:
+                    return "number (" + numberValue + ")";
+                case TokenType.StartObject:
+                    return "start-object";
+                case TokenType.EndObject:
+                    return "end-object";
+                case TokenType.StartArray:
+                    return "start-array";
+                case TokenType.EndArray:
+                    return "end-array";
+                case TokenType.EndDocument:
+                    return "end-document";
+                default:
+                    throw new InvalidOperationException("Token is of unknown type " + type);
+            }
+        }
+
+        public bool Equals(JsonToken other)
+        {
+            if (ReferenceEquals(other, null))
+            {
+                return false;
+            }
+            // Note use of other.numberValue.Equals rather than ==, so that NaN compares appropriately.
+            return other.type == type && other.stringValue == stringValue && other.numberValue.Equals(numberValue);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/JsonTokenizer.cs b/Libs/Google.Protobuf/JsonTokenizer.cs
new file mode 100644
index 0000000..f36d0c7
--- /dev/null
+++ b/Libs/Google.Protobuf/JsonTokenizer.cs
@@ -0,0 +1,766 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Simple but strict JSON tokenizer, rigidly following RFC 7159.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This tokenizer is stateful, and only returns "useful" tokens - names, values etc.
+    /// It does not create tokens for the separator between names and values, or for the comma
+    /// between values. It validates the token stream as it goes - so callers can assume that the
+    /// tokens it produces are appropriate. For example, it would never produce "start object, end array."
+    /// </para>
+    /// <para>Implementation details: the base class handles single token push-back and </para>
+    /// <para>Not thread-safe.</para>
+    /// </remarks>
+    internal abstract class JsonTokenizer
+    {
+        private JsonToken bufferedToken;
+
+        /// <summary>
+        ///  Creates a tokenizer that reads from the given text reader.
+        /// </summary>
+        internal static JsonTokenizer FromTextReader(TextReader reader)
+        {
+            return new JsonTextTokenizer(reader);
+        }
+
+        /// <summary>
+        /// Creates a tokenizer that first replays the given list of tokens, then continues reading
+        /// from another tokenizer. Note that if the returned tokenizer is "pushed back", that does not push back
+        /// on the continuation tokenizer, or vice versa. Care should be taken when using this method - it was
+        /// created for the sake of Any parsing.
+        /// </summary>
+        internal static JsonTokenizer FromReplayedTokens(IList<JsonToken> tokens, JsonTokenizer continuation)
+        {
+            return new JsonReplayTokenizer(tokens, continuation);
+        }
+
+        /// <summary>
+        /// Returns the depth of the stack, purely in objects (not collections).
+        /// Informally, this is the number of remaining unclosed '{' characters we have.
+        /// </summary>
+        internal int ObjectDepth { get; private set; }
+
+        // TODO: Why do we allow a different token to be pushed back? It might be better to always remember the previous
+        // token returned, and allow a parameterless Rewind() method (which could only be called once, just like the current PushBack).
+        internal void PushBack(JsonToken token)
+        {
+            if (bufferedToken != null)
+            {
+                throw new InvalidOperationException("Can't push back twice");
+            }
+            bufferedToken = token;
+            if (token.Type == JsonToken.TokenType.StartObject)
+            {
+                ObjectDepth--;
+            }
+            else if (token.Type == JsonToken.TokenType.EndObject)
+            {
+                ObjectDepth++;
+            }
+        }
+
+        /// <summary>
+        /// Returns the next JSON token in the stream. An EndDocument token is returned to indicate the end of the stream,
+        /// after which point <c>Next()</c> should not be called again.
+        /// </summary>
+        /// <remarks>This implementation provides single-token buffering, and calls <see cref="NextImpl"/> if there is no buffered token.</remarks>
+        /// <returns>The next token in the stream. This is never null.</returns>
+        /// <exception cref="InvalidOperationException">This method is called after an EndDocument token has been returned</exception>
+        /// <exception cref="InvalidJsonException">The input text does not comply with RFC 7159</exception>
+        internal JsonToken Next()
+        {
+            JsonToken tokenToReturn;
+            if (bufferedToken != null)
+            {
+                tokenToReturn = bufferedToken;
+                bufferedToken = null;
+            }
+            else
+            {
+                tokenToReturn = NextImpl();
+            }
+            if (tokenToReturn.Type == JsonToken.TokenType.StartObject)
+            {
+                ObjectDepth++;
+            }
+            else if (tokenToReturn.Type == JsonToken.TokenType.EndObject)
+            {
+                ObjectDepth--;
+            }
+            return tokenToReturn;
+        }
+
+        /// <summary>
+        /// Returns the next JSON token in the stream, when requested by the base class. (The <see cref="Next"/> method delegates
+        /// to this if it doesn't have a buffered token.)
+        /// </summary>
+        /// <exception cref="InvalidOperationException">This method is called after an EndDocument token has been returned</exception>
+        /// <exception cref="InvalidJsonException">The input text does not comply with RFC 7159</exception>
+        protected abstract JsonToken NextImpl();
+
+        /// <summary>
+        /// Skips the value we're about to read. This must only be called immediately after reading a property name.
+        /// If the value is an object or an array, the complete object/array is skipped.
+        /// </summary>
+        internal void SkipValue()
+        {
+            // We'll assume that Next() makes sure that the end objects and end arrays are all valid.
+            // All we care about is the total nesting depth we need to close.
+            int depth = 0;
+
+            // do/while rather than while loop so that we read at least one token.
+            do
+            {
+                var token = Next();
+                switch (token.Type)
+                {
+                    case JsonToken.TokenType.EndArray:
+                    case JsonToken.TokenType.EndObject:
+                        depth--;
+                        break;
+                    case JsonToken.TokenType.StartArray:
+                    case JsonToken.TokenType.StartObject:
+                        depth++;
+                        break;
+                }
+            } while (depth != 0);
+        }
+
+        /// <summary>
+        /// Tokenizer which first exhausts a list of tokens, then consults another tokenizer.
+        /// </summary>
+        private class JsonReplayTokenizer : JsonTokenizer
+        {
+            private readonly IList<JsonToken> tokens;
+            private readonly JsonTokenizer nextTokenizer;
+            private int nextTokenIndex;
+
+            internal JsonReplayTokenizer(IList<JsonToken> tokens, JsonTokenizer nextTokenizer)
+            {
+                this.tokens = tokens;
+                this.nextTokenizer = nextTokenizer;
+            }
+
+            // FIXME: Object depth not maintained...
+            protected override JsonToken NextImpl()
+            {
+                if (nextTokenIndex >= tokens.Count)
+                {
+                    return nextTokenizer.Next();
+                }
+                return tokens[nextTokenIndex++];
+            }
+        }
+
+        /// <summary>
+        /// Tokenizer which does all the *real* work of parsing JSON.
+        /// </summary>
+        private sealed class JsonTextTokenizer : JsonTokenizer
+        {
+            // The set of states in which a value is valid next token.
+            private static readonly State ValueStates = State.ArrayStart | State.ArrayAfterComma | State.ObjectAfterColon | State.StartOfDocument;
+
+            private readonly Stack<ContainerType> containerStack = new Stack<ContainerType>();
+            private readonly PushBackReader reader;
+            private State state;
+
+            internal JsonTextTokenizer(TextReader reader)
+            {
+                this.reader = new PushBackReader(reader);
+                state = State.StartOfDocument;
+                containerStack.Push(ContainerType.Document);
+            }
+
+            /// <remarks>
+            /// This method essentially just loops through characters skipping whitespace, validating and
+            /// changing state (e.g. from ObjectBeforeColon to ObjectAfterColon)
+            /// until it reaches something which will be a genuine token (e.g. a start object, or a value) at which point
+            /// it returns the token. Although the method is large, it would be relatively hard to break down further... most
+            /// of it is the large switch statement, which sometimes returns and sometimes doesn't.
+            /// </remarks>
+            protected override JsonToken NextImpl()
+            {
+                if (state == State.ReaderExhausted)
+                {
+                    throw new InvalidOperationException("Next() called after end of document");
+                }
+                while (true)
+                {
+                    var next = reader.Read();
+                    if (next == null)
+                    {
+                        ValidateState(State.ExpectedEndOfDocument, "Unexpected end of document in state: ");
+                        state = State.ReaderExhausted;
+                        return JsonToken.EndDocument;
+                    }
+                    switch (next.Value)
+                    {
+                        // Skip whitespace between tokens
+                        case ' ':
+                        case '\t':
+                        case '\r':
+                        case '\n':
+                            break;
+                        case ':':
+                            ValidateState(State.ObjectBeforeColon, "Invalid state to read a colon: ");
+                            state = State.ObjectAfterColon;
+                            break;
+                        case ',':
+                            ValidateState(State.ObjectAfterProperty | State.ArrayAfterValue, "Invalid state to read a comma: ");
+                            state = state == State.ObjectAfterProperty ? State.ObjectAfterComma : State.ArrayAfterComma;
+                            break;
+                        case '"':
+                            string stringValue = ReadString();
+                            if ((state & (State.ObjectStart | State.ObjectAfterComma)) != 0)
+                            {
+                                state = State.ObjectBeforeColon;
+                                return JsonToken.Name(stringValue);
+                            }
+                            else
+                            {
+                                ValidateAndModifyStateForValue("Invalid state to read a double quote: ");
+                                return JsonToken.Value(stringValue);
+                            }
+                        case '{':
+                            ValidateState(ValueStates, "Invalid state to read an open brace: ");
+                            state = State.ObjectStart;
+                            containerStack.Push(ContainerType.Object);
+                            return JsonToken.StartObject;
+                        case '}':
+                            ValidateState(State.ObjectAfterProperty | State.ObjectStart, "Invalid state to read a close brace: ");
+                            PopContainer();
+                            return JsonToken.EndObject;
+                        case '[':
+                            ValidateState(ValueStates, "Invalid state to read an open square bracket: ");
+                            state = State.ArrayStart;
+                            containerStack.Push(ContainerType.Array);
+                            return JsonToken.StartArray;
+                        case ']':
+                            ValidateState(State.ArrayAfterValue | State.ArrayStart, "Invalid state to read a close square bracket: ");
+                            PopContainer();
+                            return JsonToken.EndArray;
+                        case 'n': // Start of null
+                            ConsumeLiteral("null");
+                            ValidateAndModifyStateForValue("Invalid state to read a null literal: ");
+                            return JsonToken.Null;
+                        case 't': // Start of true
+                            ConsumeLiteral("true");
+                            ValidateAndModifyStateForValue("Invalid state to read a true literal: ");
+                            return JsonToken.True;
+                        case 'f': // Start of false
+                            ConsumeLiteral("false");
+                            ValidateAndModifyStateForValue("Invalid state to read a false literal: ");
+                            return JsonToken.False;
+                        case '-': // Start of a number
+                        case '0':
+                        case '1':
+                        case '2':
+                        case '3':
+                        case '4':
+                        case '5':
+                        case '6':
+                        case '7':
+                        case '8':
+                        case '9':
+                            double number = ReadNumber(next.Value);
+                            ValidateAndModifyStateForValue("Invalid state to read a number token: ");
+                            return JsonToken.Value(number);
+                        default:
+                            throw new InvalidJsonException("Invalid first character of token: " + next.Value);
+                    }
+                }
+            }
+
+            private void ValidateState(State validStates, string errorPrefix)
+            {
+                if ((validStates & state) == 0)
+                {
+                    throw reader.CreateException(errorPrefix + state);
+                }
+            }
+
+            /// <summary>
+            /// Reads a string token. It is assumed that the opening " has already been read.
+            /// </summary>
+            private string ReadString()
+            {
+                var value = new StringBuilder();
+                bool haveHighSurrogate = false;
+                while (true)
+                {
+                    char c = reader.ReadOrFail("Unexpected end of text while reading string");
+                    if (c < ' ')
+                    {
+                        throw reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in string literal: U+{0:x4}", (int) c));
+                    }
+                    if (c == '"')
+                    {
+                        if (haveHighSurrogate)
+                        {
+                            throw reader.CreateException("Invalid use of surrogate pair code units");
+                        }
+                        return value.ToString();
+                    }
+                    if (c == '\\')
+                    {
+                        c = ReadEscapedCharacter();
+                    }
+                    // TODO: Consider only allowing surrogate pairs that are either both escaped,
+                    // or both not escaped. It would be a very odd text stream that contained a "lone" high surrogate
+                    // followed by an escaped low surrogate or vice versa... and that couldn't even be represented in UTF-8.
+                    if (haveHighSurrogate != char.IsLowSurrogate(c))
+                    {
+                        throw reader.CreateException("Invalid use of surrogate pair code units");
+                    }
+                    haveHighSurrogate = char.IsHighSurrogate(c);
+                    value.Append(c);
+                }
+            }
+
+            /// <summary>
+            /// Reads an escaped character. It is assumed that the leading backslash has already been read.
+            /// </summary>
+            private char ReadEscapedCharacter()
+            {
+                char c = reader.ReadOrFail("Unexpected end of text while reading character escape sequence");
+                switch (c)
+                {
+                    case 'n':
+                        return '\n';
+                    case '\\':
+                        return '\\';
+                    case 'b':
+                        return '\b';
+                    case 'f':
+                        return '\f';
+                    case 'r':
+                        return '\r';
+                    case 't':
+                        return '\t';
+                    case '"':
+                        return '"';
+                    case '/':
+                        return '/';
+                    case 'u':
+                        return ReadUnicodeEscape();
+                    default:
+                        throw reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in character escape sequence: U+{0:x4}", (int) c));
+                }
+            }
+
+            /// <summary>
+            /// Reads an escaped Unicode 4-nybble hex sequence. It is assumed that the leading \u has already been read.
+            /// </summary>
+            private char ReadUnicodeEscape()
+            {
+                int result = 0;
+                for (int i = 0; i < 4; i++)
+                {
+                    char c = reader.ReadOrFail("Unexpected end of text while reading Unicode escape sequence");
+                    int nybble;
+                    if (c >= '0' && c <= '9')
+                    {
+                        nybble = c - '0';
+                    }
+                    else if (c >= 'a' && c <= 'f')
+                    {
+                        nybble = c - 'a' + 10;
+                    }
+                    else if (c >= 'A' && c <= 'F')
+                    {
+                        nybble = c - 'A' + 10;
+                    }
+                    else
+                    {
+                        throw reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in character escape sequence: U+{0:x4}", (int) c));
+                    }
+                    result = (result << 4) + nybble;
+                }
+                return (char) result;
+            }
+
+            /// <summary>
+            /// Consumes a text-only literal, throwing an exception if the read text doesn't match it.
+            /// It is assumed that the first letter of the literal has already been read.
+            /// </summary>
+            private void ConsumeLiteral(string text)
+            {
+                for (int i = 1; i < text.Length; i++)
+                {
+                    char? next = reader.Read();
+                    if (next == null)
+                    {
+                        throw reader.CreateException("Unexpected end of text while reading literal token " + text);
+                    }
+                    if (next.Value != text[i])
+                    {
+                        throw reader.CreateException("Unexpected character while reading literal token " + text);
+                    }
+                }
+            }
+
+            private double ReadNumber(char initialCharacter)
+            {
+                StringBuilder builder = new StringBuilder();
+                if (initialCharacter == '-')
+                {
+                    builder.Append("-");
+                }
+                else
+                {
+                    reader.PushBack(initialCharacter);
+                }
+                // Each method returns the character it read that doesn't belong in that part,
+                // so we know what to do next, including pushing the character back at the end.
+                // null is returned for "end of text".
+                char? next = ReadInt(builder);
+                if (next == '.')
+                {
+                    next = ReadFrac(builder);
+                }
+                if (next == 'e' || next == 'E')
+                {
+                    next = ReadExp(builder);
+                }
+                // If we read a character which wasn't part of the number, push it back so we can read it again
+                // to parse the next token.
+                if (next != null)
+                {
+                    reader.PushBack(next.Value);
+                }
+
+                // TODO: What exception should we throw if the value can't be represented as a double?
+                try
+                {
+                    return double.Parse(builder.ToString(),
+                        NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent,
+                        CultureInfo.InvariantCulture);
+                }
+                catch (OverflowException)
+                {
+                    throw reader.CreateException("Numeric value out of range: " + builder);
+                }
+            }
+
+            private char? ReadInt(StringBuilder builder)
+            {
+                char first = reader.ReadOrFail("Invalid numeric literal");
+                if (first < '0' || first > '9')
+                {
+                    throw reader.CreateException("Invalid numeric literal");
+                }
+                builder.Append(first);
+                int digitCount;
+                char? next = ConsumeDigits(builder, out digitCount);
+                if (first == '0' && digitCount != 0)
+                {
+                    throw reader.CreateException("Invalid numeric literal: leading 0 for non-zero value.");
+                }
+                return next;
+            }
+
+            private char? ReadFrac(StringBuilder builder)
+            {
+                builder.Append('.'); // Already consumed this
+                int digitCount;
+                char? next = ConsumeDigits(builder, out digitCount);
+                if (digitCount == 0)
+                {
+                    throw reader.CreateException("Invalid numeric literal: fraction with no trailing digits");
+                }
+                return next;
+            }
+
+            private char? ReadExp(StringBuilder builder)
+            {
+                builder.Append('E'); // Already consumed this (or 'e')
+                char? next = reader.Read();
+                if (next == null)
+                {
+                    throw reader.CreateException("Invalid numeric literal: exponent with no trailing digits");
+                }
+                if (next == '-' || next == '+')
+                {
+                    builder.Append(next.Value);
+                }
+                else
+                {
+                    reader.PushBack(next.Value);
+                }
+                int digitCount;
+                next = ConsumeDigits(builder, out digitCount);
+                if (digitCount == 0)
+                {
+                    throw reader.CreateException("Invalid numeric literal: exponent without value");
+                }
+                return next;
+            }
+
+            private char? ConsumeDigits(StringBuilder builder, out int count)
+            {
+                count = 0;
+                while (true)
+                {
+                    char? next = reader.Read();
+                    if (next == null || next.Value < '0' || next.Value > '9')
+                    {
+                        return next;
+                    }
+                    count++;
+                    builder.Append(next.Value);
+                }
+            }
+
+            /// <summary>
+            /// Validates that we're in a valid state to read a value (using the given error prefix if necessary)
+            /// and changes the state to the appropriate one, e.g. ObjectAfterColon to ObjectAfterProperty.
+            /// </summary>
+            private void ValidateAndModifyStateForValue(string errorPrefix)
+            {
+                ValidateState(ValueStates, errorPrefix);
+                switch (state)
+                {
+                    case State.StartOfDocument:
+                        state = State.ExpectedEndOfDocument;
+                        return;
+                    case State.ObjectAfterColon:
+                        state = State.ObjectAfterProperty;
+                        return;
+                    case State.ArrayStart:
+                    case State.ArrayAfterComma:
+                        state = State.ArrayAfterValue;
+                        return;
+                    default:
+                        throw new InvalidOperationException("ValidateAndModifyStateForValue does not handle all value states (and should)");
+                }
+            }
+
+            /// <summary>
+            /// Pops the top-most container, and sets the state to the appropriate one for the end of a value
+            /// in the parent container.
+            /// </summary>
+            private void PopContainer()
+            {
+                containerStack.Pop();
+                var parent = containerStack.Peek();
+                switch (parent)
+                {
+                    case ContainerType.Object:
+                        state = State.ObjectAfterProperty;
+                        break;
+                    case ContainerType.Array:
+                        state = State.ArrayAfterValue;
+                        break;
+                    case ContainerType.Document:
+                        state = State.ExpectedEndOfDocument;
+                        break;
+                    default:
+                        throw new InvalidOperationException("Unexpected container type: " + parent);
+                }
+            }
+
+            private enum ContainerType
+            {
+                Document, Object, Array
+            }
+
+            /// <summary>
+            /// Possible states of the tokenizer.
+            /// </summary>
+            /// <remarks>
+            /// <para>This is a flags enum purely so we can simply and efficiently represent a set of valid states
+            /// for checking.</para>
+            /// <para>
+            /// Each is documented with an example,
+            /// where ^ represents the current position within the text stream. The examples all use string values,
+            /// but could be any value, including nested objects/arrays.
+            /// The complete state of the tokenizer also includes a stack to indicate the contexts (arrays/objects).
+            /// Any additional notional state of "AfterValue" indicates that a value has been completed, at which
+            /// point there's an immediate transition to ExpectedEndOfDocument,  ObjectAfterProperty or ArrayAfterValue.
+            /// </para>
+            /// <para>
+            /// These states were derived manually by reading RFC 7159 carefully.
+            /// </para>
+            /// </remarks>
+            [Flags]
+            private enum State
+            {
+                /// <summary>
+                /// ^ { "foo": "bar" }
+                /// Before the value in a document. Next states: ObjectStart, ArrayStart, "AfterValue"
+                /// </summary>
+                StartOfDocument = 1 << 0,
+                /// <summary>
+                /// { "foo": "bar" } ^
+                /// After the value in a document. Next states: ReaderExhausted
+                /// </summary>
+                ExpectedEndOfDocument = 1 << 1,
+                /// <summary>
+                /// { "foo": "bar" } ^ (and already read to the end of the reader)
+                /// Terminal state.
+                /// </summary>
+                ReaderExhausted = 1 << 2,
+                /// <summary>
+                /// { ^ "foo": "bar" }
+                /// Before the *first* property in an object.
+                /// Next states:
+                /// "AfterValue" (empty object)
+                /// ObjectBeforeColon (read a name)
+                /// </summary>
+                ObjectStart = 1 << 3,
+                /// <summary>
+                /// { "foo" ^ : "bar", "x": "y" }
+                /// Next state: ObjectAfterColon
+                /// </summary>
+                ObjectBeforeColon = 1 << 4,
+                /// <summary>
+                /// { "foo" : ^ "bar", "x": "y" }
+                /// Before any property other than the first in an object.
+                /// (Equivalently: after any property in an object)
+                /// Next states:
+                /// "AfterValue" (value is simple)
+                /// ObjectStart (value is object)
+                /// ArrayStart (value is array)
+                /// </summary>
+                ObjectAfterColon = 1 << 5,
+                /// <summary>
+                /// { "foo" : "bar" ^ , "x" : "y" }
+                /// At the end of a property, so expecting either a comma or end-of-object
+                /// Next states: ObjectAfterComma or "AfterValue"
+                /// </summary>
+                ObjectAfterProperty = 1 << 6,
+                /// <summary>
+                /// { "foo":"bar", ^ "x":"y" }
+                /// Read the comma after the previous property, so expecting another property.
+                /// This is like ObjectStart, but closing brace isn't valid here
+                /// Next state: ObjectBeforeColon.
+                /// </summary>
+                ObjectAfterComma = 1 << 7,
+                /// <summary>
+                /// [ ^ "foo", "bar" ]
+                /// Before the *first* value in an array.
+                /// Next states:
+                /// "AfterValue" (read a value)
+                /// "AfterValue" (end of array; will pop stack)
+                /// </summary>
+                ArrayStart = 1 << 8,
+                /// <summary>
+                /// [ "foo" ^ , "bar" ]
+                /// After any value in an array, so expecting either a comma or end-of-array
+                /// Next states: ArrayAfterComma or "AfterValue"
+                /// </summary>
+                ArrayAfterValue = 1 << 9,
+                /// <summary>
+                /// [ "foo", ^ "bar" ]
+                /// After a comma in an array, so there *must* be another value (simple or complex).
+                /// Next states: "AfterValue" (simple value), StartObject, StartArray
+                /// </summary>
+                ArrayAfterComma = 1 << 10
+            }
+
+            /// <summary>
+            /// Wrapper around a text reader allowing small amounts of buffering and location handling.
+            /// </summary>
+            private class PushBackReader
+            {
+                // TODO: Add locations for errors etc.
+
+                private readonly TextReader reader;
+
+                internal PushBackReader(TextReader reader)
+                {
+                    // TODO: Wrap the reader in a BufferedReader?
+                    this.reader = reader;
+                }
+
+                /// <summary>
+                /// The buffered next character, if we have one.
+                /// </summary>
+                private char? nextChar;
+
+                /// <summary>
+                /// Returns the next character in the stream, or null if we have reached the end.
+                /// </summary>
+                /// <returns></returns>
+                internal char? Read()
+                {
+                    if (nextChar != null)
+                    {
+                        char? tmp = nextChar;
+                        nextChar = null;
+                        return tmp;
+                    }
+                    int next = reader.Read();
+                    return next == -1 ? null : (char?) next;
+                }
+
+                internal char ReadOrFail(string messageOnFailure)
+                {
+                    char? next = Read();
+                    if (next == null)
+                    {
+                        throw CreateException(messageOnFailure);
+                    }
+                    return next.Value;
+                }
+
+                internal void PushBack(char c)
+                {
+                    if (nextChar != null)
+                    {
+                        throw new InvalidOperationException("Cannot push back when already buffering a character");
+                    }
+                    nextChar = c;
+                }
+
+                /// <summary>
+                /// Creates a new exception appropriate for the current state of the reader.
+                /// </summary>
+                internal InvalidJsonException CreateException(string message)
+                {
+                    // TODO: Keep track of and use the location.
+                    return new InvalidJsonException(message);
+                }
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/LC.Google.Protobuf.csproj b/Libs/Google.Protobuf/LC.Google.Protobuf.csproj
new file mode 100644
index 0000000..b725648
--- /dev/null
+++ b/Libs/Google.Protobuf/LC.Google.Protobuf.csproj
@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Description>C# runtime library for Protocol Buffers - Google's data interchange format.</Description>
+    <Copyright>Copyright 2015, Google Inc.</Copyright>
+    <AssemblyTitle>Google Protocol Buffers</AssemblyTitle>
+    <VersionPrefix>3.15.6</VersionPrefix>
+    <!-- C# 7.2 is required for Span/BufferWriter/ReadOnlySequence -->
+    <LangVersion>7.2</LangVersion>
+    <Authors>Google Inc.</Authors>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <AssemblyOriginatorKeyFile>./keys/Google.Protobuf.snk</AssemblyOriginatorKeyFile>
+    <SignAssembly>true</SignAssembly>
+    <PackageTags>Protocol;Buffers;Binary;Serialization;Format;Google;proto;proto3</PackageTags>
+    <PackageReleaseNotes>C# proto3 support</PackageReleaseNotes>
+    <PackageProjectUrl>https://github.com/protocolbuffers/protobuf</PackageProjectUrl>
+    <PackageLicenseUrl>https://github.com/protocolbuffers/protobuf/blob/master/LICENSE</PackageLicenseUrl>
+    <RepositoryType>git</RepositoryType>
+    <RepositoryUrl>https://github.com/protocolbuffers/protobuf.git</RepositoryUrl>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <!-- Include PDB in the built .nupkg -->
+    <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
+    <ReleaseVersion>0.7.1</ReleaseVersion>
+    <AssemblyName>LC.Google.Protobuf</AssemblyName>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+    <DefineConstants>$(DefineConstants);GOOGLE_PROTOBUF_SUPPORT_FAST_STRING</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'net50' ">
+    <DefineConstants>$(DefineConstants);GOOGLE_PROTOBUF_SUPPORT_FAST_STRING;GOOGLE_PROTOBUF_SIMD</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All" Version="1.0.0" />
+    <!-- Needed for the net45 build to work on Unix. See https://github.com/dotnet/designs/pull/33 -->
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" PrivateAssets="All" Version="1.0.0" />
+    <PackageReference Include="System.Memory" Version="4.5.4" />
+  </ItemGroup>
+
+</Project>
diff --git a/Libs/Google.Protobuf/LimitedInputStream.cs b/Libs/Google.Protobuf/LimitedInputStream.cs
new file mode 100644
index 0000000..7888c06
--- /dev/null
+++ b/Libs/Google.Protobuf/LimitedInputStream.cs
@@ -0,0 +1,110 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.IO;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Stream implementation which proxies another stream, only allowing a certain amount
+    /// of data to be read. Note that this is only used to read delimited streams, so it
+    /// doesn't attempt to implement everything.
+    /// </summary>
+    internal sealed class LimitedInputStream : Stream
+    {
+        private readonly Stream proxied;
+        private int bytesLeft;
+
+        internal LimitedInputStream(Stream proxied, int size)
+        {
+            this.proxied = proxied;
+            bytesLeft = size;
+        }
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override long Length
+        {
+            get { throw new NotSupportedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (bytesLeft > 0)
+            {
+                int bytesRead = proxied.Read(buffer, offset, Math.Min(bytesLeft, count));
+                bytesLeft -= bytesRead;
+                return bytesRead;
+            }
+            return 0;
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/MessageExtensions.cs b/Libs/Google.Protobuf/MessageExtensions.cs
new file mode 100644
index 0000000..1bbb01e
--- /dev/null
+++ b/Libs/Google.Protobuf/MessageExtensions.cs
@@ -0,0 +1,306 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Reflection;
+using System.Buffers;
+using System.Collections;
+using System;
+using System.IO;
+using System.Linq;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Extension methods on <see cref="IMessage"/> and <see cref="IMessage{T}"/>.
+    /// </summary>
+    public static class MessageExtensions
+    {
+        /// <summary>
+        /// Merges data from the given byte array into an existing message.
+        /// </summary>
+        /// <param name="message">The message to merge the data into.</param>
+        /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param>
+        public static void MergeFrom(this IMessage message, byte[] data) =>
+            MergeFrom(message, data, false, null);
+
+        /// <summary>
+        /// Merges data from the given byte array slice into an existing message.
+        /// </summary>
+        /// <param name="message">The message to merge the data into.</param>
+        /// <param name="data">The data containing the slice to merge, which must be protobuf-encoded binary data.</param>
+        /// <param name="offset">The offset of the slice to merge.</param>
+        /// <param name="length">The length of the slice to merge.</param>
+        public static void MergeFrom(this IMessage message, byte[] data, int offset, int length) =>
+            MergeFrom(message, data, offset, length, false, null);
+
+        /// <summary>
+        /// Merges data from the given byte string into an existing message.
+        /// </summary>
+        /// <param name="message">The message to merge the data into.</param>
+        /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param>
+        public static void MergeFrom(this IMessage message, ByteString data) =>
+            MergeFrom(message, data, false, null);
+
+        /// <summary>
+        /// Merges data from the given stream into an existing message.
+        /// </summary>
+        /// <param name="message">The message to merge the data into.</param>
+        /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param>
+        public static void MergeFrom(this IMessage message, Stream input) =>
+            MergeFrom(message, input, false, null);
+
+        /// <summary>
+        /// Merges length-delimited data from the given stream into an existing message.
+        /// </summary>
+        /// <remarks>
+        /// The stream is expected to contain a length and then the data. Only the amount of data
+        /// specified by the length will be consumed.
+        /// </remarks>
+        /// <param name="message">The message to merge the data into.</param>
+        /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param>
+        public static void MergeDelimitedFrom(this IMessage message, Stream input) =>
+            MergeDelimitedFrom(message, input, false, null);
+
+        /// <summary>
+        /// Converts the given message into a byte array in protobuf encoding.
+        /// </summary>
+        /// <param name="message">The message to convert.</param>
+        /// <returns>The message data as a byte array.</returns>
+        public static byte[] ToByteArray(this IMessage message)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            byte[] result = new byte[message.CalculateSize()];
+            CodedOutputStream output = new CodedOutputStream(result);
+            message.WriteTo(output);
+            output.CheckNoSpaceLeft();
+            return result;
+        }
+
+        /// <summary>
+        /// Writes the given message data to the given stream in protobuf encoding.
+        /// </summary>
+        /// <param name="message">The message to write to the stream.</param>
+        /// <param name="output">The stream to write to.</param>
+        public static void WriteTo(this IMessage message, Stream output)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(output, "output");
+            CodedOutputStream codedOutput = new CodedOutputStream(output);
+            message.WriteTo(codedOutput);
+            codedOutput.Flush();
+        }
+
+        /// <summary>
+        /// Writes the length and then data of the given message to a stream.
+        /// </summary>
+        /// <param name="message">The message to write.</param>
+        /// <param name="output">The output stream to write to.</param>
+        public static void WriteDelimitedTo(this IMessage message, Stream output)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(output, "output");
+            CodedOutputStream codedOutput = new CodedOutputStream(output);
+            codedOutput.WriteLength(message.CalculateSize());
+            message.WriteTo(codedOutput);
+            codedOutput.Flush();
+        }
+
+        /// <summary>
+        /// Converts the given message into a byte string in protobuf encoding.
+        /// </summary>
+        /// <param name="message">The message to convert.</param>
+        /// <returns>The message data as a byte string.</returns>
+        public static ByteString ToByteString(this IMessage message)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            return ByteString.AttachBytes(message.ToByteArray());
+        }
+
+        /// <summary>
+        /// Writes the given message data to the given buffer writer in protobuf encoding.
+        /// </summary>
+        /// <param name="message">The message to write to the stream.</param>
+        /// <param name="output">The stream to write to.</param>
+        [SecuritySafeCritical]
+        public static void WriteTo(this IMessage message, IBufferWriter<byte> output)
+        {
+            ProtoPreconditions.CheckNotNull(message, nameof(message));
+            ProtoPreconditions.CheckNotNull(output, nameof(output));
+
+            WriteContext.Initialize(output, out WriteContext ctx);
+            WritingPrimitivesMessages.WriteRawMessage(ref ctx, message);
+            ctx.Flush();
+        }
+
+        /// <summary>
+        /// Writes the given message data to the given span in protobuf encoding.
+        /// The size of the destination span needs to fit the serialized size
+        /// of the message exactly, otherwise an exception is thrown.
+        /// </summary>
+        /// <param name="message">The message to write to the stream.</param>
+        /// <param name="output">The span to write to. Size must match size of the message exactly.</param>
+        [SecuritySafeCritical]
+        public static void WriteTo(this IMessage message, Span<byte> output)
+        {
+            ProtoPreconditions.CheckNotNull(message, nameof(message));
+
+            WriteContext.Initialize(ref output, out WriteContext ctx);
+            WritingPrimitivesMessages.WriteRawMessage(ref ctx, message);
+            ctx.CheckNoSpaceLeft();
+        }
+
+        /// <summary>
+        /// Checks if all required fields in a message have values set. For proto3 messages, this returns true
+        /// </summary>
+        public static bool IsInitialized(this IMessage message)
+        {
+            if (message.Descriptor.File.Syntax == Syntax.Proto3)
+            {
+                return true;
+            }
+
+            if (!message.Descriptor.IsExtensionsInitialized(message))
+            {
+                return false;
+            }
+
+            return message.Descriptor
+                .Fields
+                .InDeclarationOrder()
+                .All(f =>
+                {
+                    if (f.IsMap)
+                    {
+                        var valueField = f.MessageType.Fields[2];
+                        if (valueField.FieldType == FieldType.Message)
+                        {
+                            var map = (IDictionary)f.Accessor.GetValue(message);
+                            return map.Values.Cast<IMessage>().All(IsInitialized);
+                        }
+                        else
+                        {
+                            return true;
+                        }
+                    }
+                    else if (f.IsRepeated && f.FieldType == FieldType.Message || f.FieldType == FieldType.Group)
+                    {
+                        var enumerable = (IEnumerable)f.Accessor.GetValue(message);
+                        return enumerable.Cast<IMessage>().All(IsInitialized);
+                    }
+                    else if (f.FieldType == FieldType.Message || f.FieldType == FieldType.Group)
+                    {
+                        if (f.Accessor.HasValue(message))
+                        {
+                            return ((IMessage)f.Accessor.GetValue(message)).IsInitialized();
+                        }
+                        else
+                        {
+                            return !f.IsRequired;
+                        }
+                    }
+                    else if (f.IsRequired)
+                    {
+                        return f.Accessor.HasValue(message);
+                    }
+                    else
+                    {
+                        return true;
+                    }
+                });
+        }
+
+        // Implementations allowing unknown fields to be discarded.
+        internal static void MergeFrom(this IMessage message, byte[] data, bool discardUnknownFields, ExtensionRegistry registry)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(data, "data");
+            CodedInputStream input = new CodedInputStream(data);
+            input.DiscardUnknownFields = discardUnknownFields;
+            input.ExtensionRegistry = registry;
+            message.MergeFrom(input);
+            input.CheckReadEndOfStreamTag();
+        }
+
+        internal static void MergeFrom(this IMessage message, byte[] data, int offset, int length, bool discardUnknownFields, ExtensionRegistry registry)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(data, "data");
+            CodedInputStream input = new CodedInputStream(data, offset, length);
+            input.DiscardUnknownFields = discardUnknownFields;
+            input.ExtensionRegistry = registry;
+            message.MergeFrom(input);
+            input.CheckReadEndOfStreamTag();
+        }
+
+        internal static void MergeFrom(this IMessage message, ByteString data, bool discardUnknownFields, ExtensionRegistry registry)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(data, "data");
+            CodedInputStream input = data.CreateCodedInput();
+            input.DiscardUnknownFields = discardUnknownFields;
+            input.ExtensionRegistry = registry;
+            message.MergeFrom(input);
+            input.CheckReadEndOfStreamTag();
+        }
+
+        internal static void MergeFrom(this IMessage message, Stream input, bool discardUnknownFields, ExtensionRegistry registry)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(input, "input");
+            CodedInputStream codedInput = new CodedInputStream(input);
+            codedInput.DiscardUnknownFields = discardUnknownFields;
+            codedInput.ExtensionRegistry = registry;
+            message.MergeFrom(codedInput);
+            codedInput.CheckReadEndOfStreamTag();
+        }
+
+        [SecuritySafeCritical]
+        internal static void MergeFrom(this IMessage message, ReadOnlySequence<byte> data, bool discardUnknownFields, ExtensionRegistry registry)
+        {
+            ParseContext.Initialize(data, out ParseContext ctx);
+            ctx.DiscardUnknownFields = discardUnknownFields;
+            ctx.ExtensionRegistry = registry;
+            ParsingPrimitivesMessages.ReadRawMessage(ref ctx, message);
+            ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref ctx.state);
+        }
+
+        internal static void MergeDelimitedFrom(this IMessage message, Stream input, bool discardUnknownFields, ExtensionRegistry registry)
+        {
+            ProtoPreconditions.CheckNotNull(message, "message");
+            ProtoPreconditions.CheckNotNull(input, "input");
+            int size = (int) CodedInputStream.ReadRawVarint32(input);
+            Stream limitedStream = new LimitedInputStream(input, size);
+            MergeFrom(message, limitedStream, discardUnknownFields, registry);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/MessageParser.cs b/Libs/Google.Protobuf/MessageParser.cs
new file mode 100644
index 0000000..90cf5ad
--- /dev/null
+++ b/Libs/Google.Protobuf/MessageParser.cs
@@ -0,0 +1,376 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// A general message parser, typically used by reflection-based code as all the methods
+    /// return simple <see cref="IMessage"/>.
+    /// </summary>
+    public class MessageParser
+    {
+        private Func<IMessage> factory;
+        // TODO: When we use a C# 7.1 compiler, make this private protected.
+        internal bool DiscardUnknownFields { get; }
+
+        internal ExtensionRegistry Extensions { get; }
+
+        internal MessageParser(Func<IMessage> factory, bool discardUnknownFields, ExtensionRegistry extensions)
+        {
+            this.factory = factory;
+            DiscardUnknownFields = discardUnknownFields;
+            Extensions = extensions;
+        }
+
+        /// <summary>
+        /// Creates a template instance ready for population.
+        /// </summary>
+        /// <returns>An empty message.</returns>
+        internal IMessage CreateTemplate()
+        {
+            return factory();
+        }
+
+        /// <summary>
+        /// Parses a message from a byte array.
+        /// </summary>
+        /// <param name="data">The byte array containing the message. Must not be null.</param>
+        /// <returns>The newly parsed message.</returns>
+        public IMessage ParseFrom(byte[] data)
+        {
+            IMessage message = factory();
+            message.MergeFrom(data, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from a byte array slice.
+        /// </summary>
+        /// <param name="data">The byte array containing the message. Must not be null.</param>
+        /// <param name="offset">The offset of the slice to parse.</param>
+        /// <param name="length">The length of the slice to parse.</param>
+        /// <returns>The newly parsed message.</returns>
+        public IMessage ParseFrom(byte[] data, int offset, int length)
+        {
+            IMessage message = factory();
+            message.MergeFrom(data, offset, length, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given byte string.
+        /// </summary>
+        /// <param name="data">The data to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public IMessage ParseFrom(ByteString data)
+        {
+            IMessage message = factory();
+            message.MergeFrom(data, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given stream.
+        /// </summary>
+        /// <param name="input">The stream to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public IMessage ParseFrom(Stream input)
+        {
+            IMessage message = factory();
+            message.MergeFrom(input, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given sequence.
+        /// </summary>
+        /// <param name="data">The data to parse.</param>
+        /// <returns>The parsed message.</returns>
+        [SecuritySafeCritical]
+        public IMessage ParseFrom(ReadOnlySequence<byte> data)
+        {
+            IMessage message = factory();
+            message.MergeFrom(data, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a length-delimited message from the given stream.
+        /// </summary>
+        /// <remarks>
+        /// The stream is expected to contain a length and then the data. Only the amount of data
+        /// specified by the length will be consumed.
+        /// </remarks>
+        /// <param name="input">The stream to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public IMessage ParseDelimitedFrom(Stream input)
+        {
+            IMessage message = factory();
+            message.MergeDelimitedFrom(input, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given coded input stream.
+        /// </summary>
+        /// <param name="input">The stream to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public IMessage ParseFrom(CodedInputStream input)
+        {
+            IMessage message = factory();
+            MergeFrom(message, input);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given JSON.
+        /// </summary>
+        /// <param name="json">The JSON to parse.</param>
+        /// <returns>The parsed message.</returns>
+        /// <exception cref="InvalidJsonException">The JSON does not comply with RFC 7159</exception>
+        /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
+        public IMessage ParseJson(string json)
+        {
+            IMessage message = factory();
+            JsonParser.Default.Merge(message, json);
+            return message;
+        }
+
+        // TODO: When we're using a C# 7.1 compiler, make this private protected.
+        internal void MergeFrom(IMessage message, CodedInputStream codedInput)
+        {
+            bool originalDiscard = codedInput.DiscardUnknownFields;
+            try
+            {
+                codedInput.DiscardUnknownFields = DiscardUnknownFields;
+                message.MergeFrom(codedInput);
+            }
+            finally
+            {
+                codedInput.DiscardUnknownFields = originalDiscard;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new message parser which optionally discards unknown fields when parsing.
+        /// </summary>
+        /// <param name="discardUnknownFields">Whether or not to discard unknown fields when parsing.</param>
+        /// <returns>A newly configured message parser.</returns>
+        public MessageParser WithDiscardUnknownFields(bool discardUnknownFields) =>
+            new MessageParser(factory, discardUnknownFields, Extensions);
+
+        /// <summary>
+        /// Creates a new message parser which registers extensions from the specified registry upon creating the message instance
+        /// </summary>
+        /// <param name="registry">The extensions to register</param>
+        /// <returns>A newly configured message parser.</returns>
+        public MessageParser WithExtensionRegistry(ExtensionRegistry registry) =>
+            new MessageParser(factory, DiscardUnknownFields, registry);
+    }
+
+    /// <summary>
+    /// A parser for a specific message type.
+    /// </summary>
+    /// <remarks>
+    /// <p>
+    /// This delegates most behavior to the
+    /// <see cref="IMessage.MergeFrom"/> implementation within the original type, but
+    /// provides convenient overloads to parse from a variety of sources.
+    /// </p>
+    /// <p>
+    /// Most applications will never need to create their own instances of this type;
+    /// instead, use the static <c>Parser</c> property of a generated message type to obtain a
+    /// parser for that type.
+    /// </p>
+    /// </remarks>
+    /// <typeparam name="T">The type of message to be parsed.</typeparam>
+    public sealed class MessageParser<T> : MessageParser where T : IMessage<T>
+    {
+        // Implementation note: all the methods here *could* just delegate up to the base class and cast the result.
+        // The current implementation avoids a virtual method call and a cast, which *may* be significant in some cases.
+        // Benchmarking work is required to measure the significance - but it's only a few lines of code in any case.
+        // The API wouldn't change anyway - just the implementation - so this work can be deferred.
+        private readonly Func<T> factory;
+
+        /// <summary>
+        /// Creates a new parser.
+        /// </summary>
+        /// <remarks>
+        /// The factory method is effectively an optimization over using a generic constraint
+        /// to require a parameterless constructor: delegates are significantly faster to execute.
+        /// </remarks>
+        /// <param name="factory">Function to invoke when a new, empty message is required.</param>
+        public MessageParser(Func<T> factory) : this(factory, false, null)
+        {
+        }
+
+        internal MessageParser(Func<T> factory, bool discardUnknownFields, ExtensionRegistry extensions) : base(() => factory(), discardUnknownFields, extensions)
+        {
+            this.factory = factory;
+        }
+
+        /// <summary>
+        /// Creates a template instance ready for population.
+        /// </summary>
+        /// <returns>An empty message.</returns>
+        internal new T CreateTemplate()
+        {
+            return factory();
+        }
+
+        /// <summary>
+        /// Parses a message from a byte array.
+        /// </summary>
+        /// <param name="data">The byte array containing the message. Must not be null.</param>
+        /// <returns>The newly parsed message.</returns>
+        public new T ParseFrom(byte[] data)
+        {
+            T message = factory();
+            message.MergeFrom(data, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from a byte array slice.
+        /// </summary>
+        /// <param name="data">The byte array containing the message. Must not be null.</param>
+        /// <param name="offset">The offset of the slice to parse.</param>
+        /// <param name="length">The length of the slice to parse.</param>
+        /// <returns>The newly parsed message.</returns>
+        public new T ParseFrom(byte[] data, int offset, int length)
+        {
+            T message = factory();
+            message.MergeFrom(data, offset, length, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given byte string.
+        /// </summary>
+        /// <param name="data">The data to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public new T ParseFrom(ByteString data)
+        {
+            T message = factory();
+            message.MergeFrom(data, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given stream.
+        /// </summary>
+        /// <param name="input">The stream to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public new T ParseFrom(Stream input)
+        {
+            T message = factory();
+            message.MergeFrom(input, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given sequence.
+        /// </summary>
+        /// <param name="data">The data to parse.</param>
+        /// <returns>The parsed message.</returns>
+        [SecuritySafeCritical]
+        public new T ParseFrom(ReadOnlySequence<byte> data)
+        {
+            T message = factory();
+            message.MergeFrom(data, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a length-delimited message from the given stream.
+        /// </summary>
+        /// <remarks>
+        /// The stream is expected to contain a length and then the data. Only the amount of data
+        /// specified by the length will be consumed.
+        /// </remarks>
+        /// <param name="input">The stream to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public new T ParseDelimitedFrom(Stream input)
+        {
+            T message = factory();
+            message.MergeDelimitedFrom(input, DiscardUnknownFields, Extensions);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given coded input stream.
+        /// </summary>
+        /// <param name="input">The stream to parse.</param>
+        /// <returns>The parsed message.</returns>
+        public new T ParseFrom(CodedInputStream input)
+        {
+            T message = factory();
+            MergeFrom(message, input);
+            return message;
+        }
+
+        /// <summary>
+        /// Parses a message from the given JSON.
+        /// </summary>
+        /// <param name="json">The JSON to parse.</param>
+        /// <returns>The parsed message.</returns>
+        /// <exception cref="InvalidJsonException">The JSON does not comply with RFC 7159</exception>
+        /// <exception cref="InvalidProtocolBufferException">The JSON does not represent a Protocol Buffers message correctly</exception>
+        public new T ParseJson(string json)
+        {
+            T message = factory();
+            JsonParser.Default.Merge(message, json);
+            return message;
+        }
+
+        /// <summary>
+        /// Creates a new message parser which optionally discards unknown fields when parsing.
+        /// </summary>
+        /// <param name="discardUnknownFields">Whether or not to discard unknown fields when parsing.</param>
+        /// <returns>A newly configured message parser.</returns>
+        public new MessageParser<T> WithDiscardUnknownFields(bool discardUnknownFields) =>
+            new MessageParser<T>(factory, discardUnknownFields, Extensions);
+
+        /// <summary>
+        /// Creates a new message parser which registers extensions from the specified registry upon creating the message instance
+        /// </summary>
+        /// <param name="registry">The extensions to register</param>
+        /// <returns>A newly configured message parser.</returns>
+        public new MessageParser<T> WithExtensionRegistry(ExtensionRegistry registry) =>
+            new MessageParser<T>(factory, DiscardUnknownFields, registry);
+    }
+}
diff --git a/Libs/Google.Protobuf/ObjectIntPair.cs b/Libs/Google.Protobuf/ObjectIntPair.cs
new file mode 100644
index 0000000..d834228
--- /dev/null
+++ b/Libs/Google.Protobuf/ObjectIntPair.cs
@@ -0,0 +1,40 @@
+using System;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Struct used to hold the keys for the fieldByNumber table in DescriptorPool and the keys for the 
+    /// extensionByNumber table in ExtensionRegistry.
+    /// </summary>
+    internal struct ObjectIntPair<T> : IEquatable<ObjectIntPair<T>> where T : class
+    {
+        private readonly int number;
+        private readonly T obj;
+
+        internal ObjectIntPair(T obj, int number)
+        {
+            this.number = number;
+            this.obj = obj;
+        }
+
+        public bool Equals(ObjectIntPair<T> other)
+        {
+            return obj == other.obj
+                   && number == other.number;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is ObjectIntPair<T>)
+            {
+                return Equals((ObjectIntPair<T>)obj);
+            }
+            return false;
+        }
+
+        public override int GetHashCode()
+        {
+            return obj.GetHashCode() * ((1 << 16) - 1) + number;
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/ParseContext.cs b/Libs/Google.Protobuf/ParseContext.cs
new file mode 100644
index 0000000..e2f368f
--- /dev/null
+++ b/Libs/Google.Protobuf/ParseContext.cs
@@ -0,0 +1,329 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// An opaque struct that represents the current parsing state and is passed along
+    /// as the parsing proceeds.
+    /// All the public methods are intended to be invoked only by the generated code,
+    /// users should never invoke them directly.
+    /// </summary>
+    [SecuritySafeCritical]
+    public ref struct ParseContext
+    {
+        internal const int DefaultRecursionLimit = 100;
+        internal const int DefaultSizeLimit = Int32.MaxValue;
+
+        internal ReadOnlySpan<byte> buffer;
+        internal ParserInternalState state;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, out ParseContext ctx)
+        {
+            ctx.buffer = buffer;
+            ctx.state = state;
+        }
+
+        /// <summary>
+        /// Creates a ParseContext instance from CodedInputStream.
+        /// WARNING: internally this copies the CodedInputStream's state, so after done with the ParseContext,
+        /// the CodedInputStream's state needs to be updated.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(CodedInputStream input, out ParseContext ctx)
+        {
+            ctx.buffer = new ReadOnlySpan<byte>(input.InternalBuffer);
+            // ideally we would use a reference to the original state, but that doesn't seem possible
+            // so we just copy the struct that holds the state. We will need to later store the state back
+            // into CodedInputStream if we want to keep it usable.
+            ctx.state = input.InternalState;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(ReadOnlySequence<byte> input, out ParseContext ctx)
+        {
+            Initialize(input, DefaultRecursionLimit, out ctx);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(ReadOnlySequence<byte> input, int recursionLimit, out ParseContext ctx)
+        {
+            ctx.buffer = default;
+            ctx.state = default;
+            ctx.state.lastTag = 0;
+            ctx.state.recursionDepth = 0;
+            ctx.state.sizeLimit = DefaultSizeLimit;
+            ctx.state.recursionLimit = recursionLimit;
+            ctx.state.currentLimit = int.MaxValue;
+            SegmentedBufferHelper.Initialize(input, out ctx.state.segmentedBufferHelper, out ctx.buffer);
+            ctx.state.bufferPos = 0;
+            ctx.state.bufferSize = ctx.buffer.Length;
+
+            ctx.state.DiscardUnknownFields = false;
+            ctx.state.ExtensionRegistry = null;
+        }
+
+        /// <summary>
+        /// Returns the last tag read, or 0 if no tags have been read or we've read beyond
+        /// the end of the input.
+        /// </summary>
+        internal uint LastTag { get { return state.lastTag; } }
+
+        /// <summary>
+        /// Internal-only property; when set to true, unknown fields will be discarded while parsing.
+        /// </summary>
+        internal bool DiscardUnknownFields {
+            get { return state.DiscardUnknownFields; }
+            set { state.DiscardUnknownFields = value; }
+        }
+
+        /// <summary>
+        /// Internal-only property; provides extension identifiers to compatible messages while parsing.
+        /// </summary>
+        internal ExtensionRegistry ExtensionRegistry
+        {
+            get { return state.ExtensionRegistry; }
+            set { state.ExtensionRegistry = value; }
+        }
+
+        /// <summary>
+        /// Reads a field tag, returning the tag of 0 for "end of input".
+        /// </summary>
+        /// <remarks>
+        /// If this method returns 0, it doesn't necessarily mean the end of all
+        /// the data in this CodedInputReader; it may be the end of the logical input
+        /// for an embedded message, for example.
+        /// </remarks>
+        /// <returns>The next field tag, or 0 for end of input. (0 is never a valid tag.)</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint ReadTag()
+        {
+            return ParsingPrimitives.ParseTag(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads a double field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double ReadDouble()
+        {
+            return ParsingPrimitives.ParseDouble(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads a float field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float ReadFloat()
+        {
+            return ParsingPrimitives.ParseFloat(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads a uint64 field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ulong ReadUInt64()
+        {
+            return ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads an int64 field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public long ReadInt64()
+        {
+            return (long)ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads an int32 field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int ReadInt32()
+        {
+            return (int)ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads a fixed64 field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ulong ReadFixed64()
+        {
+            return ParsingPrimitives.ParseRawLittleEndian64(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads a fixed32 field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint ReadFixed32()
+        {
+            return ParsingPrimitives.ParseRawLittleEndian32(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads a bool field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool ReadBool()
+        {
+            return ParsingPrimitives.ParseRawVarint64(ref buffer, ref state) != 0;
+        }
+        /// <summary>
+        /// Reads a string field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadString()
+        {
+            return ParsingPrimitives.ReadString(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads an embedded message field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadMessage(IMessage message)
+        {
+            ParsingPrimitivesMessages.ReadMessage(ref this, message);
+        }
+
+        /// <summary>
+        /// Reads an embedded group field from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadGroup(IMessage message)
+        {
+            ParsingPrimitivesMessages.ReadGroup(ref this, message);
+        }
+
+        /// <summary>
+        /// Reads a bytes field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ByteString ReadBytes()
+        {
+            return ParsingPrimitives.ReadBytes(ref buffer, ref state);
+        }
+        /// <summary>
+        /// Reads a uint32 field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint ReadUInt32()
+        {
+            return ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads an enum field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int ReadEnum()
+        {
+            // Currently just a pass-through, but it's nice to separate it logically from WriteInt32.
+            return (int)ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads an sfixed32 field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int ReadSFixed32()
+        {
+            return (int)ParsingPrimitives.ParseRawLittleEndian32(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads an sfixed64 field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public long ReadSFixed64()
+        {
+            return (long)ParsingPrimitives.ParseRawLittleEndian64(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Reads an sint32 field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int ReadSInt32()
+        {
+            return ParsingPrimitives.DecodeZigZag32(ParsingPrimitives.ParseRawVarint32(ref buffer, ref state));
+        }
+
+        /// <summary>
+        /// Reads an sint64 field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public long ReadSInt64()
+        {
+            return ParsingPrimitives.DecodeZigZag64(ParsingPrimitives.ParseRawVarint64(ref buffer, ref state));
+        }
+
+        /// <summary>
+        /// Reads a length for length-delimited data.
+        /// </summary>
+        /// <remarks>
+        /// This is internally just reading a varint, but this method exists
+        /// to make the calling code clearer.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int ReadLength()
+        {
+            return (int)ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+        }
+
+        internal void CopyStateTo(CodedInputStream input)
+        {
+            input.InternalState = state;
+        }
+
+        internal void LoadStateFrom(CodedInputStream input)
+        {
+            state = input.InternalState;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/ParserInternalState.cs b/Libs/Google.Protobuf/ParserInternalState.cs
new file mode 100644
index 0000000..04bd26d
--- /dev/null
+++ b/Libs/Google.Protobuf/ParserInternalState.cs
@@ -0,0 +1,115 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+
+    // warning: this is a mutable struct, so it needs to be only passed as a ref!
+    internal struct ParserInternalState
+    {
+        // NOTE: the Span representing the current buffer is kept separate so that this doesn't have to be a ref struct and so it can
+        // be included in CodedInputStream's internal state
+
+        /// <summary>
+        /// The position within the current buffer (i.e. the next byte to read)
+        /// </summary>
+        internal int bufferPos;
+
+        /// <summary>
+        /// Size of the current buffer
+        /// </summary>
+        internal int bufferSize;
+
+        /// <summary>
+        /// If we are currently inside a length-delimited block, this is the number of
+        /// bytes in the buffer that are still available once we leave the delimited block.
+        /// </summary>
+        internal int bufferSizeAfterLimit;
+
+        /// <summary>
+        /// The absolute position of the end of the current length-delimited block (including totalBytesRetired)
+        /// </summary>
+        internal int currentLimit;
+
+        /// <summary>
+        /// The total number of consumed before the start of the current buffer. The
+        /// total bytes read up to the current position can be computed as
+        /// totalBytesRetired + bufferPos.
+        /// </summary>
+        internal int totalBytesRetired;
+
+        internal int recursionDepth;  // current recursion depth
+
+        internal SegmentedBufferHelper segmentedBufferHelper;
+
+        /// <summary>
+        /// The last tag we read. 0 indicates we've read to the end of the stream
+        /// (or haven't read anything yet).
+        /// </summary>
+        internal uint lastTag;
+
+        /// <summary>
+        /// The next tag, used to store the value read by PeekTag.
+        /// </summary>
+        internal uint nextTag;
+        internal bool hasNextTag;
+
+        // these fields are configuration, they should be readonly
+        internal int sizeLimit;
+        internal int recursionLimit;
+
+        // If non-null, the top level parse method was started with given coded input stream as an argument
+        // which also means we can potentially fallback to calling MergeFrom(CodedInputStream cis) if needed.
+        internal CodedInputStream CodedInputStream => segmentedBufferHelper.CodedInputStream;
+
+        /// <summary>
+        /// Internal-only property; when set to true, unknown fields will be discarded while parsing.
+        /// </summary>
+        internal bool DiscardUnknownFields { get; set; }
+
+        /// <summary>
+        /// Internal-only property; provides extension identifiers to compatible messages while parsing.
+        /// </summary>
+        internal ExtensionRegistry ExtensionRegistry { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/ParsingPrimitives.cs b/Libs/Google.Protobuf/ParsingPrimitives.cs
new file mode 100644
index 0000000..e807707
--- /dev/null
+++ b/Libs/Google.Protobuf/ParsingPrimitives.cs
@@ -0,0 +1,815 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Primitives for parsing protobuf wire format.
+    /// </summary>
+    [SecuritySafeCritical]
+    internal static class ParsingPrimitives
+    {
+        private const int StackallocThreshold = 256;
+
+        /// <summary>
+        /// Reads a length for length-delimited data.
+        /// </summary>
+        /// <remarks>
+        /// This is internally just reading a varint, but this method exists
+        /// to make the calling code clearer.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ParseLength(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            return (int)ParseRawVarint32(ref buffer, ref state);
+        }
+
+        /// <summary>
+        /// Parses the next tag.
+        /// If the end of logical stream was reached, an invalid tag of 0 is returned. 
+        /// </summary>
+        public static uint ParseTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            // The "nextTag" logic is there only as an optimization for reading non-packed repeated / map
+            // fields and is strictly speaking not necessary.
+            // TODO(jtattermusch): look into simplifying the ParseTag logic.
+            if (state.hasNextTag)
+            {
+                state.lastTag = state.nextTag;
+                state.hasNextTag = false;
+                return state.lastTag;
+            }
+
+            // Optimize for the incredibly common case of having at least two bytes left in the buffer,
+            // and those two bytes being enough to get the tag. This will be true for fields up to 4095.
+            if (state.bufferPos + 2 <= state.bufferSize)
+            {
+                int tmp = buffer[state.bufferPos++];
+                if (tmp < 128)
+                {
+                    state.lastTag = (uint)tmp;
+                }
+                else
+                {
+                    int result = tmp & 0x7f;
+                    if ((tmp = buffer[state.bufferPos++]) < 128)
+                    {
+                        result |= tmp << 7;
+                        state.lastTag = (uint) result;
+                    }
+                    else
+                    {
+                        // Nope, rewind and go the potentially slow route.
+                        state.bufferPos -= 2;
+                        state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+                    }
+                }
+            }
+            else
+            {
+                if (SegmentedBufferHelper.IsAtEnd(ref buffer, ref state))
+                {
+                    state.lastTag = 0;
+                    return 0;
+                }
+
+                state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+            }
+            if (WireFormat.GetTagFieldNumber(state.lastTag) == 0)
+            {
+                // If we actually read a tag with a field of 0, that's not a valid tag.
+                throw InvalidProtocolBufferException.InvalidTag();
+            }
+            return state.lastTag;
+        }
+
+        /// <summary>
+        /// Peeks at the next tag in the stream. If it matches <paramref name="tag"/>,
+        /// the tag is consumed and the method returns <c>true</c>; otherwise, the
+        /// stream is left in the original position and the method returns <c>false</c>.
+        /// </summary>
+        public static bool MaybeConsumeTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, uint tag)
+        {
+            if (PeekTag(ref buffer, ref state) == tag)
+            {
+                state.hasNextTag = false;
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Peeks at the next field tag. This is like calling <see cref="ParseTag"/>, but the
+        /// tag is not consumed. (So a subsequent call to <see cref="ParseTag"/> will return the
+        /// same value.)
+        /// </summary>
+        public static uint PeekTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            if (state.hasNextTag)
+            {
+                return state.nextTag;
+            }
+
+            uint savedLast = state.lastTag;
+            state.nextTag = ParseTag(ref buffer, ref state);
+            state.hasNextTag = true;
+            state.lastTag = savedLast; // Undo the side effect of ReadTag
+            return state.nextTag;
+        }
+
+        /// <summary>
+        /// Parses a raw varint.
+        /// </summary>
+        public static ulong ParseRawVarint64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            if (state.bufferPos + 10 > state.bufferSize)
+            {
+                return ParseRawVarint64SlowPath(ref buffer, ref state);
+            }
+
+            ulong result = buffer[state.bufferPos++];
+            if (result < 128)
+            {
+                return result;
+            }
+            result &= 0x7f;
+            int shift = 7;
+            do
+            {
+                byte b = buffer[state.bufferPos++];
+                result |= (ulong)(b & 0x7F) << shift;
+                if (b < 0x80)
+                {
+                    return result;
+                }
+                shift += 7;
+            }
+            while (shift < 64);
+
+            throw InvalidProtocolBufferException.MalformedVarint();
+        }
+
+        private static ulong ParseRawVarint64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            int shift = 0;
+            ulong result = 0;
+            do
+            {
+                byte b = ReadRawByte(ref buffer, ref state);
+                result |= (ulong)(b & 0x7F) << shift;
+                if (b < 0x80)
+                {
+                    return result;
+                }
+                shift += 7;
+            }
+            while (shift < 64);
+
+            throw InvalidProtocolBufferException.MalformedVarint();
+        }
+
+        /// <summary>
+        /// Parses a raw Varint.  If larger than 32 bits, discard the upper bits.
+        /// This method is optimised for the case where we've got lots of data in the buffer.
+        /// That means we can check the size just once, then just read directly from the buffer
+        /// without constant rechecking of the buffer length.
+        /// </summary>
+        public static uint ParseRawVarint32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            if (state.bufferPos + 5 > state.bufferSize)
+            {
+                return ParseRawVarint32SlowPath(ref buffer, ref state);
+            }
+
+            int tmp = buffer[state.bufferPos++];
+            if (tmp < 128)
+            {
+                return (uint)tmp;
+            }
+            int result = tmp & 0x7f;
+            if ((tmp = buffer[state.bufferPos++]) < 128)
+            {
+                result |= tmp << 7;
+            }
+            else
+            {
+                result |= (tmp & 0x7f) << 7;
+                if ((tmp = buffer[state.bufferPos++]) < 128)
+                {
+                    result |= tmp << 14;
+                }
+                else
+                {
+                    result |= (tmp & 0x7f) << 14;
+                    if ((tmp = buffer[state.bufferPos++]) < 128)
+                    {
+                        result |= tmp << 21;
+                    }
+                    else
+                    {
+                        result |= (tmp & 0x7f) << 21;
+                        result |= (tmp = buffer[state.bufferPos++]) << 28;
+                        if (tmp >= 128)
+                        {
+                            // Discard upper 32 bits.
+                            // Note that this has to use ReadRawByte() as we only ensure we've
+                            // got at least 5 bytes at the start of the method. This lets us
+                            // use the fast path in more cases, and we rarely hit this section of code.
+                            for (int i = 0; i < 5; i++)
+                            {
+                                if (ReadRawByte(ref buffer, ref state) < 128)
+                                {
+                                    return (uint) result;
+                                }
+                            }
+                            throw InvalidProtocolBufferException.MalformedVarint();
+                        }
+                    }
+                }
+            }
+            return (uint)result;
+        }
+
+        private static uint ParseRawVarint32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            int tmp = ReadRawByte(ref buffer, ref state);
+            if (tmp < 128)
+            {
+                return (uint) tmp;
+            }
+            int result = tmp & 0x7f;
+            if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
+            {
+                result |= tmp << 7;
+            }
+            else
+            {
+                result |= (tmp & 0x7f) << 7;
+                if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
+                {
+                    result |= tmp << 14;
+                }
+                else
+                {
+                    result |= (tmp & 0x7f) << 14;
+                    if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
+                    {
+                        result |= tmp << 21;
+                    }
+                    else
+                    {
+                        result |= (tmp & 0x7f) << 21;
+                        result |= (tmp = ReadRawByte(ref buffer, ref state)) << 28;
+                        if (tmp >= 128)
+                        {
+                            // Discard upper 32 bits.
+                            for (int i = 0; i < 5; i++)
+                            {
+                                if (ReadRawByte(ref buffer, ref state) < 128)
+                                {
+                                    return (uint) result;
+                                }
+                            }
+                            throw InvalidProtocolBufferException.MalformedVarint();
+                        }
+                    }
+                }
+            }
+            return (uint) result;
+        }
+
+        /// <summary>
+        /// Parses a 32-bit little-endian integer.
+        /// </summary>
+        public static uint ParseRawLittleEndian32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            const int uintLength = sizeof(uint);
+            const int ulongLength = sizeof(ulong);
+            if (state.bufferPos + ulongLength > state.bufferSize)
+            {
+                return ParseRawLittleEndian32SlowPath(ref buffer, ref state);
+            }
+            // ReadUInt32LittleEndian is many times slower than ReadUInt64LittleEndian (at least on some runtimes)
+            // so it's faster better to use ReadUInt64LittleEndian and truncate the result.
+            uint result = (uint) BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, ulongLength));
+            state.bufferPos += uintLength;
+            return result;
+        }
+
+        private static uint ParseRawLittleEndian32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            uint b1 = ReadRawByte(ref buffer, ref state);
+            uint b2 = ReadRawByte(ref buffer, ref state);
+            uint b3 = ReadRawByte(ref buffer, ref state);
+            uint b4 = ReadRawByte(ref buffer, ref state);
+            return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
+        }
+
+        /// <summary>
+        /// Parses a 64-bit little-endian integer.
+        /// </summary>
+        public static ulong ParseRawLittleEndian64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            const int length = sizeof(ulong);
+            if (state.bufferPos + length > state.bufferSize)
+            {
+                return ParseRawLittleEndian64SlowPath(ref buffer, ref state);
+            }
+            ulong result = BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, length));
+            state.bufferPos += length;
+            return result;
+        }
+
+        private static ulong ParseRawLittleEndian64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            ulong b1 = ReadRawByte(ref buffer, ref state);
+            ulong b2 = ReadRawByte(ref buffer, ref state);
+            ulong b3 = ReadRawByte(ref buffer, ref state);
+            ulong b4 = ReadRawByte(ref buffer, ref state);
+            ulong b5 = ReadRawByte(ref buffer, ref state);
+            ulong b6 = ReadRawByte(ref buffer, ref state);
+            ulong b7 = ReadRawByte(ref buffer, ref state);
+            ulong b8 = ReadRawByte(ref buffer, ref state);
+            return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24)
+                    | (b5 << 32) | (b6 << 40) | (b7 << 48) | (b8 << 56);
+        }
+
+        /// <summary>
+        /// Parses a double value.
+        /// </summary>
+        public static double ParseDouble(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            const int length = sizeof(double);
+            if (!BitConverter.IsLittleEndian || state.bufferPos + length > state.bufferSize)
+            {
+                return BitConverter.Int64BitsToDouble((long)ParseRawLittleEndian64(ref buffer, ref state));
+            }
+            // ReadUnaligned uses processor architecture for endianness.
+            double result = Unsafe.ReadUnaligned<double>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
+            state.bufferPos += length;
+            return result;
+        }
+
+        /// <summary>
+        /// Parses a float value.
+        /// </summary>
+        public static float ParseFloat(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            const int length = sizeof(float);
+            if (!BitConverter.IsLittleEndian || state.bufferPos + length > state.bufferSize)
+            {
+                return ParseFloatSlow(ref buffer, ref state);
+            }
+            // ReadUnaligned uses processor architecture for endianness.
+            float result = Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
+            state.bufferPos += length;
+            return result;  
+        }
+
+        private static unsafe float ParseFloatSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            const int length = sizeof(float);
+            byte* stackBuffer = stackalloc byte[length];
+            Span<byte> tempSpan = new Span<byte>(stackBuffer, length);
+            for (int i = 0; i < length; i++)
+            {
+                tempSpan[i] = ReadRawByte(ref buffer, ref state);
+            }
+
+            // Content is little endian. Reverse if needed to match endianness of architecture.
+            if (!BitConverter.IsLittleEndian)
+            {
+                tempSpan.Reverse();
+            }
+            return Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(tempSpan));
+        }
+
+        /// <summary>
+        /// Reads a fixed size of bytes from the input.
+        /// </summary>
+        /// <exception cref="InvalidProtocolBufferException">
+        /// the end of the stream or the current limit was reached
+        /// </exception>
+        public static byte[] ReadRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
+        {
+            if (size < 0)
+            {
+                throw InvalidProtocolBufferException.NegativeSize();
+            }
+
+            if (size <= state.bufferSize - state.bufferPos)
+            {
+                // We have all the bytes we need already.
+                byte[] bytes = new byte[size];
+                buffer.Slice(state.bufferPos, size).CopyTo(bytes);
+                state.bufferPos += size;
+                return bytes;
+            }
+
+            return ReadRawBytesSlow(ref buffer, ref state, size);
+        }
+
+        private static byte[] ReadRawBytesSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
+        {
+            ValidateCurrentLimit(ref buffer, ref state, size);
+
+            if ((!state.segmentedBufferHelper.TotalLength.HasValue && size < buffer.Length) ||
+                IsDataAvailableInSource(ref state, size))
+            {
+                // Reading more bytes than are in the buffer, but not an excessive number
+                // of bytes.  We can safely allocate the resulting array ahead of time.
+
+                byte[] bytes = new byte[size];
+                ReadRawBytesIntoSpan(ref buffer, ref state, size, bytes);
+                return bytes;
+            }
+            else
+            {
+                // The size is very large.  For security reasons, we can't allocate the
+                // entire byte array yet.  The size comes directly from the input, so a
+                // maliciously-crafted message could provide a bogus very large size in
+                // order to trick the app into allocating a lot of memory.  We avoid this
+                // by allocating and reading only a small chunk at a time, so that the
+                // malicious message must actually *be* extremely large to cause
+                // problems.  Meanwhile, we limit the allowed size of a message elsewhere.
+
+                List<byte[]> chunks = new List<byte[]>();
+
+                int pos = state.bufferSize - state.bufferPos;
+                byte[] firstChunk = new byte[pos];
+                buffer.Slice(state.bufferPos, pos).CopyTo(firstChunk);
+                chunks.Add(firstChunk);
+                state.bufferPos = state.bufferSize;
+
+                // Read all the rest of the bytes we need.
+                int sizeLeft = size - pos;
+                while (sizeLeft > 0)
+                {
+                    state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
+                    byte[] chunk = new byte[Math.Min(sizeLeft, state.bufferSize)];
+
+                    buffer.Slice(0, chunk.Length)
+                        .CopyTo(chunk);
+                    state.bufferPos += chunk.Length;
+                    sizeLeft -= chunk.Length;
+                    chunks.Add(chunk);
+                }
+
+                // OK, got everything.  Now concatenate it all into one buffer.
+                byte[] bytes = new byte[size];
+                int newPos = 0;
+                foreach (byte[] chunk in chunks)
+                {
+                    Buffer.BlockCopy(chunk, 0, bytes, newPos, chunk.Length);
+                    newPos += chunk.Length;
+                }
+
+                // Done.
+                return bytes;
+            }
+        }
+
+        /// <summary>
+        /// Reads and discards <paramref name="size"/> bytes.
+        /// </summary>
+        /// <exception cref="InvalidProtocolBufferException">the end of the stream
+        /// or the current limit was reached</exception>
+        public static void SkipRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
+        {
+            if (size < 0)
+            {
+                throw InvalidProtocolBufferException.NegativeSize();
+            }
+
+            ValidateCurrentLimit(ref buffer, ref state, size);
+
+            if (size <= state.bufferSize - state.bufferPos)
+            {
+                // We have all the bytes we need already.
+                state.bufferPos += size;
+            }
+            else
+            {
+                // Skipping more bytes than are in the buffer.  First skip what we have.
+                int pos = state.bufferSize - state.bufferPos;
+                state.bufferPos = state.bufferSize;
+
+                // TODO: If our segmented buffer is backed by a Stream that is seekable, we could skip the bytes more efficiently
+                // by simply updating stream's Position property. This used to be supported in the past, but the support was dropped
+                // because it would make the segmentedBufferHelper more complex. Support can be reintroduced if needed.
+                state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
+
+                while (size - pos > state.bufferSize)
+                {
+                    pos += state.bufferSize;
+                    state.bufferPos = state.bufferSize;
+                    state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
+                }
+
+                state.bufferPos = size - pos;
+            }
+        }
+
+        /// <summary>
+        /// Reads a string field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static string ReadString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
+            return ParsingPrimitives.ReadRawString(ref buffer, ref state, length);
+        }
+
+        /// <summary>
+        /// Reads a bytes field value from the input.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ByteString ReadBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
+            return ByteString.AttachBytes(ParsingPrimitives.ReadRawBytes(ref buffer, ref state, length));
+        }
+
+        /// <summary>
+        /// Reads a UTF-8 string from the next "length" bytes.
+        /// </summary>
+        /// <exception cref="InvalidProtocolBufferException">
+        /// the end of the stream or the current limit was reached
+        /// </exception>
+        [SecuritySafeCritical]
+        public static string ReadRawString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
+        {
+            // No need to read any data for an empty string.
+            if (length == 0)
+            {
+                return string.Empty;
+            }
+
+            if (length < 0)
+            {
+                throw InvalidProtocolBufferException.NegativeSize();
+            }
+
+#if GOOGLE_PROTOBUF_SUPPORT_FAST_STRING
+            if (length <= state.bufferSize - state.bufferPos)
+            {
+                // Fast path: all bytes to decode appear in the same span.
+                ReadOnlySpan<byte> data = buffer.Slice(state.bufferPos, length);
+
+                string value;
+                unsafe
+                {
+                    fixed (byte* sourceBytes = &MemoryMarshal.GetReference(data))
+                    {
+                        value = WritingPrimitives.Utf8Encoding.GetString(sourceBytes, length);
+                    }
+                }
+
+                state.bufferPos += length;
+                return value;
+            }
+#endif
+
+            return ReadStringSlow(ref buffer, ref state, length);
+        }
+
+        /// <summary>
+        /// Reads a string assuming that it is spread across multiple spans in a <see cref="ReadOnlySequence{T}"/>.
+        /// </summary>
+        private static string ReadStringSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
+        {
+            ValidateCurrentLimit(ref buffer, ref state, length);
+
+#if GOOGLE_PROTOBUF_SUPPORT_FAST_STRING
+            if (IsDataAvailable(ref state, length))
+            {
+                // Read string data into a temporary buffer, either stackalloc'ed or from ArrayPool
+                // Once all data is read then call Encoding.GetString on buffer and return to pool if needed.
+
+                byte[] byteArray = null;
+                Span<byte> byteSpan = length <= StackallocThreshold ?
+                    stackalloc byte[length] :
+                    (byteArray = ArrayPool<byte>.Shared.Rent(length));
+
+                try
+                {
+                    unsafe
+                    {
+                        fixed (byte* pByteSpan = &MemoryMarshal.GetReference(byteSpan))
+                        {
+                            // Compiler doesn't like that a potentially stackalloc'd Span<byte> is being used
+                            // in a method with a "ref Span<byte> buffer" argument. If the stackalloc'd span was assigned
+                            // to the ref argument then bad things would happen. We'll never do that so it is ok.
+                            // Make compiler happy by passing a new span created from pointer.
+                            var tempSpan = new Span<byte>(pByteSpan, byteSpan.Length);
+                            ReadRawBytesIntoSpan(ref buffer, ref state, length, tempSpan);
+
+                            return WritingPrimitives.Utf8Encoding.GetString(pByteSpan, length);
+                        }
+                    }
+                }
+                finally
+                {
+                    if (byteArray != null)
+                    {
+                        ArrayPool<byte>.Shared.Return(byteArray);
+                    }
+                }
+            }
+#endif
+
+            // Slow path: Build a byte array first then copy it.
+            // This will be called when reading from a Stream because we don't know the length of the stream,
+            // or there is not enough data in the sequence. If there is not enough data then ReadRawBytes will
+            // throw an exception.
+            return WritingPrimitives.Utf8Encoding.GetString(ReadRawBytes(ref buffer, ref state, length), 0, length);
+        }
+
+        /// <summary>
+        /// Validates that the specified size doesn't exceed the current limit. If it does then remaining bytes
+        /// are skipped and an error is thrown.
+        /// </summary>
+        private static void ValidateCurrentLimit(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
+        {
+            if (state.totalBytesRetired + state.bufferPos + size > state.currentLimit)
+            {
+                // Read to the end of the stream (up to the current limit) anyway.
+                SkipRawBytes(ref buffer, ref state, state.currentLimit - state.totalBytesRetired - state.bufferPos);
+                // Then fail.
+                throw InvalidProtocolBufferException.TruncatedMessage();
+            }
+        }
+
+        [SecuritySafeCritical]
+        private static byte ReadRawByte(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            if (state.bufferPos == state.bufferSize)
+            {
+                state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
+            }
+            return buffer[state.bufferPos++];
+        }
+
+        /// <summary>
+        /// Reads a varint from the input one byte at a time, so that it does not
+        /// read any bytes after the end of the varint. If you simply wrapped the
+        /// stream in a CodedInputStream and used ReadRawVarint32(Stream)
+        /// then you would probably end up reading past the end of the varint since
+        /// CodedInputStream buffers its input.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static uint ReadRawVarint32(Stream input)
+        {
+            int result = 0;
+            int offset = 0;
+            for (; offset < 32; offset += 7)
+            {
+                int b = input.ReadByte();
+                if (b == -1)
+                {
+                    throw InvalidProtocolBufferException.TruncatedMessage();
+                }
+                result |= (b & 0x7f) << offset;
+                if ((b & 0x80) == 0)
+                {
+                    return (uint) result;
+                }
+            }
+            // Keep reading up to 64 bits.
+            for (; offset < 64; offset += 7)
+            {
+                int b = input.ReadByte();
+                if (b == -1)
+                {
+                    throw InvalidProtocolBufferException.TruncatedMessage();
+                }
+                if ((b & 0x80) == 0)
+                {
+                    return (uint) result;
+                }
+            }
+            throw InvalidProtocolBufferException.MalformedVarint();
+        }
+
+        /// <summary>
+        /// Decode a 32-bit value with ZigZag encoding.
+        /// </summary>
+        /// <remarks>
+        /// ZigZag encodes signed integers into values that can be efficiently
+        /// encoded with varint.  (Otherwise, negative values must be 
+        /// sign-extended to 32 bits to be varint encoded, thus always taking
+        /// 5 bytes on the wire.)
+        /// </remarks>
+        public static int DecodeZigZag32(uint n)
+        {
+            return (int)(n >> 1) ^ -(int)(n & 1);
+        }
+
+        /// <summary>
+        /// Decode a 64-bit value with ZigZag encoding.
+        /// </summary>
+        /// <remarks>
+        /// ZigZag encodes signed integers into values that can be efficiently
+        /// encoded with varint.  (Otherwise, negative values must be 
+        /// sign-extended to 64 bits to be varint encoded, thus always taking
+        /// 10 bytes on the wire.)
+        /// </remarks>
+        public static long DecodeZigZag64(ulong n)
+        {
+            return (long)(n >> 1) ^ -(long)(n & 1);
+        }
+
+        /// <summary>
+        /// Checks whether there is known data available of the specified size remaining to parse.
+        /// When parsing from a Stream this can return false because we have no knowledge of the amount
+        /// of data remaining in the stream until it is read.
+        /// </summary>
+        public static bool IsDataAvailable(ref ParserInternalState state, int size)
+        {
+            // Data fits in remaining buffer
+            if (size <= state.bufferSize - state.bufferPos)
+            {
+                return true;
+            }
+
+            return IsDataAvailableInSource(ref state, size);
+        }
+
+        /// <summary>
+        /// Checks whether there is known data available of the specified size remaining to parse
+        /// in the underlying data source.
+        /// When parsing from a Stream this will return false because we have no knowledge of the amount
+        /// of data remaining in the stream until it is read.
+        /// </summary>
+        private static bool IsDataAvailableInSource(ref ParserInternalState state, int size)
+        {
+            // Data fits in remaining source data.
+            // Note that this will never be true when reading from a stream as the total length is unknown.
+            return size <= state.segmentedBufferHelper.TotalLength - state.totalBytesRetired - state.bufferPos;
+        }
+
+        /// <summary>
+        /// Read raw bytes of the specified length into a span. The amount of data available and the current limit should
+        /// be checked before calling this method.
+        /// </summary>
+        private static void ReadRawBytesIntoSpan(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length, Span<byte> byteSpan)
+        {
+            int remainingByteLength = length;
+            while (remainingByteLength > 0)
+            {
+                if (state.bufferSize - state.bufferPos == 0)
+                {
+                    state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
+                }
+
+                ReadOnlySpan<byte> unreadSpan = buffer.Slice(state.bufferPos, Math.Min(remainingByteLength, state.bufferSize - state.bufferPos));
+                unreadSpan.CopyTo(byteSpan.Slice(length - remainingByteLength));
+
+                remainingByteLength -= unreadSpan.Length;
+                state.bufferPos += unreadSpan.Length;
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/ParsingPrimitivesMessages.cs b/Libs/Google.Protobuf/ParsingPrimitivesMessages.cs
new file mode 100644
index 0000000..b11caa1
--- /dev/null
+++ b/Libs/Google.Protobuf/ParsingPrimitivesMessages.cs
@@ -0,0 +1,292 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Security;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Reading and skipping messages / groups
+    /// </summary>
+    [SecuritySafeCritical]
+    internal static class ParsingPrimitivesMessages
+    {
+        private static readonly byte[] ZeroLengthMessageStreamData = new byte[] { 0 };
+
+        public static void SkipLastField(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            if (state.lastTag == 0)
+            {
+                throw new InvalidOperationException("SkipLastField cannot be called at the end of a stream");
+            }
+            switch (WireFormat.GetTagWireType(state.lastTag))
+            {
+                case WireFormat.WireType.StartGroup:
+                    SkipGroup(ref buffer, ref state, state.lastTag);
+                    break;
+                case WireFormat.WireType.EndGroup:
+                    throw new InvalidProtocolBufferException(
+                        "SkipLastField called on an end-group tag, indicating that the corresponding start-group was missing");
+                case WireFormat.WireType.Fixed32:
+                    ParsingPrimitives.ParseRawLittleEndian32(ref buffer, ref state);
+                    break;
+                case WireFormat.WireType.Fixed64:
+                    ParsingPrimitives.ParseRawLittleEndian64(ref buffer, ref state);
+                    break;
+                case WireFormat.WireType.LengthDelimited:
+                    var length = ParsingPrimitives.ParseLength(ref buffer, ref state);
+                    ParsingPrimitives.SkipRawBytes(ref buffer, ref state, length);
+                    break;
+                case WireFormat.WireType.Varint:
+                    ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Skip a group.
+        /// </summary>
+        public static void SkipGroup(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, uint startGroupTag)
+        {
+            // Note: Currently we expect this to be the way that groups are read. We could put the recursion
+            // depth changes into the ReadTag method instead, potentially...
+            state.recursionDepth++;
+            if (state.recursionDepth >= state.recursionLimit)
+            {
+                throw InvalidProtocolBufferException.RecursionLimitExceeded();
+            }
+            uint tag;
+            while (true)
+            {
+                tag = ParsingPrimitives.ParseTag(ref buffer, ref state);
+                if (tag == 0)
+                {
+                    throw InvalidProtocolBufferException.TruncatedMessage();
+                }
+                // Can't call SkipLastField for this case- that would throw.
+                if (WireFormat.GetTagWireType(tag) == WireFormat.WireType.EndGroup)
+                {
+                    break;
+                }
+                // This recursion will allow us to handle nested groups.
+                SkipLastField(ref buffer, ref state);
+            }
+            int startField = WireFormat.GetTagFieldNumber(startGroupTag);
+            int endField = WireFormat.GetTagFieldNumber(tag);
+            if (startField != endField)
+            {
+                throw new InvalidProtocolBufferException(
+                    $"Mismatched end-group tag. Started with field {startField}; ended with field {endField}");
+            }
+            state.recursionDepth--;
+        }
+
+        public static void ReadMessage(ref ParseContext ctx, IMessage message)
+        {
+            int length = ParsingPrimitives.ParseLength(ref ctx.buffer, ref ctx.state);
+            if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
+            {
+                throw InvalidProtocolBufferException.RecursionLimitExceeded();
+            }
+            int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, length);
+            ++ctx.state.recursionDepth;
+
+            ReadRawMessage(ref ctx, message);
+
+            CheckReadEndOfStreamTag(ref ctx.state);
+            // Check that we've read exactly as much data as expected.
+            if (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
+            {
+                throw InvalidProtocolBufferException.TruncatedMessage();
+            }
+            --ctx.state.recursionDepth;
+            SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
+        }
+
+        public static KeyValuePair<TKey, TValue> ReadMapEntry<TKey, TValue>(ref ParseContext ctx, MapField<TKey, TValue>.Codec codec)
+        {
+            int length = ParsingPrimitives.ParseLength(ref ctx.buffer, ref ctx.state);
+            if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
+            {
+                throw InvalidProtocolBufferException.RecursionLimitExceeded();
+            }
+            int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, length);
+            ++ctx.state.recursionDepth;
+
+            TKey key = codec.KeyCodec.DefaultValue;
+            TValue value = codec.ValueCodec.DefaultValue;
+
+            uint tag;
+            while ((tag = ctx.ReadTag()) != 0)
+            {
+                if (tag == codec.KeyCodec.Tag)
+                {
+                    key = codec.KeyCodec.Read(ref ctx);
+                }
+                else if (tag == codec.ValueCodec.Tag)
+                {
+                    value = codec.ValueCodec.Read(ref ctx);
+                }
+                else
+                {
+                    SkipLastField(ref ctx.buffer, ref ctx.state);
+                }
+            }
+
+            // Corner case: a map entry with a key but no value, where the value type is a message.
+            // Read it as if we'd seen input with no data (i.e. create a "default" message).
+            if (value == null)
+            {
+                if (ctx.state.CodedInputStream != null)
+                {
+                    // the decoded message might not support parsing from ParseContext, so
+                    // we need to allow fallback to the legacy MergeFrom(CodedInputStream) parsing.
+                    value = codec.ValueCodec.Read(new CodedInputStream(ZeroLengthMessageStreamData));
+                }
+                else
+                {
+                    ParseContext.Initialize(new ReadOnlySequence<byte>(ZeroLengthMessageStreamData), out ParseContext zeroLengthCtx);
+                    value = codec.ValueCodec.Read(ref zeroLengthCtx);
+                }
+            }
+
+            CheckReadEndOfStreamTag(ref ctx.state);
+            // Check that we've read exactly as much data as expected.
+            if (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
+            {
+                throw InvalidProtocolBufferException.TruncatedMessage();
+            }
+            --ctx.state.recursionDepth;
+            SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
+
+            return new KeyValuePair<TKey, TValue>(key, value);
+        }
+
+        public static void ReadGroup(ref ParseContext ctx, IMessage message)
+        {
+            if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
+            {
+                throw InvalidProtocolBufferException.RecursionLimitExceeded();
+            }
+            ++ctx.state.recursionDepth;
+            
+            uint tag = ctx.state.lastTag;
+            int fieldNumber = WireFormat.GetTagFieldNumber(tag);
+            ReadRawMessage(ref ctx, message);
+            CheckLastTagWas(ref ctx.state, WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup));
+
+            --ctx.state.recursionDepth;
+        }
+
+        public static void ReadGroup(ref ParseContext ctx, int fieldNumber, UnknownFieldSet set)
+        {
+            if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
+            {
+                throw InvalidProtocolBufferException.RecursionLimitExceeded();
+            }
+            ++ctx.state.recursionDepth;
+
+            set.MergeGroupFrom(ref ctx);
+            CheckLastTagWas(ref ctx.state, WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup));
+
+            --ctx.state.recursionDepth;
+        }
+
+        public static void ReadRawMessage(ref ParseContext ctx, IMessage message)
+        {
+            if (message is IBufferMessage bufferMessage)
+            {
+                bufferMessage.InternalMergeFrom(ref ctx);   
+            }
+            else
+            {
+                // If we reached here, it means we've ran into a nested message with older generated code
+                // which doesn't provide the InternalMergeFrom method that takes a ParseContext.
+                // With a slight performance overhead, we can still parse this message just fine,
+                // but we need to find the original CodedInputStream instance that initiated this
+                // parsing process and make sure its internal state is up to date.
+                // Note that this performance overhead is not very high (basically copying contents of a struct)
+                // and it will only be incurred in case the application mixes older and newer generated code.
+                // Regenerating the code from .proto files will remove this overhead because it will
+                // generate the InternalMergeFrom method we need.
+
+                if (ctx.state.CodedInputStream == null)
+                {
+                    // This can only happen when the parsing started without providing a CodedInputStream instance
+                    // (e.g. ParseContext was created directly from a ReadOnlySequence).
+                    // That also means that one of the new parsing APIs was used at the top level
+                    // and in such case it is reasonable to require that all the nested message provide
+                    // up-to-date generated code with ParseContext support (and fail otherwise).
+                    throw new InvalidProtocolBufferException($"Message {message.GetType().Name} doesn't provide the generated method that enables ParseContext-based parsing. You might need to regenerate the generated protobuf code.");
+                }
+
+                ctx.CopyStateTo(ctx.state.CodedInputStream);
+                try
+                {
+                    // fallback parse using the CodedInputStream that started current parsing tree
+                    message.MergeFrom(ctx.state.CodedInputStream);
+                }
+                finally
+                {
+                    ctx.LoadStateFrom(ctx.state.CodedInputStream);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Verifies that the last call to ReadTag() returned tag 0 - in other words,
+        /// we've reached the end of the stream when we expected to.
+        /// </summary>
+        /// <exception cref="InvalidProtocolBufferException">The 
+        /// tag read was not the one specified</exception>
+        public static void CheckReadEndOfStreamTag(ref ParserInternalState state)
+        {
+            if (state.lastTag != 0)
+            {
+                throw InvalidProtocolBufferException.MoreDataAvailable();
+            }
+        }
+
+        private static void CheckLastTagWas(ref ParserInternalState state, uint expectedTag)
+        {
+            if (state.lastTag != expectedTag) {
+               throw InvalidProtocolBufferException.InvalidEndTag();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/ParsingPrimitivesWrappers.cs b/Libs/Google.Protobuf/ParsingPrimitivesWrappers.cs
new file mode 100644
index 0000000..01e657f
--- /dev/null
+++ b/Libs/Google.Protobuf/ParsingPrimitivesWrappers.cs
@@ -0,0 +1,355 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Fast parsing primitives for wrapper types
+    /// </summary>
+    [SecuritySafeCritical]
+    internal static class ParsingPrimitivesWrappers
+    {
+        internal static float? ReadFloatWrapperLittleEndian(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            // length:1 + tag:1 + value:4 = 6 bytes
+            if (state.bufferPos + 6 <= state.bufferSize)
+            {
+                // The entire wrapper message is already contained in `buffer`.
+                int length = buffer[state.bufferPos];
+                if (length == 0)
+                {
+                    state.bufferPos++;
+                    return 0F;
+                }
+                // tag:1 + value:4 = length of 5 bytes
+                // field=1, type=32-bit = tag of 13
+                if (length != 5 || buffer[state.bufferPos + 1] != 13)
+                {
+                    return ReadFloatWrapperSlow(ref buffer, ref state);
+                }
+                state.bufferPos += 2;
+                return ParsingPrimitives.ParseFloat(ref buffer, ref state);
+            }
+            else
+            {
+                return ReadFloatWrapperSlow(ref buffer, ref state);
+            }
+        }
+
+        internal static float? ReadFloatWrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
+            if (length == 0)
+            {
+                return 0F;
+            }
+            int finalBufferPos = state.totalBytesRetired + state.bufferPos + length;
+            float result = 0F;
+            do
+            {
+                // field=1, type=32-bit = tag of 13
+                if (ParsingPrimitives.ParseTag(ref buffer, ref state) == 13)
+                {
+                    result = ParsingPrimitives.ParseFloat(ref buffer, ref state);
+                }
+                else
+                {
+                    ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
+                }
+            }
+            while (state.totalBytesRetired + state.bufferPos < finalBufferPos);
+            return result;
+        }
+
+        internal static double? ReadDoubleWrapperLittleEndian(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            // length:1 + tag:1 + value:8 = 10 bytes
+            if (state.bufferPos + 10 <= state.bufferSize)
+            {
+                // The entire wrapper message is already contained in `buffer`.
+                int length = buffer[state.bufferPos];
+                if (length == 0)
+                {
+                    state.bufferPos++;
+                    return 0D;
+                }
+                // tag:1 + value:8 = length of 9 bytes
+                // field=1, type=64-bit = tag of 9
+                if (length != 9 || buffer[state.bufferPos + 1] != 9)
+                {
+                    return ReadDoubleWrapperSlow(ref buffer, ref state);
+                }
+                state.bufferPos += 2;
+                return ParsingPrimitives.ParseDouble(ref buffer, ref state);
+            }
+            else
+            {
+                return ReadDoubleWrapperSlow(ref buffer, ref state);
+            }
+        }
+
+        internal static double? ReadDoubleWrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
+            if (length == 0)
+            {
+                return 0D;
+            }
+            int finalBufferPos = state.totalBytesRetired + state.bufferPos + length;
+            double result = 0D;
+            do
+            {
+                // field=1, type=64-bit = tag of 9
+                if (ParsingPrimitives.ParseTag(ref buffer, ref state) == 9)
+                {
+                    result = ParsingPrimitives.ParseDouble(ref buffer, ref state);
+                }
+                else
+                {
+                    ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
+                }
+            }
+            while (state.totalBytesRetired + state.bufferPos < finalBufferPos);
+            return result;
+        }
+
+        internal static bool? ReadBoolWrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            return ReadUInt64Wrapper(ref buffer, ref state) != 0;
+        }
+
+        internal static uint? ReadUInt32Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            // field=1, type=varint = tag of 8
+            const int expectedTag = 8;
+            // length:1 + tag:1 + value:10(varint64-max) = 12 bytes
+            // Value can be 64 bits for negative integers
+            if (state.bufferPos + 12 <= state.bufferSize)
+            {
+                // The entire wrapper message is already contained in `buffer`.
+                int pos0 = state.bufferPos;
+                int length = buffer[state.bufferPos++];
+                if (length == 0)
+                {
+                    return 0;
+                }
+                // Length will always fit in a single byte.
+                if (length >= 128)
+                {
+                    state.bufferPos = pos0;
+                    return ReadUInt32WrapperSlow(ref buffer, ref state);
+                }
+                int finalBufferPos = state.bufferPos + length;
+                if (buffer[state.bufferPos++] != expectedTag)
+                {
+                    state.bufferPos = pos0;
+                    return ReadUInt32WrapperSlow(ref buffer, ref state);
+                }
+                var result = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+                // Verify this message only contained a single field.
+                if (state.bufferPos != finalBufferPos)
+                {
+                    state.bufferPos = pos0;
+                    return ReadUInt32WrapperSlow(ref buffer, ref state);
+                }
+                return result;
+            }
+            else
+            {
+                return ReadUInt32WrapperSlow(ref buffer, ref state);
+            }
+        }
+
+        internal static uint? ReadUInt32WrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
+            if (length == 0)
+            {
+                return 0;
+            }
+            int finalBufferPos = state.totalBytesRetired + state.bufferPos + length;
+            uint result = 0;
+            do
+            {
+                // field=1, type=varint = tag of 8
+                if (ParsingPrimitives.ParseTag(ref buffer, ref state) == 8)
+                {
+                    result = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
+                }
+                else
+                {
+                    ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
+                }
+            }
+            while (state.totalBytesRetired + state.bufferPos < finalBufferPos);
+            return result;
+        }
+
+        internal static int? ReadInt32Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            return (int?)ReadUInt32Wrapper(ref buffer, ref state);
+        }
+
+        internal static ulong? ReadUInt64Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            // field=1, type=varint = tag of 8
+            const int expectedTag = 8;
+            // length:1 + tag:1 + value:10(varint64-max) = 12 bytes
+            if (state.bufferPos + 12 <= state.bufferSize)
+            {
+                // The entire wrapper message is already contained in `buffer`.
+                int pos0 = state.bufferPos;
+                int length = buffer[state.bufferPos++];
+                if (length == 0)
+                {
+                    return 0L;
+                }
+                // Length will always fit in a single byte.
+                if (length >= 128)
+                {
+                    state.bufferPos = pos0;
+                    return ReadUInt64WrapperSlow(ref buffer, ref state);
+                }
+                int finalBufferPos = state.bufferPos + length;
+                if (buffer[state.bufferPos++] != expectedTag)
+                {
+                    state.bufferPos = pos0;
+                    return ReadUInt64WrapperSlow(ref buffer, ref state);
+                }
+                var result = ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
+                // Verify this message only contained a single field.
+                if (state.bufferPos != finalBufferPos)
+                {
+                    state.bufferPos = pos0;
+                    return ReadUInt64WrapperSlow(ref buffer, ref state);
+                }
+                return result;
+            }
+            else
+            {
+                return ReadUInt64WrapperSlow(ref buffer, ref state);
+            }
+        }
+
+        internal static ulong? ReadUInt64WrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            // field=1, type=varint = tag of 8
+            const int expectedTag = 8;
+            int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
+            if (length == 0)
+            {
+                return 0L;
+            }
+            int finalBufferPos = state.totalBytesRetired + state.bufferPos + length;
+            ulong result = 0L;
+            do
+            {
+                if (ParsingPrimitives.ParseTag(ref buffer, ref state) == expectedTag)
+                {
+                    result = ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
+                }
+                else
+                {
+                    ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
+                }
+            }
+            while (state.totalBytesRetired + state.bufferPos < finalBufferPos);
+            return result;
+        }
+
+        internal static long? ReadInt64Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            return (long?)ReadUInt64Wrapper(ref buffer, ref state);
+        }
+
+        internal static float? ReadFloatWrapperLittleEndian(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadFloatWrapperLittleEndian(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static float? ReadFloatWrapperSlow(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadFloatWrapperSlow(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static double? ReadDoubleWrapperLittleEndian(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadDoubleWrapperLittleEndian(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static double? ReadDoubleWrapperSlow(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadDoubleWrapperSlow(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static bool? ReadBoolWrapper(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadBoolWrapper(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static uint? ReadUInt32Wrapper(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadUInt32Wrapper(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static int? ReadInt32Wrapper(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadInt32Wrapper(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static ulong? ReadUInt64Wrapper(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadUInt64Wrapper(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static ulong? ReadUInt64WrapperSlow(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadUInt64WrapperSlow(ref ctx.buffer, ref ctx.state);
+        }
+
+        internal static long? ReadInt64Wrapper(ref ParseContext ctx)
+        {
+            return ParsingPrimitivesWrappers.ReadInt64Wrapper(ref ctx.buffer, ref ctx.state);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Properties/AssemblyInfo.cs b/Libs/Google.Protobuf/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..4328e2e
--- /dev/null
+++ b/Libs/Google.Protobuf/Properties/AssemblyInfo.cs
@@ -0,0 +1,56 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Runtime.CompilerServices;
+using System.Security;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+#if !NCRUNCH
+[assembly: AllowPartiallyTrustedCallers]
+#endif
+
+[assembly: InternalsVisibleTo("Google.Protobuf.Test, PublicKey=" +
+    "002400000480000094000000060200000024000052534131000400000100010025800fbcfc63a1" +
+    "7c66b303aae80b03a6beaa176bb6bef883be436f2a1579edd80ce23edf151a1f4ced97af83abcd" +
+    "981207041fd5b2da3b498346fcfcd94910d52f25537c4a43ce3fbe17dc7d43e6cbdb4d8f1242dc" +
+    "b6bd9b5906be74da8daa7d7280f97130f318a16c07baf118839b156299a48522f9fae2371c9665" +
+    "c5ae9cb6")]
+
+[assembly: InternalsVisibleTo("Google.Protobuf.Benchmarks, PublicKey=" +
+    "002400000480000094000000060200000024000052534131000400000100010025800fbcfc63a1" +
+    "7c66b303aae80b03a6beaa176bb6bef883be436f2a1579edd80ce23edf151a1f4ced97af83abcd" +
+    "981207041fd5b2da3b498346fcfcd94910d52f25537c4a43ce3fbe17dc7d43e6cbdb4d8f1242dc" +
+    "b6bd9b5906be74da8daa7d7280f97130f318a16c07baf118839b156299a48522f9fae2371c9665" +
+    "c5ae9cb6")]
diff --git a/Libs/Google.Protobuf/ProtoPreconditions.cs b/Libs/Google.Protobuf/ProtoPreconditions.cs
new file mode 100644
index 0000000..fb87d49
--- /dev/null
+++ b/Libs/Google.Protobuf/ProtoPreconditions.cs
@@ -0,0 +1,79 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Helper methods for throwing exceptions when preconditions are not met.
+    /// </summary>
+    /// <remarks>
+    /// This class is used internally and by generated code; it is not particularly
+    /// expected to be used from application code, although nothing prevents it
+    /// from being used that way.
+    /// </remarks>
+    public static class ProtoPreconditions
+    {
+        /// <summary>
+        /// Throws an ArgumentNullException if the given value is null, otherwise
+        /// return the value to the caller.
+        /// </summary>
+        public static T CheckNotNull<T>(T value, string name) where T : class
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(name);
+            }
+            return value;
+        }
+
+        /// <summary>
+        /// Throws an ArgumentNullException if the given value is null, otherwise
+        /// return the value to the caller.
+        /// </summary>
+        /// <remarks>
+        /// This is equivalent to <see cref="CheckNotNull{T}(T, string)"/> but without the type parameter
+        /// constraint. In most cases, the constraint is useful to prevent you from calling CheckNotNull
+        /// with a value type - but it gets in the way if either you want to use it with a nullable
+        /// value type, or you want to use it with an unconstrained type parameter.
+        /// </remarks>
+        internal static T CheckNotNullUnconstrained<T>(T value, string name)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(name);
+            }
+            return value;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/CustomOptions.cs b/Libs/Google.Protobuf/Reflection/CustomOptions.cs
new file mode 100644
index 0000000..65c7958
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/CustomOptions.cs
@@ -0,0 +1,304 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2017 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Container for a set of custom options specified within a message, field etc.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This type is publicly immutable, but internally mutable. It is only populated
+    /// by the descriptor parsing code - by the time any user code is able to see an instance,
+    /// it will be fully initialized.
+    /// </para>
+    /// <para>
+    /// If an option is requested using the incorrect method, an answer may still be returned: all
+    /// of the numeric types are represented internally using 64-bit integers, for example. It is up to
+    /// the caller to ensure that they make the appropriate method call for the option they're interested in.
+    /// Note that enum options are simply stored as integers, so the value should be fetched using
+    /// <see cref="TryGetInt32(int, out int)"/> and then cast appropriately.
+    /// </para>
+    /// <para>
+    /// Repeated options are currently not supported. Asking for a single value of an option
+    /// which was actually repeated will return the last value, except for message types where
+    /// all the set values are merged together.
+    /// </para>
+    /// </remarks>
+    public sealed class CustomOptions
+    {
+        private static readonly object[] EmptyParameters = new object[0];
+        private readonly IDictionary<int, IExtensionValue> values;
+
+        internal CustomOptions(IDictionary<int, IExtensionValue> values)
+        {
+            this.values = values;
+        }
+
+        /// <summary>
+        /// Retrieves a Boolean value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetBool(int field, out bool value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a signed 32-bit integer value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetInt32(int field, out int value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a signed 64-bit integer value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetInt64(int field, out long value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves an unsigned 32-bit integer value for the specified option field,
+        /// assuming a fixed-length representation.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetFixed32(int field, out uint value) => TryGetUInt32(field, out value);
+
+        /// <summary>
+        /// Retrieves an unsigned 64-bit integer value for the specified option field,
+        /// assuming a fixed-length representation.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetFixed64(int field, out ulong value) => TryGetUInt64(field, out value);
+
+        /// <summary>
+        /// Retrieves a signed 32-bit integer value for the specified option field,
+        /// assuming a fixed-length representation.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetSFixed32(int field, out int value) => TryGetInt32(field, out value);
+
+        /// <summary>
+        /// Retrieves a signed 64-bit integer value for the specified option field,
+        /// assuming a fixed-length representation.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetSFixed64(int field, out long value) => TryGetInt64(field, out value);
+
+        /// <summary>
+        /// Retrieves a signed 32-bit integer value for the specified option field,
+        /// assuming a zigzag encoding.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetSInt32(int field, out int value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a signed 64-bit integer value for the specified option field,
+        /// assuming a zigzag encoding.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetSInt64(int field, out long value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves an unsigned 32-bit integer value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetUInt32(int field, out uint value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves an unsigned 64-bit integer value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetUInt64(int field, out ulong value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a 32-bit floating point value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetFloat(int field, out float value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a 64-bit floating point value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetDouble(int field, out double value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a string value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetString(int field, out string value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a bytes value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetBytes(int field, out ByteString value) => TryGetPrimitiveValue(field, out value);
+
+        /// <summary>
+        /// Retrieves a message value for the specified option field.
+        /// </summary>
+        /// <param name="field">The field to fetch the value for.</param>
+        /// <param name="value">The output variable to populate.</param>
+        /// <returns><c>true</c> if a suitable value for the field was found; <c>false</c> otherwise.</returns>
+        public bool TryGetMessage<T>(int field, out T value) where T : class, IMessage, new()
+        {
+            if (values == null)
+            {
+                value = default(T);
+                return false;
+            }
+
+            IExtensionValue extensionValue;
+            if (values.TryGetValue(field, out extensionValue))
+            {
+                if (extensionValue is ExtensionValue<T>)
+                {
+                    ExtensionValue<T> single = extensionValue as ExtensionValue<T>;
+                    ByteString bytes = single.GetValue().ToByteString();
+                    value = new T();
+                    value.MergeFrom(bytes);
+                    return true;
+                }
+                else if (extensionValue is RepeatedExtensionValue<T>)
+                {
+                    RepeatedExtensionValue<T> repeated = extensionValue as RepeatedExtensionValue<T>;
+                    value = repeated.GetValue()
+                        .Select(v => v.ToByteString())
+                        .Aggregate(new T(), (t, b) =>
+                        {
+                            t.MergeFrom(b);
+                            return t;
+                        });
+                    return true;
+                }
+            }
+
+            value = null;
+            return false;
+        }
+
+        private bool TryGetPrimitiveValue<T>(int field, out T value)
+        {
+            if (values == null)
+            {
+                value = default(T);
+                return false;
+            }
+
+            IExtensionValue extensionValue;
+            if (values.TryGetValue(field, out extensionValue))
+            {
+                if (extensionValue is ExtensionValue<T>)
+                {
+                    ExtensionValue<T> single = extensionValue as ExtensionValue<T>;
+                    value = single.GetValue();
+                    return true;
+                }
+                else if (extensionValue is RepeatedExtensionValue<T>)
+                {
+                    RepeatedExtensionValue<T> repeated = extensionValue as RepeatedExtensionValue<T>;
+                    if (repeated.GetValue().Count != 0)
+                    {
+                        RepeatedField<T> repeatedField = repeated.GetValue();
+                        value = repeatedField[repeatedField.Count - 1];
+                        return true;
+                    }
+                }
+                else // and here we find explicit enum handling since T : Enum ! x is ExtensionValue<Enum>
+                {
+                    var type = extensionValue.GetType();
+                    if (type.GetGenericTypeDefinition() == typeof(ExtensionValue<>))
+                    {
+                        var typeInfo = type.GetTypeInfo();
+                        var typeArgs = typeInfo.GenericTypeArguments;
+                        if (typeArgs.Length == 1 && typeArgs[0].GetTypeInfo().IsEnum)
+                        {
+                            value = (T)typeInfo.GetDeclaredMethod(nameof(ExtensionValue<T>.GetValue)).Invoke(extensionValue, EmptyParameters);
+                            return true;
+                        }
+                    }
+                    else if (type.GetGenericTypeDefinition() == typeof(RepeatedExtensionValue<>))
+                    {
+                        var typeInfo = type.GetTypeInfo();
+                        var typeArgs = typeInfo.GenericTypeArguments;
+                        if (typeArgs.Length == 1 && typeArgs[0].GetTypeInfo().IsEnum)
+                        {
+                            var values = (IList)typeInfo.GetDeclaredMethod(nameof(RepeatedExtensionValue<T>.GetValue)).Invoke(extensionValue, EmptyParameters);
+                            if (values.Count != 0)
+                            {
+                                value = (T)values[values.Count - 1];
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+
+            value = default(T);
+            return false;
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/Descriptor.cs b/Libs/Google.Protobuf/Reflection/Descriptor.cs
new file mode 100644
index 0000000..3afa27f
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/Descriptor.cs
@@ -0,0 +1,10296 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/descriptor.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.Reflection {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/descriptor.proto</summary>
+  public static partial class DescriptorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/descriptor.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static DescriptorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90bxIPZ29vZ2xlLnBy",
+            "b3RvYnVmIkcKEUZpbGVEZXNjcmlwdG9yU2V0EjIKBGZpbGUYASADKAsyJC5n",
+            "b29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90byLbAwoTRmlsZURl",
+            "c2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEg8KB3BhY2thZ2UYAiABKAkS",
+            "EgoKZGVwZW5kZW5jeRgDIAMoCRIZChFwdWJsaWNfZGVwZW5kZW5jeRgKIAMo",
+            "BRIXCg93ZWFrX2RlcGVuZGVuY3kYCyADKAUSNgoMbWVzc2FnZV90eXBlGAQg",
+            "AygLMiAuZ29vZ2xlLnByb3RvYnVmLkRlc2NyaXB0b3JQcm90bxI3CgllbnVt",
+            "X3R5cGUYBSADKAsyJC5nb29nbGUucHJvdG9idWYuRW51bURlc2NyaXB0b3JQ",
+            "cm90bxI4CgdzZXJ2aWNlGAYgAygLMicuZ29vZ2xlLnByb3RvYnVmLlNlcnZp",
+            "Y2VEZXNjcmlwdG9yUHJvdG8SOAoJZXh0ZW5zaW9uGAcgAygLMiUuZ29vZ2xl",
+            "LnByb3RvYnVmLkZpZWxkRGVzY3JpcHRvclByb3RvEi0KB29wdGlvbnMYCCAB",
+            "KAsyHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMSOQoQc291cmNlX2Nv",
+            "ZGVfaW5mbxgJIAEoCzIfLmdvb2dsZS5wcm90b2J1Zi5Tb3VyY2VDb2RlSW5m",
+            "bxIOCgZzeW50YXgYDCABKAkiqQUKD0Rlc2NyaXB0b3JQcm90bxIMCgRuYW1l",
+            "GAEgASgJEjQKBWZpZWxkGAIgAygLMiUuZ29vZ2xlLnByb3RvYnVmLkZpZWxk",
+            "RGVzY3JpcHRvclByb3RvEjgKCWV4dGVuc2lvbhgGIAMoCzIlLmdvb2dsZS5w",
+            "cm90b2J1Zi5GaWVsZERlc2NyaXB0b3JQcm90bxI1CgtuZXN0ZWRfdHlwZRgD",
+            "IAMoCzIgLmdvb2dsZS5wcm90b2J1Zi5EZXNjcmlwdG9yUHJvdG8SNwoJZW51",
+            "bV90eXBlGAQgAygLMiQuZ29vZ2xlLnByb3RvYnVmLkVudW1EZXNjcmlwdG9y",
+            "UHJvdG8SSAoPZXh0ZW5zaW9uX3JhbmdlGAUgAygLMi8uZ29vZ2xlLnByb3Rv",
+            "YnVmLkRlc2NyaXB0b3JQcm90by5FeHRlbnNpb25SYW5nZRI5CgpvbmVvZl9k",
+            "ZWNsGAggAygLMiUuZ29vZ2xlLnByb3RvYnVmLk9uZW9mRGVzY3JpcHRvclBy",
+            "b3RvEjAKB29wdGlvbnMYByABKAsyHy5nb29nbGUucHJvdG9idWYuTWVzc2Fn",
+            "ZU9wdGlvbnMSRgoOcmVzZXJ2ZWRfcmFuZ2UYCSADKAsyLi5nb29nbGUucHJv",
+            "dG9idWYuRGVzY3JpcHRvclByb3RvLlJlc2VydmVkUmFuZ2USFQoNcmVzZXJ2",
+            "ZWRfbmFtZRgKIAMoCRplCg5FeHRlbnNpb25SYW5nZRINCgVzdGFydBgBIAEo",
+            "BRILCgNlbmQYAiABKAUSNwoHb3B0aW9ucxgDIAEoCzImLmdvb2dsZS5wcm90",
+            "b2J1Zi5FeHRlbnNpb25SYW5nZU9wdGlvbnMaKwoNUmVzZXJ2ZWRSYW5nZRIN",
+            "CgVzdGFydBgBIAEoBRILCgNlbmQYAiABKAUiZwoVRXh0ZW5zaW9uUmFuZ2VP",
+            "cHRpb25zEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcHIAMoCzIkLmdvb2ds",
+            "ZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uKgkI6AcQgICAgAIi1QUK",
+            "FEZpZWxkRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSDgoGbnVtYmVy",
+            "GAMgASgFEjoKBWxhYmVsGAQgASgOMisuZ29vZ2xlLnByb3RvYnVmLkZpZWxk",
+            "RGVzY3JpcHRvclByb3RvLkxhYmVsEjgKBHR5cGUYBSABKA4yKi5nb29nbGUu",
+            "cHJvdG9idWYuRmllbGREZXNjcmlwdG9yUHJvdG8uVHlwZRIRCgl0eXBlX25h",
+            "bWUYBiABKAkSEAoIZXh0ZW5kZWUYAiABKAkSFQoNZGVmYXVsdF92YWx1ZRgH",
+            "IAEoCRITCgtvbmVvZl9pbmRleBgJIAEoBRIRCglqc29uX25hbWUYCiABKAkS",
+            "LgoHb3B0aW9ucxgIIAEoCzIdLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlv",
+            "bnMSFwoPcHJvdG8zX29wdGlvbmFsGBEgASgIIrYCCgRUeXBlEg8KC1RZUEVf",
+            "RE9VQkxFEAESDgoKVFlQRV9GTE9BVBACEg4KClRZUEVfSU5UNjQQAxIPCgtU",
+            "WVBFX1VJTlQ2NBAEEg4KClRZUEVfSU5UMzIQBRIQCgxUWVBFX0ZJWEVENjQQ",
+            "BhIQCgxUWVBFX0ZJWEVEMzIQBxINCglUWVBFX0JPT0wQCBIPCgtUWVBFX1NU",
+            "UklORxAJEg4KClRZUEVfR1JPVVAQChIQCgxUWVBFX01FU1NBR0UQCxIOCgpU",
+            "WVBFX0JZVEVTEAwSDwoLVFlQRV9VSU5UMzIQDRINCglUWVBFX0VOVU0QDhIR",
+            "Cg1UWVBFX1NGSVhFRDMyEA8SEQoNVFlQRV9TRklYRUQ2NBAQEg8KC1RZUEVf",
+            "U0lOVDMyEBESDwoLVFlQRV9TSU5UNjQQEiJDCgVMYWJlbBISCg5MQUJFTF9P",
+            "UFRJT05BTBABEhIKDkxBQkVMX1JFUVVJUkVEEAISEgoOTEFCRUxfUkVQRUFU",
+            "RUQQAyJUChRPbmVvZkRlc2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEi4K",
+            "B29wdGlvbnMYAiABKAsyHS5nb29nbGUucHJvdG9idWYuT25lb2ZPcHRpb25z",
+            "IqQCChNFbnVtRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSOAoFdmFs",
+            "dWUYAiADKAsyKS5nb29nbGUucHJvdG9idWYuRW51bVZhbHVlRGVzY3JpcHRv",
+            "clByb3RvEi0KB29wdGlvbnMYAyABKAsyHC5nb29nbGUucHJvdG9idWYuRW51",
+            "bU9wdGlvbnMSTgoOcmVzZXJ2ZWRfcmFuZ2UYBCADKAsyNi5nb29nbGUucHJv",
+            "dG9idWYuRW51bURlc2NyaXB0b3JQcm90by5FbnVtUmVzZXJ2ZWRSYW5nZRIV",
+            "Cg1yZXNlcnZlZF9uYW1lGAUgAygJGi8KEUVudW1SZXNlcnZlZFJhbmdlEg0K",
+            "BXN0YXJ0GAEgASgFEgsKA2VuZBgCIAEoBSJsChhFbnVtVmFsdWVEZXNjcmlw",
+            "dG9yUHJvdG8SDAoEbmFtZRgBIAEoCRIOCgZudW1iZXIYAiABKAUSMgoHb3B0",
+            "aW9ucxgDIAEoCzIhLmdvb2dsZS5wcm90b2J1Zi5FbnVtVmFsdWVPcHRpb25z",
+            "IpABChZTZXJ2aWNlRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSNgoG",
+            "bWV0aG9kGAIgAygLMiYuZ29vZ2xlLnByb3RvYnVmLk1ldGhvZERlc2NyaXB0",
+            "b3JQcm90bxIwCgdvcHRpb25zGAMgASgLMh8uZ29vZ2xlLnByb3RvYnVmLlNl",
+            "cnZpY2VPcHRpb25zIsEBChVNZXRob2REZXNjcmlwdG9yUHJvdG8SDAoEbmFt",
+            "ZRgBIAEoCRISCgppbnB1dF90eXBlGAIgASgJEhMKC291dHB1dF90eXBlGAMg",
+            "ASgJEi8KB29wdGlvbnMYBCABKAsyHi5nb29nbGUucHJvdG9idWYuTWV0aG9k",
+            "T3B0aW9ucxIfChBjbGllbnRfc3RyZWFtaW5nGAUgASgIOgVmYWxzZRIfChBz",
+            "ZXJ2ZXJfc3RyZWFtaW5nGAYgASgIOgVmYWxzZSKlBgoLRmlsZU9wdGlvbnMS",
+            "FAoMamF2YV9wYWNrYWdlGAEgASgJEhwKFGphdmFfb3V0ZXJfY2xhc3NuYW1l",
+            "GAggASgJEiIKE2phdmFfbXVsdGlwbGVfZmlsZXMYCiABKAg6BWZhbHNlEikK",
+            "HWphdmFfZ2VuZXJhdGVfZXF1YWxzX2FuZF9oYXNoGBQgASgIQgIYARIlChZq",
+            "YXZhX3N0cmluZ19jaGVja191dGY4GBsgASgIOgVmYWxzZRJGCgxvcHRpbWl6",
+            "ZV9mb3IYCSABKA4yKS5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMuT3B0",
+            "aW1pemVNb2RlOgVTUEVFRBISCgpnb19wYWNrYWdlGAsgASgJEiIKE2NjX2dl",
+            "bmVyaWNfc2VydmljZXMYECABKAg6BWZhbHNlEiQKFWphdmFfZ2VuZXJpY19z",
+            "ZXJ2aWNlcxgRIAEoCDoFZmFsc2USIgoTcHlfZ2VuZXJpY19zZXJ2aWNlcxgS",
+            "IAEoCDoFZmFsc2USIwoUcGhwX2dlbmVyaWNfc2VydmljZXMYKiABKAg6BWZh",
+            "bHNlEhkKCmRlcHJlY2F0ZWQYFyABKAg6BWZhbHNlEh4KEGNjX2VuYWJsZV9h",
+            "cmVuYXMYHyABKAg6BHRydWUSGQoRb2JqY19jbGFzc19wcmVmaXgYJCABKAkS",
+            "GAoQY3NoYXJwX25hbWVzcGFjZRglIAEoCRIUCgxzd2lmdF9wcmVmaXgYJyAB",
+            "KAkSGAoQcGhwX2NsYXNzX3ByZWZpeBgoIAEoCRIVCg1waHBfbmFtZXNwYWNl",
+            "GCkgASgJEh4KFnBocF9tZXRhZGF0YV9uYW1lc3BhY2UYLCABKAkSFAoMcnVi",
+            "eV9wYWNrYWdlGC0gASgJEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcHIAMo",
+            "CzIkLmdvb2dsZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uIjoKDE9w",
+            "dGltaXplTW9kZRIJCgVTUEVFRBABEg0KCUNPREVfU0laRRACEhAKDExJVEVf",
+            "UlVOVElNRRADKgkI6AcQgICAgAJKBAgmECcihAIKDk1lc3NhZ2VPcHRpb25z",
+            "EiYKF21lc3NhZ2Vfc2V0X3dpcmVfZm9ybWF0GAEgASgIOgVmYWxzZRIuCh9u",
+            "b19zdGFuZGFyZF9kZXNjcmlwdG9yX2FjY2Vzc29yGAIgASgIOgVmYWxzZRIZ",
+            "CgpkZXByZWNhdGVkGAMgASgIOgVmYWxzZRIRCgltYXBfZW50cnkYByABKAgS",
+            "QwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3Rv",
+            "YnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAkoECAQQBUoECAUQ",
+            "BkoECAYQB0oECAgQCUoECAkQCiKeAwoMRmllbGRPcHRpb25zEjoKBWN0eXBl",
+            "GAEgASgOMiMuZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucy5DVHlwZToG",
+            "U1RSSU5HEg4KBnBhY2tlZBgCIAEoCBI/CgZqc3R5cGUYBiABKA4yJC5nb29n",
+            "bGUucHJvdG9idWYuRmllbGRPcHRpb25zLkpTVHlwZToJSlNfTk9STUFMEhMK",
+            "BGxhenkYBSABKAg6BWZhbHNlEhkKCmRlcHJlY2F0ZWQYAyABKAg6BWZhbHNl",
+            "EhMKBHdlYWsYCiABKAg6BWZhbHNlEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9u",
+            "GOcHIAMoCzIkLmdvb2dsZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9u",
+            "Ii8KBUNUeXBlEgoKBlNUUklORxAAEggKBENPUkQQARIQCgxTVFJJTkdfUElF",
+            "Q0UQAiI1CgZKU1R5cGUSDQoJSlNfTk9STUFMEAASDQoJSlNfU1RSSU5HEAES",
+            "DQoJSlNfTlVNQkVSEAIqCQjoBxCAgICAAkoECAQQBSJeCgxPbmVvZk9wdGlv",
+            "bnMSQwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnBy",
+            "b3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiKTAQoLRW51",
+            "bU9wdGlvbnMSEwoLYWxsb3dfYWxpYXMYAiABKAgSGQoKZGVwcmVjYXRlZBgD",
+            "IAEoCDoFZmFsc2USQwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQu",
+            "Z29vZ2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICA",
+            "AkoECAUQBiJ9ChBFbnVtVmFsdWVPcHRpb25zEhkKCmRlcHJlY2F0ZWQYASAB",
+            "KAg6BWZhbHNlEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcHIAMoCzIkLmdv",
+            "b2dsZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uKgkI6AcQgICAgAIi",
+            "ewoOU2VydmljZU9wdGlvbnMSGQoKZGVwcmVjYXRlZBghIAEoCDoFZmFsc2US",
+            "QwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3Rv",
+            "YnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiKtAgoNTWV0aG9k",
+            "T3B0aW9ucxIZCgpkZXByZWNhdGVkGCEgASgIOgVmYWxzZRJfChFpZGVtcG90",
+            "ZW5jeV9sZXZlbBgiIAEoDjIvLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRp",
+            "b25zLklkZW1wb3RlbmN5TGV2ZWw6E0lERU1QT1RFTkNZX1VOS05PV04SQwoU",
+            "dW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVm",
+            "LlVuaW50ZXJwcmV0ZWRPcHRpb24iUAoQSWRlbXBvdGVuY3lMZXZlbBIXChNJ",
+            "REVNUE9URU5DWV9VTktOT1dOEAASEwoPTk9fU0lERV9FRkZFQ1RTEAESDgoK",
+            "SURFTVBPVEVOVBACKgkI6AcQgICAgAIingIKE1VuaW50ZXJwcmV0ZWRPcHRp",
+            "b24SOwoEbmFtZRgCIAMoCzItLmdvb2dsZS5wcm90b2J1Zi5VbmludGVycHJl",
+            "dGVkT3B0aW9uLk5hbWVQYXJ0EhgKEGlkZW50aWZpZXJfdmFsdWUYAyABKAkS",
+            "GgoScG9zaXRpdmVfaW50X3ZhbHVlGAQgASgEEhoKEm5lZ2F0aXZlX2ludF92",
+            "YWx1ZRgFIAEoAxIUCgxkb3VibGVfdmFsdWUYBiABKAESFAoMc3RyaW5nX3Zh",
+            "bHVlGAcgASgMEhcKD2FnZ3JlZ2F0ZV92YWx1ZRgIIAEoCRozCghOYW1lUGFy",
+            "dBIRCgluYW1lX3BhcnQYASACKAkSFAoMaXNfZXh0ZW5zaW9uGAIgAigIItUB",
+            "Cg5Tb3VyY2VDb2RlSW5mbxI6Cghsb2NhdGlvbhgBIAMoCzIoLmdvb2dsZS5w",
+            "cm90b2J1Zi5Tb3VyY2VDb2RlSW5mby5Mb2NhdGlvbhqGAQoITG9jYXRpb24S",
+            "EAoEcGF0aBgBIAMoBUICEAESEAoEc3BhbhgCIAMoBUICEAESGAoQbGVhZGlu",
+            "Z19jb21tZW50cxgDIAEoCRIZChF0cmFpbGluZ19jb21tZW50cxgEIAEoCRIh",
+            "ChlsZWFkaW5nX2RldGFjaGVkX2NvbW1lbnRzGAYgAygJIqcBChFHZW5lcmF0",
+            "ZWRDb2RlSW5mbxJBCgphbm5vdGF0aW9uGAEgAygLMi0uZ29vZ2xlLnByb3Rv",
+            "YnVmLkdlbmVyYXRlZENvZGVJbmZvLkFubm90YXRpb24aTwoKQW5ub3RhdGlv",
+            "bhIQCgRwYXRoGAEgAygFQgIQARITCgtzb3VyY2VfZmlsZRgCIAEoCRINCgVi",
+            "ZWdpbhgDIAEoBRILCgNlbmQYBCABKAVCfgoTY29tLmdvb2dsZS5wcm90b2J1",
+            "ZkIQRGVzY3JpcHRvclByb3Rvc0gBWi1nb29nbGUuZ29sYW5nLm9yZy9wcm90",
+            "b2J1Zi90eXBlcy9kZXNjcmlwdG9ycGL4AQGiAgNHUEKqAhpHb29nbGUuUHJv",
+            "dG9idWYuUmVmbGVjdGlvbg=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.FileDescriptorSet), global::LC.Google.Protobuf.Reflection.FileDescriptorSet.Parser, new[]{ "File" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.FileDescriptorProto), global::LC.Google.Protobuf.Reflection.FileDescriptorProto.Parser, new[]{ "Name", "Package", "Dependency", "PublicDependency", "WeakDependency", "MessageType", "EnumType", "Service", "Extension", "Options", "SourceCodeInfo", "Syntax" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.DescriptorProto), global::LC.Google.Protobuf.Reflection.DescriptorProto.Parser, new[]{ "Name", "Field", "Extension", "NestedType", "EnumType", "ExtensionRange", "OneofDecl", "Options", "ReservedRange", "ReservedName" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ExtensionRange), global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ExtensionRange.Parser, new[]{ "Start", "End", "Options" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ReservedRange), global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ReservedRange.Parser, new[]{ "Start", "End" }, null, null, null, null)}),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.ExtensionRangeOptions), global::LC.Google.Protobuf.Reflection.ExtensionRangeOptions.Parser, new[]{ "UninterpretedOption" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.FieldDescriptorProto), global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Parser, new[]{ "Name", "Number", "Label", "Type", "TypeName", "Extendee", "DefaultValue", "OneofIndex", "JsonName", "Options", "Proto3Optional" }, null, new[]{ typeof(global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Type), typeof(global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Label) }, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.OneofDescriptorProto), global::LC.Google.Protobuf.Reflection.OneofDescriptorProto.Parser, new[]{ "Name", "Options" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.EnumDescriptorProto), global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Parser, new[]{ "Name", "Value", "Options", "ReservedRange", "ReservedName" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Types.EnumReservedRange), global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Types.EnumReservedRange.Parser, new[]{ "Start", "End" }, null, null, null, null)}),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.EnumValueDescriptorProto), global::LC.Google.Protobuf.Reflection.EnumValueDescriptorProto.Parser, new[]{ "Name", "Number", "Options" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.ServiceDescriptorProto), global::LC.Google.Protobuf.Reflection.ServiceDescriptorProto.Parser, new[]{ "Name", "Method", "Options" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.MethodDescriptorProto), global::LC.Google.Protobuf.Reflection.MethodDescriptorProto.Parser, new[]{ "Name", "InputType", "OutputType", "Options", "ClientStreaming", "ServerStreaming" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.FileOptions), global::LC.Google.Protobuf.Reflection.FileOptions.Parser, new[]{ "JavaPackage", "JavaOuterClassname", "JavaMultipleFiles", "JavaGenerateEqualsAndHash", "JavaStringCheckUtf8", "OptimizeFor", "GoPackage", "CcGenericServices", "JavaGenericServices", "PyGenericServices", "PhpGenericServices", "Deprecated", "CcEnableArenas", "ObjcClassPrefix", "CsharpNamespace", "SwiftPrefix", "PhpClassPrefix", "PhpNamespace", "PhpMetadataNamespace", "RubyPackage", "UninterpretedOption" }, null, new[]{ typeof(global::LC.Google.Protobuf.Reflection.FileOptions.Types.OptimizeMode) }, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.MessageOptions), global::LC.Google.Protobuf.Reflection.MessageOptions.Parser, new[]{ "MessageSetWireFormat", "NoStandardDescriptorAccessor", "Deprecated", "MapEntry", "UninterpretedOption" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.FieldOptions), global::LC.Google.Protobuf.Reflection.FieldOptions.Parser, new[]{ "Ctype", "Packed", "Jstype", "Lazy", "Deprecated", "Weak", "UninterpretedOption" }, null, new[]{ typeof(global::LC.Google.Protobuf.Reflection.FieldOptions.Types.CType), typeof(global::LC.Google.Protobuf.Reflection.FieldOptions.Types.JSType) }, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.OneofOptions), global::LC.Google.Protobuf.Reflection.OneofOptions.Parser, new[]{ "UninterpretedOption" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.EnumOptions), global::LC.Google.Protobuf.Reflection.EnumOptions.Parser, new[]{ "AllowAlias", "Deprecated", "UninterpretedOption" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.EnumValueOptions), global::LC.Google.Protobuf.Reflection.EnumValueOptions.Parser, new[]{ "Deprecated", "UninterpretedOption" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.ServiceOptions), global::LC.Google.Protobuf.Reflection.ServiceOptions.Parser, new[]{ "Deprecated", "UninterpretedOption" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.MethodOptions), global::LC.Google.Protobuf.Reflection.MethodOptions.Parser, new[]{ "Deprecated", "IdempotencyLevel", "UninterpretedOption" }, null, new[]{ typeof(global::LC.Google.Protobuf.Reflection.MethodOptions.Types.IdempotencyLevel) }, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.UninterpretedOption), global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser, new[]{ "Name", "IdentifierValue", "PositiveIntValue", "NegativeIntValue", "DoubleValue", "StringValue", "AggregateValue" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.UninterpretedOption.Types.NamePart), global::LC.Google.Protobuf.Reflection.UninterpretedOption.Types.NamePart.Parser, new[]{ "NamePart_", "IsExtension" }, null, null, null, null)}),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.SourceCodeInfo), global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Parser, new[]{ "Location" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Types.Location), global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Types.Location.Parser, new[]{ "Path", "Span", "LeadingComments", "TrailingComments", "LeadingDetachedComments" }, null, null, null, null)}),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo), global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Parser, new[]{ "Annotation" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Types.Annotation), global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Types.Annotation.Parser, new[]{ "Path", "SourceFile", "Begin", "End" }, null, null, null, null)})
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// The protocol compiler can output a FileDescriptorSet containing the .proto
+  /// files it parses.
+  /// </summary>
+  public sealed partial class FileDescriptorSet : pb::IMessage<FileDescriptorSet>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FileDescriptorSet> _parser = new pb::MessageParser<FileDescriptorSet>(() => new FileDescriptorSet());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<FileDescriptorSet> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileDescriptorSet() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileDescriptorSet(FileDescriptorSet other) : this() {
+      file_ = other.file_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileDescriptorSet Clone() {
+      return new FileDescriptorSet(this);
+    }
+
+    /// <summary>Field number for the "file" field.</summary>
+    public const int FileFieldNumber = 1;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.FileDescriptorProto> _repeated_file_codec
+        = pb::FieldCodec.ForMessage(10, global::LC.Google.Protobuf.Reflection.FileDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FileDescriptorProto> file_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FileDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FileDescriptorProto> File {
+      get { return file_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as FileDescriptorSet);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(FileDescriptorSet other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!file_.Equals(other.file_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= file_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      file_.WriteTo(output, _repeated_file_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      file_.WriteTo(ref output, _repeated_file_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += file_.CalculateSize(_repeated_file_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(FileDescriptorSet other) {
+      if (other == null) {
+        return;
+      }
+      file_.Add(other.file_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            file_.AddEntriesFrom(input, _repeated_file_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            file_.AddEntriesFrom(ref input, _repeated_file_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Describes a complete .proto file.
+  /// </summary>
+  public sealed partial class FileDescriptorProto : pb::IMessage<FileDescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FileDescriptorProto> _parser = new pb::MessageParser<FileDescriptorProto>(() => new FileDescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<FileDescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[1]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileDescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileDescriptorProto(FileDescriptorProto other) : this() {
+      name_ = other.name_;
+      package_ = other.package_;
+      dependency_ = other.dependency_.Clone();
+      publicDependency_ = other.publicDependency_.Clone();
+      weakDependency_ = other.weakDependency_.Clone();
+      messageType_ = other.messageType_.Clone();
+      enumType_ = other.enumType_.Clone();
+      service_ = other.service_.Clone();
+      extension_ = other.extension_.Clone();
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      sourceCodeInfo_ = other.sourceCodeInfo_ != null ? other.sourceCodeInfo_.Clone() : null;
+      syntax_ = other.syntax_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileDescriptorProto Clone() {
+      return new FileDescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    /// <summary>
+    /// file name, relative to root of source tree
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "package" field.</summary>
+    public const int PackageFieldNumber = 2;
+    private readonly static string PackageDefaultValue = "";
+
+    private string package_;
+    /// <summary>
+    /// e.g. "foo", "foo.bar", etc.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Package {
+      get { return package_ ?? PackageDefaultValue; }
+      set {
+        package_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "package" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPackage {
+      get { return package_ != null; }
+    }
+    /// <summary>Clears the value of the "package" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPackage() {
+      package_ = null;
+    }
+
+    /// <summary>Field number for the "dependency" field.</summary>
+    public const int DependencyFieldNumber = 3;
+    private static readonly pb::FieldCodec<string> _repeated_dependency_codec
+        = pb::FieldCodec.ForString(26);
+    private readonly pbc::RepeatedField<string> dependency_ = new pbc::RepeatedField<string>();
+    /// <summary>
+    /// Names of files imported by this file.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<string> Dependency {
+      get { return dependency_; }
+    }
+
+    /// <summary>Field number for the "public_dependency" field.</summary>
+    public const int PublicDependencyFieldNumber = 10;
+    private static readonly pb::FieldCodec<int> _repeated_publicDependency_codec
+        = pb::FieldCodec.ForInt32(80);
+    private readonly pbc::RepeatedField<int> publicDependency_ = new pbc::RepeatedField<int>();
+    /// <summary>
+    /// Indexes of the public imported files in the dependency list above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<int> PublicDependency {
+      get { return publicDependency_; }
+    }
+
+    /// <summary>Field number for the "weak_dependency" field.</summary>
+    public const int WeakDependencyFieldNumber = 11;
+    private static readonly pb::FieldCodec<int> _repeated_weakDependency_codec
+        = pb::FieldCodec.ForInt32(88);
+    private readonly pbc::RepeatedField<int> weakDependency_ = new pbc::RepeatedField<int>();
+    /// <summary>
+    /// Indexes of the weak imported files in the dependency list.
+    /// For Google-internal migration only. Do not use.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<int> WeakDependency {
+      get { return weakDependency_; }
+    }
+
+    /// <summary>Field number for the "message_type" field.</summary>
+    public const int MessageTypeFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.DescriptorProto> _repeated_messageType_codec
+        = pb::FieldCodec.ForMessage(34, global::LC.Google.Protobuf.Reflection.DescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto> messageType_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto>();
+    /// <summary>
+    /// All top-level definitions in this file.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto> MessageType {
+      get { return messageType_; }
+    }
+
+    /// <summary>Field number for the "enum_type" field.</summary>
+    public const int EnumTypeFieldNumber = 5;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto> _repeated_enumType_codec
+        = pb::FieldCodec.ForMessage(42, global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto> EnumType {
+      get { return enumType_; }
+    }
+
+    /// <summary>Field number for the "service" field.</summary>
+    public const int ServiceFieldNumber = 6;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.ServiceDescriptorProto> _repeated_service_codec
+        = pb::FieldCodec.ForMessage(50, global::LC.Google.Protobuf.Reflection.ServiceDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.ServiceDescriptorProto> service_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.ServiceDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.ServiceDescriptorProto> Service {
+      get { return service_; }
+    }
+
+    /// <summary>Field number for the "extension" field.</summary>
+    public const int ExtensionFieldNumber = 7;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> _repeated_extension_codec
+        = pb::FieldCodec.ForMessage(58, global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> Extension {
+      get { return extension_; }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 8;
+    private global::LC.Google.Protobuf.Reflection.FileOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.FileOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "source_code_info" field.</summary>
+    public const int SourceCodeInfoFieldNumber = 9;
+    private global::LC.Google.Protobuf.Reflection.SourceCodeInfo sourceCodeInfo_;
+    /// <summary>
+    /// This field contains optional information about the original source code.
+    /// You may safely remove this entire field without harming runtime
+    /// functionality of the descriptors -- the information is needed only by
+    /// development tools.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.SourceCodeInfo SourceCodeInfo {
+      get { return sourceCodeInfo_; }
+      set {
+        sourceCodeInfo_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "syntax" field.</summary>
+    public const int SyntaxFieldNumber = 12;
+    private readonly static string SyntaxDefaultValue = "";
+
+    private string syntax_;
+    /// <summary>
+    /// The syntax of the proto file.
+    /// The supported values are "proto2" and "proto3".
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Syntax {
+      get { return syntax_ ?? SyntaxDefaultValue; }
+      set {
+        syntax_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "syntax" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasSyntax {
+      get { return syntax_ != null; }
+    }
+    /// <summary>Clears the value of the "syntax" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearSyntax() {
+      syntax_ = null;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as FileDescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(FileDescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (Package != other.Package) return false;
+      if(!dependency_.Equals(other.dependency_)) return false;
+      if(!publicDependency_.Equals(other.publicDependency_)) return false;
+      if(!weakDependency_.Equals(other.weakDependency_)) return false;
+      if(!messageType_.Equals(other.messageType_)) return false;
+      if(!enumType_.Equals(other.enumType_)) return false;
+      if(!service_.Equals(other.service_)) return false;
+      if(!extension_.Equals(other.extension_)) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      if (!object.Equals(SourceCodeInfo, other.SourceCodeInfo)) return false;
+      if (Syntax != other.Syntax) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      if (HasPackage) hash ^= Package.GetHashCode();
+      hash ^= dependency_.GetHashCode();
+      hash ^= publicDependency_.GetHashCode();
+      hash ^= weakDependency_.GetHashCode();
+      hash ^= messageType_.GetHashCode();
+      hash ^= enumType_.GetHashCode();
+      hash ^= service_.GetHashCode();
+      hash ^= extension_.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      if (sourceCodeInfo_ != null) hash ^= SourceCodeInfo.GetHashCode();
+      if (HasSyntax) hash ^= Syntax.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasPackage) {
+        output.WriteRawTag(18);
+        output.WriteString(Package);
+      }
+      dependency_.WriteTo(output, _repeated_dependency_codec);
+      messageType_.WriteTo(output, _repeated_messageType_codec);
+      enumType_.WriteTo(output, _repeated_enumType_codec);
+      service_.WriteTo(output, _repeated_service_codec);
+      extension_.WriteTo(output, _repeated_extension_codec);
+      if (options_ != null) {
+        output.WriteRawTag(66);
+        output.WriteMessage(Options);
+      }
+      if (sourceCodeInfo_ != null) {
+        output.WriteRawTag(74);
+        output.WriteMessage(SourceCodeInfo);
+      }
+      publicDependency_.WriteTo(output, _repeated_publicDependency_codec);
+      weakDependency_.WriteTo(output, _repeated_weakDependency_codec);
+      if (HasSyntax) {
+        output.WriteRawTag(98);
+        output.WriteString(Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasPackage) {
+        output.WriteRawTag(18);
+        output.WriteString(Package);
+      }
+      dependency_.WriteTo(ref output, _repeated_dependency_codec);
+      messageType_.WriteTo(ref output, _repeated_messageType_codec);
+      enumType_.WriteTo(ref output, _repeated_enumType_codec);
+      service_.WriteTo(ref output, _repeated_service_codec);
+      extension_.WriteTo(ref output, _repeated_extension_codec);
+      if (options_ != null) {
+        output.WriteRawTag(66);
+        output.WriteMessage(Options);
+      }
+      if (sourceCodeInfo_ != null) {
+        output.WriteRawTag(74);
+        output.WriteMessage(SourceCodeInfo);
+      }
+      publicDependency_.WriteTo(ref output, _repeated_publicDependency_codec);
+      weakDependency_.WriteTo(ref output, _repeated_weakDependency_codec);
+      if (HasSyntax) {
+        output.WriteRawTag(98);
+        output.WriteString(Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (HasPackage) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Package);
+      }
+      size += dependency_.CalculateSize(_repeated_dependency_codec);
+      size += publicDependency_.CalculateSize(_repeated_publicDependency_codec);
+      size += weakDependency_.CalculateSize(_repeated_weakDependency_codec);
+      size += messageType_.CalculateSize(_repeated_messageType_codec);
+      size += enumType_.CalculateSize(_repeated_enumType_codec);
+      size += service_.CalculateSize(_repeated_service_codec);
+      size += extension_.CalculateSize(_repeated_extension_codec);
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      if (sourceCodeInfo_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(SourceCodeInfo);
+      }
+      if (HasSyntax) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Syntax);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(FileDescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      if (other.HasPackage) {
+        Package = other.Package;
+      }
+      dependency_.Add(other.dependency_);
+      publicDependency_.Add(other.publicDependency_);
+      weakDependency_.Add(other.weakDependency_);
+      messageType_.Add(other.messageType_);
+      enumType_.Add(other.enumType_);
+      service_.Add(other.service_);
+      extension_.Add(other.extension_);
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.FileOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      if (other.sourceCodeInfo_ != null) {
+        if (sourceCodeInfo_ == null) {
+          SourceCodeInfo = new global::LC.Google.Protobuf.Reflection.SourceCodeInfo();
+        }
+        SourceCodeInfo.MergeFrom(other.SourceCodeInfo);
+      }
+      if (other.HasSyntax) {
+        Syntax = other.Syntax;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            Package = input.ReadString();
+            break;
+          }
+          case 26: {
+            dependency_.AddEntriesFrom(input, _repeated_dependency_codec);
+            break;
+          }
+          case 34: {
+            messageType_.AddEntriesFrom(input, _repeated_messageType_codec);
+            break;
+          }
+          case 42: {
+            enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
+            break;
+          }
+          case 50: {
+            service_.AddEntriesFrom(input, _repeated_service_codec);
+            break;
+          }
+          case 58: {
+            extension_.AddEntriesFrom(input, _repeated_extension_codec);
+            break;
+          }
+          case 66: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.FileOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 74: {
+            if (sourceCodeInfo_ == null) {
+              SourceCodeInfo = new global::LC.Google.Protobuf.Reflection.SourceCodeInfo();
+            }
+            input.ReadMessage(SourceCodeInfo);
+            break;
+          }
+          case 82:
+          case 80: {
+            publicDependency_.AddEntriesFrom(input, _repeated_publicDependency_codec);
+            break;
+          }
+          case 90:
+          case 88: {
+            weakDependency_.AddEntriesFrom(input, _repeated_weakDependency_codec);
+            break;
+          }
+          case 98: {
+            Syntax = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            Package = input.ReadString();
+            break;
+          }
+          case 26: {
+            dependency_.AddEntriesFrom(ref input, _repeated_dependency_codec);
+            break;
+          }
+          case 34: {
+            messageType_.AddEntriesFrom(ref input, _repeated_messageType_codec);
+            break;
+          }
+          case 42: {
+            enumType_.AddEntriesFrom(ref input, _repeated_enumType_codec);
+            break;
+          }
+          case 50: {
+            service_.AddEntriesFrom(ref input, _repeated_service_codec);
+            break;
+          }
+          case 58: {
+            extension_.AddEntriesFrom(ref input, _repeated_extension_codec);
+            break;
+          }
+          case 66: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.FileOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 74: {
+            if (sourceCodeInfo_ == null) {
+              SourceCodeInfo = new global::LC.Google.Protobuf.Reflection.SourceCodeInfo();
+            }
+            input.ReadMessage(SourceCodeInfo);
+            break;
+          }
+          case 82:
+          case 80: {
+            publicDependency_.AddEntriesFrom(ref input, _repeated_publicDependency_codec);
+            break;
+          }
+          case 90:
+          case 88: {
+            weakDependency_.AddEntriesFrom(ref input, _repeated_weakDependency_codec);
+            break;
+          }
+          case 98: {
+            Syntax = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Describes a message type.
+  /// </summary>
+  public sealed partial class DescriptorProto : pb::IMessage<DescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<DescriptorProto> _parser = new pb::MessageParser<DescriptorProto>(() => new DescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<DescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[2]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public DescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public DescriptorProto(DescriptorProto other) : this() {
+      name_ = other.name_;
+      field_ = other.field_.Clone();
+      extension_ = other.extension_.Clone();
+      nestedType_ = other.nestedType_.Clone();
+      enumType_ = other.enumType_.Clone();
+      extensionRange_ = other.extensionRange_.Clone();
+      oneofDecl_ = other.oneofDecl_.Clone();
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      reservedRange_ = other.reservedRange_.Clone();
+      reservedName_ = other.reservedName_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public DescriptorProto Clone() {
+      return new DescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "field" field.</summary>
+    public const int FieldFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> _repeated_field_codec
+        = pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> field_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> Field {
+      get { return field_; }
+    }
+
+    /// <summary>Field number for the "extension" field.</summary>
+    public const int ExtensionFieldNumber = 6;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> _repeated_extension_codec
+        = pb::FieldCodec.ForMessage(50, global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.FieldDescriptorProto> Extension {
+      get { return extension_; }
+    }
+
+    /// <summary>Field number for the "nested_type" field.</summary>
+    public const int NestedTypeFieldNumber = 3;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.DescriptorProto> _repeated_nestedType_codec
+        = pb::FieldCodec.ForMessage(26, global::LC.Google.Protobuf.Reflection.DescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto> nestedType_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto> NestedType {
+      get { return nestedType_; }
+    }
+
+    /// <summary>Field number for the "enum_type" field.</summary>
+    public const int EnumTypeFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto> _repeated_enumType_codec
+        = pb::FieldCodec.ForMessage(34, global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto> EnumType {
+      get { return enumType_; }
+    }
+
+    /// <summary>Field number for the "extension_range" field.</summary>
+    public const int ExtensionRangeFieldNumber = 5;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ExtensionRange> _repeated_extensionRange_codec
+        = pb::FieldCodec.ForMessage(42, global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ExtensionRange.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ExtensionRange> extensionRange_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ExtensionRange>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ExtensionRange> ExtensionRange {
+      get { return extensionRange_; }
+    }
+
+    /// <summary>Field number for the "oneof_decl" field.</summary>
+    public const int OneofDeclFieldNumber = 8;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.OneofDescriptorProto> _repeated_oneofDecl_codec
+        = pb::FieldCodec.ForMessage(66, global::LC.Google.Protobuf.Reflection.OneofDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.OneofDescriptorProto> oneofDecl_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.OneofDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.OneofDescriptorProto> OneofDecl {
+      get { return oneofDecl_; }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 7;
+    private global::LC.Google.Protobuf.Reflection.MessageOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.MessageOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "reserved_range" field.</summary>
+    public const int ReservedRangeFieldNumber = 9;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ReservedRange> _repeated_reservedRange_codec
+        = pb::FieldCodec.ForMessage(74, global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ReservedRange.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ReservedRange> reservedRange_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ReservedRange>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.DescriptorProto.Types.ReservedRange> ReservedRange {
+      get { return reservedRange_; }
+    }
+
+    /// <summary>Field number for the "reserved_name" field.</summary>
+    public const int ReservedNameFieldNumber = 10;
+    private static readonly pb::FieldCodec<string> _repeated_reservedName_codec
+        = pb::FieldCodec.ForString(82);
+    private readonly pbc::RepeatedField<string> reservedName_ = new pbc::RepeatedField<string>();
+    /// <summary>
+    /// Reserved field names, which may not be used by fields in the same message.
+    /// A given name may only be reserved once.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<string> ReservedName {
+      get { return reservedName_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as DescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(DescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if(!field_.Equals(other.field_)) return false;
+      if(!extension_.Equals(other.extension_)) return false;
+      if(!nestedType_.Equals(other.nestedType_)) return false;
+      if(!enumType_.Equals(other.enumType_)) return false;
+      if(!extensionRange_.Equals(other.extensionRange_)) return false;
+      if(!oneofDecl_.Equals(other.oneofDecl_)) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      if(!reservedRange_.Equals(other.reservedRange_)) return false;
+      if(!reservedName_.Equals(other.reservedName_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      hash ^= field_.GetHashCode();
+      hash ^= extension_.GetHashCode();
+      hash ^= nestedType_.GetHashCode();
+      hash ^= enumType_.GetHashCode();
+      hash ^= extensionRange_.GetHashCode();
+      hash ^= oneofDecl_.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      hash ^= reservedRange_.GetHashCode();
+      hash ^= reservedName_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      field_.WriteTo(output, _repeated_field_codec);
+      nestedType_.WriteTo(output, _repeated_nestedType_codec);
+      enumType_.WriteTo(output, _repeated_enumType_codec);
+      extensionRange_.WriteTo(output, _repeated_extensionRange_codec);
+      extension_.WriteTo(output, _repeated_extension_codec);
+      if (options_ != null) {
+        output.WriteRawTag(58);
+        output.WriteMessage(Options);
+      }
+      oneofDecl_.WriteTo(output, _repeated_oneofDecl_codec);
+      reservedRange_.WriteTo(output, _repeated_reservedRange_codec);
+      reservedName_.WriteTo(output, _repeated_reservedName_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      field_.WriteTo(ref output, _repeated_field_codec);
+      nestedType_.WriteTo(ref output, _repeated_nestedType_codec);
+      enumType_.WriteTo(ref output, _repeated_enumType_codec);
+      extensionRange_.WriteTo(ref output, _repeated_extensionRange_codec);
+      extension_.WriteTo(ref output, _repeated_extension_codec);
+      if (options_ != null) {
+        output.WriteRawTag(58);
+        output.WriteMessage(Options);
+      }
+      oneofDecl_.WriteTo(ref output, _repeated_oneofDecl_codec);
+      reservedRange_.WriteTo(ref output, _repeated_reservedRange_codec);
+      reservedName_.WriteTo(ref output, _repeated_reservedName_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      size += field_.CalculateSize(_repeated_field_codec);
+      size += extension_.CalculateSize(_repeated_extension_codec);
+      size += nestedType_.CalculateSize(_repeated_nestedType_codec);
+      size += enumType_.CalculateSize(_repeated_enumType_codec);
+      size += extensionRange_.CalculateSize(_repeated_extensionRange_codec);
+      size += oneofDecl_.CalculateSize(_repeated_oneofDecl_codec);
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      size += reservedRange_.CalculateSize(_repeated_reservedRange_codec);
+      size += reservedName_.CalculateSize(_repeated_reservedName_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(DescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      field_.Add(other.field_);
+      extension_.Add(other.extension_);
+      nestedType_.Add(other.nestedType_);
+      enumType_.Add(other.enumType_);
+      extensionRange_.Add(other.extensionRange_);
+      oneofDecl_.Add(other.oneofDecl_);
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.MessageOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      reservedRange_.Add(other.reservedRange_);
+      reservedName_.Add(other.reservedName_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            field_.AddEntriesFrom(input, _repeated_field_codec);
+            break;
+          }
+          case 26: {
+            nestedType_.AddEntriesFrom(input, _repeated_nestedType_codec);
+            break;
+          }
+          case 34: {
+            enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
+            break;
+          }
+          case 42: {
+            extensionRange_.AddEntriesFrom(input, _repeated_extensionRange_codec);
+            break;
+          }
+          case 50: {
+            extension_.AddEntriesFrom(input, _repeated_extension_codec);
+            break;
+          }
+          case 58: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.MessageOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 66: {
+            oneofDecl_.AddEntriesFrom(input, _repeated_oneofDecl_codec);
+            break;
+          }
+          case 74: {
+            reservedRange_.AddEntriesFrom(input, _repeated_reservedRange_codec);
+            break;
+          }
+          case 82: {
+            reservedName_.AddEntriesFrom(input, _repeated_reservedName_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            field_.AddEntriesFrom(ref input, _repeated_field_codec);
+            break;
+          }
+          case 26: {
+            nestedType_.AddEntriesFrom(ref input, _repeated_nestedType_codec);
+            break;
+          }
+          case 34: {
+            enumType_.AddEntriesFrom(ref input, _repeated_enumType_codec);
+            break;
+          }
+          case 42: {
+            extensionRange_.AddEntriesFrom(ref input, _repeated_extensionRange_codec);
+            break;
+          }
+          case 50: {
+            extension_.AddEntriesFrom(ref input, _repeated_extension_codec);
+            break;
+          }
+          case 58: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.MessageOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 66: {
+            oneofDecl_.AddEntriesFrom(ref input, _repeated_oneofDecl_codec);
+            break;
+          }
+          case 74: {
+            reservedRange_.AddEntriesFrom(ref input, _repeated_reservedRange_codec);
+            break;
+          }
+          case 82: {
+            reservedName_.AddEntriesFrom(ref input, _repeated_reservedName_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the DescriptorProto message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      public sealed partial class ExtensionRange : pb::IMessage<ExtensionRange>
+      #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          , pb::IBufferMessage
+      #endif
+      {
+        private static readonly pb::MessageParser<ExtensionRange> _parser = new pb::MessageParser<ExtensionRange>(() => new ExtensionRange());
+        private pb::UnknownFieldSet _unknownFields;
+        private int _hasBits0;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pb::MessageParser<ExtensionRange> Parser { get { return _parser; } }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pbr::MessageDescriptor Descriptor {
+          get { return global::LC.Google.Protobuf.Reflection.DescriptorProto.Descriptor.NestedTypes[0]; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        pbr::MessageDescriptor pb::IMessage.Descriptor {
+          get { return Descriptor; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public ExtensionRange() {
+          OnConstruction();
+        }
+
+        partial void OnConstruction();
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public ExtensionRange(ExtensionRange other) : this() {
+          _hasBits0 = other._hasBits0;
+          start_ = other.start_;
+          end_ = other.end_;
+          options_ = other.options_ != null ? other.options_.Clone() : null;
+          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public ExtensionRange Clone() {
+          return new ExtensionRange(this);
+        }
+
+        /// <summary>Field number for the "start" field.</summary>
+        public const int StartFieldNumber = 1;
+        private readonly static int StartDefaultValue = 0;
+
+        private int start_;
+        /// <summary>
+        /// Inclusive.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int Start {
+          get { if ((_hasBits0 & 1) != 0) { return start_; } else { return StartDefaultValue; } }
+          set {
+            _hasBits0 |= 1;
+            start_ = value;
+          }
+        }
+        /// <summary>Gets whether the "start" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasStart {
+          get { return (_hasBits0 & 1) != 0; }
+        }
+        /// <summary>Clears the value of the "start" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearStart() {
+          _hasBits0 &= ~1;
+        }
+
+        /// <summary>Field number for the "end" field.</summary>
+        public const int EndFieldNumber = 2;
+        private readonly static int EndDefaultValue = 0;
+
+        private int end_;
+        /// <summary>
+        /// Exclusive.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int End {
+          get { if ((_hasBits0 & 2) != 0) { return end_; } else { return EndDefaultValue; } }
+          set {
+            _hasBits0 |= 2;
+            end_ = value;
+          }
+        }
+        /// <summary>Gets whether the "end" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasEnd {
+          get { return (_hasBits0 & 2) != 0; }
+        }
+        /// <summary>Clears the value of the "end" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearEnd() {
+          _hasBits0 &= ~2;
+        }
+
+        /// <summary>Field number for the "options" field.</summary>
+        public const int OptionsFieldNumber = 3;
+        private global::LC.Google.Protobuf.Reflection.ExtensionRangeOptions options_;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public global::LC.Google.Protobuf.Reflection.ExtensionRangeOptions Options {
+          get { return options_; }
+          set {
+            options_ = value;
+          }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override bool Equals(object other) {
+          return Equals(other as ExtensionRange);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool Equals(ExtensionRange other) {
+          if (ReferenceEquals(other, null)) {
+            return false;
+          }
+          if (ReferenceEquals(other, this)) {
+            return true;
+          }
+          if (Start != other.Start) return false;
+          if (End != other.End) return false;
+          if (!object.Equals(Options, other.Options)) return false;
+          return Equals(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override int GetHashCode() {
+          int hash = 1;
+          if (HasStart) hash ^= Start.GetHashCode();
+          if (HasEnd) hash ^= End.GetHashCode();
+          if (options_ != null) hash ^= Options.GetHashCode();
+          if (_unknownFields != null) {
+            hash ^= _unknownFields.GetHashCode();
+          }
+          return hash;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override string ToString() {
+          return pb::JsonFormatter.ToDiagnosticString(this);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void WriteTo(pb::CodedOutputStream output) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          output.WriteRawMessage(this);
+        #else
+          if (HasStart) {
+            output.WriteRawTag(8);
+            output.WriteInt32(Start);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(16);
+            output.WriteInt32(End);
+          }
+          if (options_ != null) {
+            output.WriteRawTag(26);
+            output.WriteMessage(Options);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(output);
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+          if (HasStart) {
+            output.WriteRawTag(8);
+            output.WriteInt32(Start);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(16);
+            output.WriteInt32(End);
+          }
+          if (options_ != null) {
+            output.WriteRawTag(26);
+            output.WriteMessage(Options);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(ref output);
+          }
+        }
+        #endif
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int CalculateSize() {
+          int size = 0;
+          if (HasStart) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Start);
+          }
+          if (HasEnd) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
+          }
+          if (options_ != null) {
+            size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+          }
+          if (_unknownFields != null) {
+            size += _unknownFields.CalculateSize();
+          }
+          return size;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(ExtensionRange other) {
+          if (other == null) {
+            return;
+          }
+          if (other.HasStart) {
+            Start = other.Start;
+          }
+          if (other.HasEnd) {
+            End = other.End;
+          }
+          if (other.options_ != null) {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.ExtensionRangeOptions();
+            }
+            Options.MergeFrom(other.Options);
+          }
+          _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(pb::CodedInputStream input) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          input.ReadRawMessage(this);
+        #else
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+                break;
+              case 8: {
+                Start = input.ReadInt32();
+                break;
+              }
+              case 16: {
+                End = input.ReadInt32();
+                break;
+              }
+              case 26: {
+                if (options_ == null) {
+                  Options = new global::LC.Google.Protobuf.Reflection.ExtensionRangeOptions();
+                }
+                input.ReadMessage(Options);
+                break;
+              }
+            }
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+                break;
+              case 8: {
+                Start = input.ReadInt32();
+                break;
+              }
+              case 16: {
+                End = input.ReadInt32();
+                break;
+              }
+              case 26: {
+                if (options_ == null) {
+                  Options = new global::LC.Google.Protobuf.Reflection.ExtensionRangeOptions();
+                }
+                input.ReadMessage(Options);
+                break;
+              }
+            }
+          }
+        }
+        #endif
+
+      }
+
+      /// <summary>
+      /// Range of reserved tag numbers. Reserved tag numbers may not be used by
+      /// fields or extension ranges in the same message. Reserved ranges may
+      /// not overlap.
+      /// </summary>
+      public sealed partial class ReservedRange : pb::IMessage<ReservedRange>
+      #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          , pb::IBufferMessage
+      #endif
+      {
+        private static readonly pb::MessageParser<ReservedRange> _parser = new pb::MessageParser<ReservedRange>(() => new ReservedRange());
+        private pb::UnknownFieldSet _unknownFields;
+        private int _hasBits0;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pb::MessageParser<ReservedRange> Parser { get { return _parser; } }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pbr::MessageDescriptor Descriptor {
+          get { return global::LC.Google.Protobuf.Reflection.DescriptorProto.Descriptor.NestedTypes[1]; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        pbr::MessageDescriptor pb::IMessage.Descriptor {
+          get { return Descriptor; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public ReservedRange() {
+          OnConstruction();
+        }
+
+        partial void OnConstruction();
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public ReservedRange(ReservedRange other) : this() {
+          _hasBits0 = other._hasBits0;
+          start_ = other.start_;
+          end_ = other.end_;
+          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public ReservedRange Clone() {
+          return new ReservedRange(this);
+        }
+
+        /// <summary>Field number for the "start" field.</summary>
+        public const int StartFieldNumber = 1;
+        private readonly static int StartDefaultValue = 0;
+
+        private int start_;
+        /// <summary>
+        /// Inclusive.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int Start {
+          get { if ((_hasBits0 & 1) != 0) { return start_; } else { return StartDefaultValue; } }
+          set {
+            _hasBits0 |= 1;
+            start_ = value;
+          }
+        }
+        /// <summary>Gets whether the "start" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasStart {
+          get { return (_hasBits0 & 1) != 0; }
+        }
+        /// <summary>Clears the value of the "start" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearStart() {
+          _hasBits0 &= ~1;
+        }
+
+        /// <summary>Field number for the "end" field.</summary>
+        public const int EndFieldNumber = 2;
+        private readonly static int EndDefaultValue = 0;
+
+        private int end_;
+        /// <summary>
+        /// Exclusive.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int End {
+          get { if ((_hasBits0 & 2) != 0) { return end_; } else { return EndDefaultValue; } }
+          set {
+            _hasBits0 |= 2;
+            end_ = value;
+          }
+        }
+        /// <summary>Gets whether the "end" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasEnd {
+          get { return (_hasBits0 & 2) != 0; }
+        }
+        /// <summary>Clears the value of the "end" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearEnd() {
+          _hasBits0 &= ~2;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override bool Equals(object other) {
+          return Equals(other as ReservedRange);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool Equals(ReservedRange other) {
+          if (ReferenceEquals(other, null)) {
+            return false;
+          }
+          if (ReferenceEquals(other, this)) {
+            return true;
+          }
+          if (Start != other.Start) return false;
+          if (End != other.End) return false;
+          return Equals(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override int GetHashCode() {
+          int hash = 1;
+          if (HasStart) hash ^= Start.GetHashCode();
+          if (HasEnd) hash ^= End.GetHashCode();
+          if (_unknownFields != null) {
+            hash ^= _unknownFields.GetHashCode();
+          }
+          return hash;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override string ToString() {
+          return pb::JsonFormatter.ToDiagnosticString(this);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void WriteTo(pb::CodedOutputStream output) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          output.WriteRawMessage(this);
+        #else
+          if (HasStart) {
+            output.WriteRawTag(8);
+            output.WriteInt32(Start);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(16);
+            output.WriteInt32(End);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(output);
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+          if (HasStart) {
+            output.WriteRawTag(8);
+            output.WriteInt32(Start);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(16);
+            output.WriteInt32(End);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(ref output);
+          }
+        }
+        #endif
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int CalculateSize() {
+          int size = 0;
+          if (HasStart) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Start);
+          }
+          if (HasEnd) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
+          }
+          if (_unknownFields != null) {
+            size += _unknownFields.CalculateSize();
+          }
+          return size;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(ReservedRange other) {
+          if (other == null) {
+            return;
+          }
+          if (other.HasStart) {
+            Start = other.Start;
+          }
+          if (other.HasEnd) {
+            End = other.End;
+          }
+          _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(pb::CodedInputStream input) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          input.ReadRawMessage(this);
+        #else
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+                break;
+              case 8: {
+                Start = input.ReadInt32();
+                break;
+              }
+              case 16: {
+                End = input.ReadInt32();
+                break;
+              }
+            }
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+                break;
+              case 8: {
+                Start = input.ReadInt32();
+                break;
+              }
+              case 16: {
+                End = input.ReadInt32();
+                break;
+              }
+            }
+          }
+        }
+        #endif
+
+      }
+
+    }
+    #endregion
+
+  }
+
+  public sealed partial class ExtensionRangeOptions : pb::IExtendableMessage<ExtensionRangeOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<ExtensionRangeOptions> _parser = new pb::MessageParser<ExtensionRangeOptions>(() => new ExtensionRangeOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<ExtensionRangeOptions> _extensions;
+    private pb::ExtensionSet<ExtensionRangeOptions> _Extensions { get { return _extensions; } }
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<ExtensionRangeOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[3]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ExtensionRangeOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ExtensionRangeOptions(ExtensionRangeOptions other) : this() {
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ExtensionRangeOptions Clone() {
+      return new ExtensionRangeOptions(this);
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as ExtensionRangeOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(ExtensionRangeOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(ExtensionRangeOptions other) {
+      if (other == null) {
+        return;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<ExtensionRangeOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<ExtensionRangeOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<ExtensionRangeOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<ExtensionRangeOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<ExtensionRangeOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<ExtensionRangeOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<ExtensionRangeOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+  }
+
+  /// <summary>
+  /// Describes a field within a message.
+  /// </summary>
+  public sealed partial class FieldDescriptorProto : pb::IMessage<FieldDescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FieldDescriptorProto> _parser = new pb::MessageParser<FieldDescriptorProto>(() => new FieldDescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<FieldDescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[4]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldDescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldDescriptorProto(FieldDescriptorProto other) : this() {
+      _hasBits0 = other._hasBits0;
+      name_ = other.name_;
+      number_ = other.number_;
+      label_ = other.label_;
+      type_ = other.type_;
+      typeName_ = other.typeName_;
+      extendee_ = other.extendee_;
+      defaultValue_ = other.defaultValue_;
+      oneofIndex_ = other.oneofIndex_;
+      jsonName_ = other.jsonName_;
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      proto3Optional_ = other.proto3Optional_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldDescriptorProto Clone() {
+      return new FieldDescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "number" field.</summary>
+    public const int NumberFieldNumber = 3;
+    private readonly static int NumberDefaultValue = 0;
+
+    private int number_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int Number {
+      get { if ((_hasBits0 & 1) != 0) { return number_; } else { return NumberDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        number_ = value;
+      }
+    }
+    /// <summary>Gets whether the "number" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasNumber {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "number" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearNumber() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "label" field.</summary>
+    public const int LabelFieldNumber = 4;
+    private readonly static global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Label LabelDefaultValue = global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Label.Optional;
+
+    private global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Label label_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Label Label {
+      get { if ((_hasBits0 & 2) != 0) { return label_; } else { return LabelDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        label_ = value;
+      }
+    }
+    /// <summary>Gets whether the "label" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasLabel {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "label" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearLabel() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "type" field.</summary>
+    public const int TypeFieldNumber = 5;
+    private readonly static global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Type TypeDefaultValue = global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Type.Double;
+
+    private global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Type type_;
+    /// <summary>
+    /// If type_name is set, this need not be set.  If both this and type_name
+    /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Type Type {
+      get { if ((_hasBits0 & 4) != 0) { return type_; } else { return TypeDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        type_ = value;
+      }
+    }
+    /// <summary>Gets whether the "type" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasType {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "type" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearType() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "type_name" field.</summary>
+    public const int TypeNameFieldNumber = 6;
+    private readonly static string TypeNameDefaultValue = "";
+
+    private string typeName_;
+    /// <summary>
+    /// For message and enum types, this is the name of the type.  If the name
+    /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+    /// rules are used to find the type (i.e. first the nested types within this
+    /// message are searched, then within the parent, on up to the root
+    /// namespace).
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string TypeName {
+      get { return typeName_ ?? TypeNameDefaultValue; }
+      set {
+        typeName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "type_name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasTypeName {
+      get { return typeName_ != null; }
+    }
+    /// <summary>Clears the value of the "type_name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearTypeName() {
+      typeName_ = null;
+    }
+
+    /// <summary>Field number for the "extendee" field.</summary>
+    public const int ExtendeeFieldNumber = 2;
+    private readonly static string ExtendeeDefaultValue = "";
+
+    private string extendee_;
+    /// <summary>
+    /// For extensions, this is the name of the type being extended.  It is
+    /// resolved in the same manner as type_name.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Extendee {
+      get { return extendee_ ?? ExtendeeDefaultValue; }
+      set {
+        extendee_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "extendee" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasExtendee {
+      get { return extendee_ != null; }
+    }
+    /// <summary>Clears the value of the "extendee" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearExtendee() {
+      extendee_ = null;
+    }
+
+    /// <summary>Field number for the "default_value" field.</summary>
+    public const int DefaultValueFieldNumber = 7;
+    private readonly static string DefaultValueDefaultValue = "";
+
+    private string defaultValue_;
+    /// <summary>
+    /// For numeric types, contains the original text representation of the value.
+    /// For booleans, "true" or "false".
+    /// For strings, contains the default text contents (not escaped in any way).
+    /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+    /// TODO(kenton):  Base-64 encode?
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string DefaultValue {
+      get { return defaultValue_ ?? DefaultValueDefaultValue; }
+      set {
+        defaultValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "default_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDefaultValue {
+      get { return defaultValue_ != null; }
+    }
+    /// <summary>Clears the value of the "default_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDefaultValue() {
+      defaultValue_ = null;
+    }
+
+    /// <summary>Field number for the "oneof_index" field.</summary>
+    public const int OneofIndexFieldNumber = 9;
+    private readonly static int OneofIndexDefaultValue = 0;
+
+    private int oneofIndex_;
+    /// <summary>
+    /// If set, gives the index of a oneof in the containing type's oneof_decl
+    /// list.  This field is a member of that oneof.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int OneofIndex {
+      get { if ((_hasBits0 & 8) != 0) { return oneofIndex_; } else { return OneofIndexDefaultValue; } }
+      set {
+        _hasBits0 |= 8;
+        oneofIndex_ = value;
+      }
+    }
+    /// <summary>Gets whether the "oneof_index" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasOneofIndex {
+      get { return (_hasBits0 & 8) != 0; }
+    }
+    /// <summary>Clears the value of the "oneof_index" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearOneofIndex() {
+      _hasBits0 &= ~8;
+    }
+
+    /// <summary>Field number for the "json_name" field.</summary>
+    public const int JsonNameFieldNumber = 10;
+    private readonly static string JsonNameDefaultValue = "";
+
+    private string jsonName_;
+    /// <summary>
+    /// JSON name of this field. The value is set by protocol compiler. If the
+    /// user has set a "json_name" option on this field, that option's value
+    /// will be used. Otherwise, it's deduced from the field's name by converting
+    /// it to camelCase.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string JsonName {
+      get { return jsonName_ ?? JsonNameDefaultValue; }
+      set {
+        jsonName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "json_name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJsonName {
+      get { return jsonName_ != null; }
+    }
+    /// <summary>Clears the value of the "json_name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJsonName() {
+      jsonName_ = null;
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 8;
+    private global::LC.Google.Protobuf.Reflection.FieldOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.FieldOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "proto3_optional" field.</summary>
+    public const int Proto3OptionalFieldNumber = 17;
+    private readonly static bool Proto3OptionalDefaultValue = false;
+
+    private bool proto3Optional_;
+    /// <summary>
+    /// If true, this is a proto3 "optional". When a proto3 field is optional, it
+    /// tracks presence regardless of field type.
+    ///
+    /// When proto3_optional is true, this field must be belong to a oneof to
+    /// signal to old proto3 clients that presence is tracked for this field. This
+    /// oneof is known as a "synthetic" oneof, and this field must be its sole
+    /// member (each proto3 optional field gets its own synthetic oneof). Synthetic
+    /// oneofs exist in the descriptor only, and do not generate any API. Synthetic
+    /// oneofs must be ordered after all "real" oneofs.
+    ///
+    /// For message fields, proto3_optional doesn't create any semantic change,
+    /// since non-repeated message fields always track presence. However it still
+    /// indicates the semantic detail of whether the user wrote "optional" or not.
+    /// This can be useful for round-tripping the .proto file. For consistency we
+    /// give message fields a synthetic oneof also, even though it is not required
+    /// to track presence. This is especially important because the parser can't
+    /// tell if a field is a message or an enum, so it must always create a
+    /// synthetic oneof.
+    ///
+    /// Proto2 optional fields do not set this flag, because they already indicate
+    /// optional with `LABEL_OPTIONAL`.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Proto3Optional {
+      get { if ((_hasBits0 & 16) != 0) { return proto3Optional_; } else { return Proto3OptionalDefaultValue; } }
+      set {
+        _hasBits0 |= 16;
+        proto3Optional_ = value;
+      }
+    }
+    /// <summary>Gets whether the "proto3_optional" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasProto3Optional {
+      get { return (_hasBits0 & 16) != 0; }
+    }
+    /// <summary>Clears the value of the "proto3_optional" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearProto3Optional() {
+      _hasBits0 &= ~16;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as FieldDescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(FieldDescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (Number != other.Number) return false;
+      if (Label != other.Label) return false;
+      if (Type != other.Type) return false;
+      if (TypeName != other.TypeName) return false;
+      if (Extendee != other.Extendee) return false;
+      if (DefaultValue != other.DefaultValue) return false;
+      if (OneofIndex != other.OneofIndex) return false;
+      if (JsonName != other.JsonName) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      if (Proto3Optional != other.Proto3Optional) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      if (HasNumber) hash ^= Number.GetHashCode();
+      if (HasLabel) hash ^= Label.GetHashCode();
+      if (HasType) hash ^= Type.GetHashCode();
+      if (HasTypeName) hash ^= TypeName.GetHashCode();
+      if (HasExtendee) hash ^= Extendee.GetHashCode();
+      if (HasDefaultValue) hash ^= DefaultValue.GetHashCode();
+      if (HasOneofIndex) hash ^= OneofIndex.GetHashCode();
+      if (HasJsonName) hash ^= JsonName.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      if (HasProto3Optional) hash ^= Proto3Optional.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasExtendee) {
+        output.WriteRawTag(18);
+        output.WriteString(Extendee);
+      }
+      if (HasNumber) {
+        output.WriteRawTag(24);
+        output.WriteInt32(Number);
+      }
+      if (HasLabel) {
+        output.WriteRawTag(32);
+        output.WriteEnum((int) Label);
+      }
+      if (HasType) {
+        output.WriteRawTag(40);
+        output.WriteEnum((int) Type);
+      }
+      if (HasTypeName) {
+        output.WriteRawTag(50);
+        output.WriteString(TypeName);
+      }
+      if (HasDefaultValue) {
+        output.WriteRawTag(58);
+        output.WriteString(DefaultValue);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(66);
+        output.WriteMessage(Options);
+      }
+      if (HasOneofIndex) {
+        output.WriteRawTag(72);
+        output.WriteInt32(OneofIndex);
+      }
+      if (HasJsonName) {
+        output.WriteRawTag(82);
+        output.WriteString(JsonName);
+      }
+      if (HasProto3Optional) {
+        output.WriteRawTag(136, 1);
+        output.WriteBool(Proto3Optional);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasExtendee) {
+        output.WriteRawTag(18);
+        output.WriteString(Extendee);
+      }
+      if (HasNumber) {
+        output.WriteRawTag(24);
+        output.WriteInt32(Number);
+      }
+      if (HasLabel) {
+        output.WriteRawTag(32);
+        output.WriteEnum((int) Label);
+      }
+      if (HasType) {
+        output.WriteRawTag(40);
+        output.WriteEnum((int) Type);
+      }
+      if (HasTypeName) {
+        output.WriteRawTag(50);
+        output.WriteString(TypeName);
+      }
+      if (HasDefaultValue) {
+        output.WriteRawTag(58);
+        output.WriteString(DefaultValue);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(66);
+        output.WriteMessage(Options);
+      }
+      if (HasOneofIndex) {
+        output.WriteRawTag(72);
+        output.WriteInt32(OneofIndex);
+      }
+      if (HasJsonName) {
+        output.WriteRawTag(82);
+        output.WriteString(JsonName);
+      }
+      if (HasProto3Optional) {
+        output.WriteRawTag(136, 1);
+        output.WriteBool(Proto3Optional);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (HasNumber) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Number);
+      }
+      if (HasLabel) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Label);
+      }
+      if (HasType) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type);
+      }
+      if (HasTypeName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(TypeName);
+      }
+      if (HasExtendee) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Extendee);
+      }
+      if (HasDefaultValue) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(DefaultValue);
+      }
+      if (HasOneofIndex) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(OneofIndex);
+      }
+      if (HasJsonName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(JsonName);
+      }
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      if (HasProto3Optional) {
+        size += 2 + 1;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(FieldDescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      if (other.HasNumber) {
+        Number = other.Number;
+      }
+      if (other.HasLabel) {
+        Label = other.Label;
+      }
+      if (other.HasType) {
+        Type = other.Type;
+      }
+      if (other.HasTypeName) {
+        TypeName = other.TypeName;
+      }
+      if (other.HasExtendee) {
+        Extendee = other.Extendee;
+      }
+      if (other.HasDefaultValue) {
+        DefaultValue = other.DefaultValue;
+      }
+      if (other.HasOneofIndex) {
+        OneofIndex = other.OneofIndex;
+      }
+      if (other.HasJsonName) {
+        JsonName = other.JsonName;
+      }
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.FieldOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      if (other.HasProto3Optional) {
+        Proto3Optional = other.Proto3Optional;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            Extendee = input.ReadString();
+            break;
+          }
+          case 24: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 32: {
+            Label = (global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Label) input.ReadEnum();
+            break;
+          }
+          case 40: {
+            Type = (global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Type) input.ReadEnum();
+            break;
+          }
+          case 50: {
+            TypeName = input.ReadString();
+            break;
+          }
+          case 58: {
+            DefaultValue = input.ReadString();
+            break;
+          }
+          case 66: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.FieldOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 72: {
+            OneofIndex = input.ReadInt32();
+            break;
+          }
+          case 82: {
+            JsonName = input.ReadString();
+            break;
+          }
+          case 136: {
+            Proto3Optional = input.ReadBool();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            Extendee = input.ReadString();
+            break;
+          }
+          case 24: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 32: {
+            Label = (global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Label) input.ReadEnum();
+            break;
+          }
+          case 40: {
+            Type = (global::LC.Google.Protobuf.Reflection.FieldDescriptorProto.Types.Type) input.ReadEnum();
+            break;
+          }
+          case 50: {
+            TypeName = input.ReadString();
+            break;
+          }
+          case 58: {
+            DefaultValue = input.ReadString();
+            break;
+          }
+          case 66: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.FieldOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 72: {
+            OneofIndex = input.ReadInt32();
+            break;
+          }
+          case 82: {
+            JsonName = input.ReadString();
+            break;
+          }
+          case 136: {
+            Proto3Optional = input.ReadBool();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the FieldDescriptorProto message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      public enum Type {
+        /// <summary>
+        /// 0 is reserved for errors.
+        /// Order is weird for historical reasons.
+        /// </summary>
+        [pbr::OriginalName("TYPE_DOUBLE")] Double = 1,
+        [pbr::OriginalName("TYPE_FLOAT")] Float = 2,
+        /// <summary>
+        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+        /// negative values are likely.
+        /// </summary>
+        [pbr::OriginalName("TYPE_INT64")] Int64 = 3,
+        [pbr::OriginalName("TYPE_UINT64")] Uint64 = 4,
+        /// <summary>
+        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+        /// negative values are likely.
+        /// </summary>
+        [pbr::OriginalName("TYPE_INT32")] Int32 = 5,
+        [pbr::OriginalName("TYPE_FIXED64")] Fixed64 = 6,
+        [pbr::OriginalName("TYPE_FIXED32")] Fixed32 = 7,
+        [pbr::OriginalName("TYPE_BOOL")] Bool = 8,
+        [pbr::OriginalName("TYPE_STRING")] String = 9,
+        /// <summary>
+        /// Tag-delimited aggregate.
+        /// Group type is deprecated and not supported in proto3. However, Proto3
+        /// implementations should still be able to parse the group wire format and
+        /// treat group fields as unknown fields.
+        /// </summary>
+        [pbr::OriginalName("TYPE_GROUP")] Group = 10,
+        /// <summary>
+        /// Length-delimited aggregate.
+        /// </summary>
+        [pbr::OriginalName("TYPE_MESSAGE")] Message = 11,
+        /// <summary>
+        /// New in version 2.
+        /// </summary>
+        [pbr::OriginalName("TYPE_BYTES")] Bytes = 12,
+        [pbr::OriginalName("TYPE_UINT32")] Uint32 = 13,
+        [pbr::OriginalName("TYPE_ENUM")] Enum = 14,
+        [pbr::OriginalName("TYPE_SFIXED32")] Sfixed32 = 15,
+        [pbr::OriginalName("TYPE_SFIXED64")] Sfixed64 = 16,
+        /// <summary>
+        /// Uses ZigZag encoding.
+        /// </summary>
+        [pbr::OriginalName("TYPE_SINT32")] Sint32 = 17,
+        /// <summary>
+        /// Uses ZigZag encoding.
+        /// </summary>
+        [pbr::OriginalName("TYPE_SINT64")] Sint64 = 18,
+      }
+
+      public enum Label {
+        /// <summary>
+        /// 0 is reserved for errors
+        /// </summary>
+        [pbr::OriginalName("LABEL_OPTIONAL")] Optional = 1,
+        [pbr::OriginalName("LABEL_REQUIRED")] Required = 2,
+        [pbr::OriginalName("LABEL_REPEATED")] Repeated = 3,
+      }
+
+    }
+    #endregion
+
+  }
+
+  /// <summary>
+  /// Describes a oneof.
+  /// </summary>
+  public sealed partial class OneofDescriptorProto : pb::IMessage<OneofDescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<OneofDescriptorProto> _parser = new pb::MessageParser<OneofDescriptorProto>(() => new OneofDescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<OneofDescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[5]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public OneofDescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public OneofDescriptorProto(OneofDescriptorProto other) : this() {
+      name_ = other.name_;
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public OneofDescriptorProto Clone() {
+      return new OneofDescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 2;
+    private global::LC.Google.Protobuf.Reflection.OneofOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.OneofOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as OneofDescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(OneofDescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(18);
+        output.WriteMessage(Options);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(18);
+        output.WriteMessage(Options);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(OneofDescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.OneofOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.OneofOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.OneofOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Describes an enum type.
+  /// </summary>
+  public sealed partial class EnumDescriptorProto : pb::IMessage<EnumDescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<EnumDescriptorProto> _parser = new pb::MessageParser<EnumDescriptorProto>(() => new EnumDescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<EnumDescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[6]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumDescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumDescriptorProto(EnumDescriptorProto other) : this() {
+      name_ = other.name_;
+      value_ = other.value_.Clone();
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      reservedRange_ = other.reservedRange_.Clone();
+      reservedName_ = other.reservedName_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumDescriptorProto Clone() {
+      return new EnumDescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.EnumValueDescriptorProto> _repeated_value_codec
+        = pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.Reflection.EnumValueDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumValueDescriptorProto> value_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumValueDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumValueDescriptorProto> Value {
+      get { return value_; }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 3;
+    private global::LC.Google.Protobuf.Reflection.EnumOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.EnumOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "reserved_range" field.</summary>
+    public const int ReservedRangeFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Types.EnumReservedRange> _repeated_reservedRange_codec
+        = pb::FieldCodec.ForMessage(34, global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Types.EnumReservedRange.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Types.EnumReservedRange> reservedRange_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Types.EnumReservedRange>();
+    /// <summary>
+    /// Range of reserved numeric values. Reserved numeric values may not be used
+    /// by enum values in the same enum declaration. Reserved ranges may not
+    /// overlap.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Types.EnumReservedRange> ReservedRange {
+      get { return reservedRange_; }
+    }
+
+    /// <summary>Field number for the "reserved_name" field.</summary>
+    public const int ReservedNameFieldNumber = 5;
+    private static readonly pb::FieldCodec<string> _repeated_reservedName_codec
+        = pb::FieldCodec.ForString(42);
+    private readonly pbc::RepeatedField<string> reservedName_ = new pbc::RepeatedField<string>();
+    /// <summary>
+    /// Reserved enum value names, which may not be reused. A given name may only
+    /// be reserved once.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<string> ReservedName {
+      get { return reservedName_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as EnumDescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(EnumDescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if(!value_.Equals(other.value_)) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      if(!reservedRange_.Equals(other.reservedRange_)) return false;
+      if(!reservedName_.Equals(other.reservedName_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      hash ^= value_.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      hash ^= reservedRange_.GetHashCode();
+      hash ^= reservedName_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      value_.WriteTo(output, _repeated_value_codec);
+      if (options_ != null) {
+        output.WriteRawTag(26);
+        output.WriteMessage(Options);
+      }
+      reservedRange_.WriteTo(output, _repeated_reservedRange_codec);
+      reservedName_.WriteTo(output, _repeated_reservedName_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      value_.WriteTo(ref output, _repeated_value_codec);
+      if (options_ != null) {
+        output.WriteRawTag(26);
+        output.WriteMessage(Options);
+      }
+      reservedRange_.WriteTo(ref output, _repeated_reservedRange_codec);
+      reservedName_.WriteTo(ref output, _repeated_reservedName_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      size += value_.CalculateSize(_repeated_value_codec);
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      size += reservedRange_.CalculateSize(_repeated_reservedRange_codec);
+      size += reservedName_.CalculateSize(_repeated_reservedName_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(EnumDescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      value_.Add(other.value_);
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.EnumOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      reservedRange_.Add(other.reservedRange_);
+      reservedName_.Add(other.reservedName_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            value_.AddEntriesFrom(input, _repeated_value_codec);
+            break;
+          }
+          case 26: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.EnumOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 34: {
+            reservedRange_.AddEntriesFrom(input, _repeated_reservedRange_codec);
+            break;
+          }
+          case 42: {
+            reservedName_.AddEntriesFrom(input, _repeated_reservedName_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            value_.AddEntriesFrom(ref input, _repeated_value_codec);
+            break;
+          }
+          case 26: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.EnumOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 34: {
+            reservedRange_.AddEntriesFrom(ref input, _repeated_reservedRange_codec);
+            break;
+          }
+          case 42: {
+            reservedName_.AddEntriesFrom(ref input, _repeated_reservedName_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the EnumDescriptorProto message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      /// <summary>
+      /// Range of reserved numeric values. Reserved values may not be used by
+      /// entries in the same enum. Reserved ranges may not overlap.
+      ///
+      /// Note that this is distinct from DescriptorProto.ReservedRange in that it
+      /// is inclusive such that it can appropriately represent the entire int32
+      /// domain.
+      /// </summary>
+      public sealed partial class EnumReservedRange : pb::IMessage<EnumReservedRange>
+      #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          , pb::IBufferMessage
+      #endif
+      {
+        private static readonly pb::MessageParser<EnumReservedRange> _parser = new pb::MessageParser<EnumReservedRange>(() => new EnumReservedRange());
+        private pb::UnknownFieldSet _unknownFields;
+        private int _hasBits0;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pb::MessageParser<EnumReservedRange> Parser { get { return _parser; } }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pbr::MessageDescriptor Descriptor {
+          get { return global::LC.Google.Protobuf.Reflection.EnumDescriptorProto.Descriptor.NestedTypes[0]; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        pbr::MessageDescriptor pb::IMessage.Descriptor {
+          get { return Descriptor; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public EnumReservedRange() {
+          OnConstruction();
+        }
+
+        partial void OnConstruction();
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public EnumReservedRange(EnumReservedRange other) : this() {
+          _hasBits0 = other._hasBits0;
+          start_ = other.start_;
+          end_ = other.end_;
+          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public EnumReservedRange Clone() {
+          return new EnumReservedRange(this);
+        }
+
+        /// <summary>Field number for the "start" field.</summary>
+        public const int StartFieldNumber = 1;
+        private readonly static int StartDefaultValue = 0;
+
+        private int start_;
+        /// <summary>
+        /// Inclusive.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int Start {
+          get { if ((_hasBits0 & 1) != 0) { return start_; } else { return StartDefaultValue; } }
+          set {
+            _hasBits0 |= 1;
+            start_ = value;
+          }
+        }
+        /// <summary>Gets whether the "start" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasStart {
+          get { return (_hasBits0 & 1) != 0; }
+        }
+        /// <summary>Clears the value of the "start" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearStart() {
+          _hasBits0 &= ~1;
+        }
+
+        /// <summary>Field number for the "end" field.</summary>
+        public const int EndFieldNumber = 2;
+        private readonly static int EndDefaultValue = 0;
+
+        private int end_;
+        /// <summary>
+        /// Inclusive.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int End {
+          get { if ((_hasBits0 & 2) != 0) { return end_; } else { return EndDefaultValue; } }
+          set {
+            _hasBits0 |= 2;
+            end_ = value;
+          }
+        }
+        /// <summary>Gets whether the "end" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasEnd {
+          get { return (_hasBits0 & 2) != 0; }
+        }
+        /// <summary>Clears the value of the "end" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearEnd() {
+          _hasBits0 &= ~2;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override bool Equals(object other) {
+          return Equals(other as EnumReservedRange);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool Equals(EnumReservedRange other) {
+          if (ReferenceEquals(other, null)) {
+            return false;
+          }
+          if (ReferenceEquals(other, this)) {
+            return true;
+          }
+          if (Start != other.Start) return false;
+          if (End != other.End) return false;
+          return Equals(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override int GetHashCode() {
+          int hash = 1;
+          if (HasStart) hash ^= Start.GetHashCode();
+          if (HasEnd) hash ^= End.GetHashCode();
+          if (_unknownFields != null) {
+            hash ^= _unknownFields.GetHashCode();
+          }
+          return hash;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override string ToString() {
+          return pb::JsonFormatter.ToDiagnosticString(this);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void WriteTo(pb::CodedOutputStream output) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          output.WriteRawMessage(this);
+        #else
+          if (HasStart) {
+            output.WriteRawTag(8);
+            output.WriteInt32(Start);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(16);
+            output.WriteInt32(End);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(output);
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+          if (HasStart) {
+            output.WriteRawTag(8);
+            output.WriteInt32(Start);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(16);
+            output.WriteInt32(End);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(ref output);
+          }
+        }
+        #endif
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int CalculateSize() {
+          int size = 0;
+          if (HasStart) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Start);
+          }
+          if (HasEnd) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
+          }
+          if (_unknownFields != null) {
+            size += _unknownFields.CalculateSize();
+          }
+          return size;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(EnumReservedRange other) {
+          if (other == null) {
+            return;
+          }
+          if (other.HasStart) {
+            Start = other.Start;
+          }
+          if (other.HasEnd) {
+            End = other.End;
+          }
+          _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(pb::CodedInputStream input) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          input.ReadRawMessage(this);
+        #else
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+                break;
+              case 8: {
+                Start = input.ReadInt32();
+                break;
+              }
+              case 16: {
+                End = input.ReadInt32();
+                break;
+              }
+            }
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+                break;
+              case 8: {
+                Start = input.ReadInt32();
+                break;
+              }
+              case 16: {
+                End = input.ReadInt32();
+                break;
+              }
+            }
+          }
+        }
+        #endif
+
+      }
+
+    }
+    #endregion
+
+  }
+
+  /// <summary>
+  /// Describes a value within an enum.
+  /// </summary>
+  public sealed partial class EnumValueDescriptorProto : pb::IMessage<EnumValueDescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<EnumValueDescriptorProto> _parser = new pb::MessageParser<EnumValueDescriptorProto>(() => new EnumValueDescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<EnumValueDescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[7]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValueDescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValueDescriptorProto(EnumValueDescriptorProto other) : this() {
+      _hasBits0 = other._hasBits0;
+      name_ = other.name_;
+      number_ = other.number_;
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValueDescriptorProto Clone() {
+      return new EnumValueDescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "number" field.</summary>
+    public const int NumberFieldNumber = 2;
+    private readonly static int NumberDefaultValue = 0;
+
+    private int number_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int Number {
+      get { if ((_hasBits0 & 1) != 0) { return number_; } else { return NumberDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        number_ = value;
+      }
+    }
+    /// <summary>Gets whether the "number" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasNumber {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "number" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearNumber() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 3;
+    private global::LC.Google.Protobuf.Reflection.EnumValueOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.EnumValueOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as EnumValueDescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(EnumValueDescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (Number != other.Number) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      if (HasNumber) hash ^= Number.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasNumber) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Number);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(26);
+        output.WriteMessage(Options);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasNumber) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Number);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(26);
+        output.WriteMessage(Options);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (HasNumber) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Number);
+      }
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(EnumValueDescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      if (other.HasNumber) {
+        Number = other.Number;
+      }
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.EnumValueOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 16: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 26: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.EnumValueOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 16: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 26: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.EnumValueOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Describes a service.
+  /// </summary>
+  public sealed partial class ServiceDescriptorProto : pb::IMessage<ServiceDescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<ServiceDescriptorProto> _parser = new pb::MessageParser<ServiceDescriptorProto>(() => new ServiceDescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<ServiceDescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[8]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ServiceDescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ServiceDescriptorProto(ServiceDescriptorProto other) : this() {
+      name_ = other.name_;
+      method_ = other.method_.Clone();
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ServiceDescriptorProto Clone() {
+      return new ServiceDescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "method" field.</summary>
+    public const int MethodFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.MethodDescriptorProto> _repeated_method_codec
+        = pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.Reflection.MethodDescriptorProto.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.MethodDescriptorProto> method_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.MethodDescriptorProto>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.MethodDescriptorProto> Method {
+      get { return method_; }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 3;
+    private global::LC.Google.Protobuf.Reflection.ServiceOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.ServiceOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as ServiceDescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(ServiceDescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if(!method_.Equals(other.method_)) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      hash ^= method_.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      method_.WriteTo(output, _repeated_method_codec);
+      if (options_ != null) {
+        output.WriteRawTag(26);
+        output.WriteMessage(Options);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      method_.WriteTo(ref output, _repeated_method_codec);
+      if (options_ != null) {
+        output.WriteRawTag(26);
+        output.WriteMessage(Options);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      size += method_.CalculateSize(_repeated_method_codec);
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(ServiceDescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      method_.Add(other.method_);
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.ServiceOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            method_.AddEntriesFrom(input, _repeated_method_codec);
+            break;
+          }
+          case 26: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.ServiceOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            method_.AddEntriesFrom(ref input, _repeated_method_codec);
+            break;
+          }
+          case 26: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.ServiceOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Describes a method of a service.
+  /// </summary>
+  public sealed partial class MethodDescriptorProto : pb::IMessage<MethodDescriptorProto>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<MethodDescriptorProto> _parser = new pb::MessageParser<MethodDescriptorProto>(() => new MethodDescriptorProto());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<MethodDescriptorProto> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[9]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MethodDescriptorProto() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MethodDescriptorProto(MethodDescriptorProto other) : this() {
+      _hasBits0 = other._hasBits0;
+      name_ = other.name_;
+      inputType_ = other.inputType_;
+      outputType_ = other.outputType_;
+      options_ = other.options_ != null ? other.options_.Clone() : null;
+      clientStreaming_ = other.clientStreaming_;
+      serverStreaming_ = other.serverStreaming_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MethodDescriptorProto Clone() {
+      return new MethodDescriptorProto(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private readonly static string NameDefaultValue = "";
+
+    private string name_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_ ?? NameDefaultValue; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "name" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasName {
+      get { return name_ != null; }
+    }
+    /// <summary>Clears the value of the "name" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearName() {
+      name_ = null;
+    }
+
+    /// <summary>Field number for the "input_type" field.</summary>
+    public const int InputTypeFieldNumber = 2;
+    private readonly static string InputTypeDefaultValue = "";
+
+    private string inputType_;
+    /// <summary>
+    /// Input and output type names.  These are resolved in the same way as
+    /// FieldDescriptorProto.type_name, but must refer to a message type.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string InputType {
+      get { return inputType_ ?? InputTypeDefaultValue; }
+      set {
+        inputType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "input_type" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasInputType {
+      get { return inputType_ != null; }
+    }
+    /// <summary>Clears the value of the "input_type" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearInputType() {
+      inputType_ = null;
+    }
+
+    /// <summary>Field number for the "output_type" field.</summary>
+    public const int OutputTypeFieldNumber = 3;
+    private readonly static string OutputTypeDefaultValue = "";
+
+    private string outputType_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string OutputType {
+      get { return outputType_ ?? OutputTypeDefaultValue; }
+      set {
+        outputType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "output_type" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasOutputType {
+      get { return outputType_ != null; }
+    }
+    /// <summary>Clears the value of the "output_type" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearOutputType() {
+      outputType_ = null;
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 4;
+    private global::LC.Google.Protobuf.Reflection.MethodOptions options_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.MethodOptions Options {
+      get { return options_; }
+      set {
+        options_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "client_streaming" field.</summary>
+    public const int ClientStreamingFieldNumber = 5;
+    private readonly static bool ClientStreamingDefaultValue = false;
+
+    private bool clientStreaming_;
+    /// <summary>
+    /// Identifies if client streams multiple client messages
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool ClientStreaming {
+      get { if ((_hasBits0 & 1) != 0) { return clientStreaming_; } else { return ClientStreamingDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        clientStreaming_ = value;
+      }
+    }
+    /// <summary>Gets whether the "client_streaming" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasClientStreaming {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "client_streaming" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearClientStreaming() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "server_streaming" field.</summary>
+    public const int ServerStreamingFieldNumber = 6;
+    private readonly static bool ServerStreamingDefaultValue = false;
+
+    private bool serverStreaming_;
+    /// <summary>
+    /// Identifies if server streams multiple server messages
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool ServerStreaming {
+      get { if ((_hasBits0 & 2) != 0) { return serverStreaming_; } else { return ServerStreamingDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        serverStreaming_ = value;
+      }
+    }
+    /// <summary>Gets whether the "server_streaming" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasServerStreaming {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "server_streaming" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearServerStreaming() {
+      _hasBits0 &= ~2;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as MethodDescriptorProto);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(MethodDescriptorProto other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (InputType != other.InputType) return false;
+      if (OutputType != other.OutputType) return false;
+      if (!object.Equals(Options, other.Options)) return false;
+      if (ClientStreaming != other.ClientStreaming) return false;
+      if (ServerStreaming != other.ServerStreaming) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasName) hash ^= Name.GetHashCode();
+      if (HasInputType) hash ^= InputType.GetHashCode();
+      if (HasOutputType) hash ^= OutputType.GetHashCode();
+      if (options_ != null) hash ^= Options.GetHashCode();
+      if (HasClientStreaming) hash ^= ClientStreaming.GetHashCode();
+      if (HasServerStreaming) hash ^= ServerStreaming.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasInputType) {
+        output.WriteRawTag(18);
+        output.WriteString(InputType);
+      }
+      if (HasOutputType) {
+        output.WriteRawTag(26);
+        output.WriteString(OutputType);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(34);
+        output.WriteMessage(Options);
+      }
+      if (HasClientStreaming) {
+        output.WriteRawTag(40);
+        output.WriteBool(ClientStreaming);
+      }
+      if (HasServerStreaming) {
+        output.WriteRawTag(48);
+        output.WriteBool(ServerStreaming);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasName) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (HasInputType) {
+        output.WriteRawTag(18);
+        output.WriteString(InputType);
+      }
+      if (HasOutputType) {
+        output.WriteRawTag(26);
+        output.WriteString(OutputType);
+      }
+      if (options_ != null) {
+        output.WriteRawTag(34);
+        output.WriteMessage(Options);
+      }
+      if (HasClientStreaming) {
+        output.WriteRawTag(40);
+        output.WriteBool(ClientStreaming);
+      }
+      if (HasServerStreaming) {
+        output.WriteRawTag(48);
+        output.WriteBool(ServerStreaming);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasName) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (HasInputType) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(InputType);
+      }
+      if (HasOutputType) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(OutputType);
+      }
+      if (options_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
+      }
+      if (HasClientStreaming) {
+        size += 1 + 1;
+      }
+      if (HasServerStreaming) {
+        size += 1 + 1;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(MethodDescriptorProto other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasName) {
+        Name = other.Name;
+      }
+      if (other.HasInputType) {
+        InputType = other.InputType;
+      }
+      if (other.HasOutputType) {
+        OutputType = other.OutputType;
+      }
+      if (other.options_ != null) {
+        if (options_ == null) {
+          Options = new global::LC.Google.Protobuf.Reflection.MethodOptions();
+        }
+        Options.MergeFrom(other.Options);
+      }
+      if (other.HasClientStreaming) {
+        ClientStreaming = other.ClientStreaming;
+      }
+      if (other.HasServerStreaming) {
+        ServerStreaming = other.ServerStreaming;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            InputType = input.ReadString();
+            break;
+          }
+          case 26: {
+            OutputType = input.ReadString();
+            break;
+          }
+          case 34: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.MethodOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 40: {
+            ClientStreaming = input.ReadBool();
+            break;
+          }
+          case 48: {
+            ServerStreaming = input.ReadBool();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            InputType = input.ReadString();
+            break;
+          }
+          case 26: {
+            OutputType = input.ReadString();
+            break;
+          }
+          case 34: {
+            if (options_ == null) {
+              Options = new global::LC.Google.Protobuf.Reflection.MethodOptions();
+            }
+            input.ReadMessage(Options);
+            break;
+          }
+          case 40: {
+            ClientStreaming = input.ReadBool();
+            break;
+          }
+          case 48: {
+            ServerStreaming = input.ReadBool();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  public sealed partial class FileOptions : pb::IExtendableMessage<FileOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FileOptions> _parser = new pb::MessageParser<FileOptions>(() => new FileOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<FileOptions> _extensions;
+    private pb::ExtensionSet<FileOptions> _Extensions { get { return _extensions; } }
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<FileOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[10]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileOptions(FileOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      javaPackage_ = other.javaPackage_;
+      javaOuterClassname_ = other.javaOuterClassname_;
+      javaMultipleFiles_ = other.javaMultipleFiles_;
+      javaGenerateEqualsAndHash_ = other.javaGenerateEqualsAndHash_;
+      javaStringCheckUtf8_ = other.javaStringCheckUtf8_;
+      optimizeFor_ = other.optimizeFor_;
+      goPackage_ = other.goPackage_;
+      ccGenericServices_ = other.ccGenericServices_;
+      javaGenericServices_ = other.javaGenericServices_;
+      pyGenericServices_ = other.pyGenericServices_;
+      phpGenericServices_ = other.phpGenericServices_;
+      deprecated_ = other.deprecated_;
+      ccEnableArenas_ = other.ccEnableArenas_;
+      objcClassPrefix_ = other.objcClassPrefix_;
+      csharpNamespace_ = other.csharpNamespace_;
+      swiftPrefix_ = other.swiftPrefix_;
+      phpClassPrefix_ = other.phpClassPrefix_;
+      phpNamespace_ = other.phpNamespace_;
+      phpMetadataNamespace_ = other.phpMetadataNamespace_;
+      rubyPackage_ = other.rubyPackage_;
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FileOptions Clone() {
+      return new FileOptions(this);
+    }
+
+    /// <summary>Field number for the "java_package" field.</summary>
+    public const int JavaPackageFieldNumber = 1;
+    private readonly static string JavaPackageDefaultValue = "";
+
+    private string javaPackage_;
+    /// <summary>
+    /// Sets the Java package where classes generated from this .proto will be
+    /// placed.  By default, the proto package is used, but this is often
+    /// inappropriate because proto packages do not normally start with backwards
+    /// domain names.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string JavaPackage {
+      get { return javaPackage_ ?? JavaPackageDefaultValue; }
+      set {
+        javaPackage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "java_package" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJavaPackage {
+      get { return javaPackage_ != null; }
+    }
+    /// <summary>Clears the value of the "java_package" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJavaPackage() {
+      javaPackage_ = null;
+    }
+
+    /// <summary>Field number for the "java_outer_classname" field.</summary>
+    public const int JavaOuterClassnameFieldNumber = 8;
+    private readonly static string JavaOuterClassnameDefaultValue = "";
+
+    private string javaOuterClassname_;
+    /// <summary>
+    /// If set, all the classes from the .proto file are wrapped in a single
+    /// outer class with the given name.  This applies to both Proto1
+    /// (equivalent to the old "--one_java_file" option) and Proto2 (where
+    /// a .proto always translates to a single class, but you may want to
+    /// explicitly choose the class name).
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string JavaOuterClassname {
+      get { return javaOuterClassname_ ?? JavaOuterClassnameDefaultValue; }
+      set {
+        javaOuterClassname_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "java_outer_classname" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJavaOuterClassname {
+      get { return javaOuterClassname_ != null; }
+    }
+    /// <summary>Clears the value of the "java_outer_classname" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJavaOuterClassname() {
+      javaOuterClassname_ = null;
+    }
+
+    /// <summary>Field number for the "java_multiple_files" field.</summary>
+    public const int JavaMultipleFilesFieldNumber = 10;
+    private readonly static bool JavaMultipleFilesDefaultValue = false;
+
+    private bool javaMultipleFiles_;
+    /// <summary>
+    /// If set true, then the Java code generator will generate a separate .java
+    /// file for each top-level message, enum, and service defined in the .proto
+    /// file.  Thus, these types will *not* be nested inside the outer class
+    /// named by java_outer_classname.  However, the outer class will still be
+    /// generated to contain the file's getDescriptor() method as well as any
+    /// top-level extensions defined in the file.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool JavaMultipleFiles {
+      get { if ((_hasBits0 & 2) != 0) { return javaMultipleFiles_; } else { return JavaMultipleFilesDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        javaMultipleFiles_ = value;
+      }
+    }
+    /// <summary>Gets whether the "java_multiple_files" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJavaMultipleFiles {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "java_multiple_files" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJavaMultipleFiles() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "java_generate_equals_and_hash" field.</summary>
+    public const int JavaGenerateEqualsAndHashFieldNumber = 20;
+    private readonly static bool JavaGenerateEqualsAndHashDefaultValue = false;
+
+    private bool javaGenerateEqualsAndHash_;
+    /// <summary>
+    /// This option does nothing.
+    /// </summary>
+    [global::System.ObsoleteAttribute]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool JavaGenerateEqualsAndHash {
+      get { if ((_hasBits0 & 32) != 0) { return javaGenerateEqualsAndHash_; } else { return JavaGenerateEqualsAndHashDefaultValue; } }
+      set {
+        _hasBits0 |= 32;
+        javaGenerateEqualsAndHash_ = value;
+      }
+    }
+    /// <summary>Gets whether the "java_generate_equals_and_hash" field is set</summary>
+    [global::System.ObsoleteAttribute]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJavaGenerateEqualsAndHash {
+      get { return (_hasBits0 & 32) != 0; }
+    }
+    /// <summary>Clears the value of the "java_generate_equals_and_hash" field</summary>
+    [global::System.ObsoleteAttribute]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJavaGenerateEqualsAndHash() {
+      _hasBits0 &= ~32;
+    }
+
+    /// <summary>Field number for the "java_string_check_utf8" field.</summary>
+    public const int JavaStringCheckUtf8FieldNumber = 27;
+    private readonly static bool JavaStringCheckUtf8DefaultValue = false;
+
+    private bool javaStringCheckUtf8_;
+    /// <summary>
+    /// If set true, then the Java2 code generator will generate code that
+    /// throws an exception whenever an attempt is made to assign a non-UTF-8
+    /// byte sequence to a string field.
+    /// Message reflection will do the same.
+    /// However, an extension field still accepts non-UTF-8 byte sequences.
+    /// This option has no effect on when used with the lite runtime.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool JavaStringCheckUtf8 {
+      get { if ((_hasBits0 & 128) != 0) { return javaStringCheckUtf8_; } else { return JavaStringCheckUtf8DefaultValue; } }
+      set {
+        _hasBits0 |= 128;
+        javaStringCheckUtf8_ = value;
+      }
+    }
+    /// <summary>Gets whether the "java_string_check_utf8" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJavaStringCheckUtf8 {
+      get { return (_hasBits0 & 128) != 0; }
+    }
+    /// <summary>Clears the value of the "java_string_check_utf8" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJavaStringCheckUtf8() {
+      _hasBits0 &= ~128;
+    }
+
+    /// <summary>Field number for the "optimize_for" field.</summary>
+    public const int OptimizeForFieldNumber = 9;
+    private readonly static global::LC.Google.Protobuf.Reflection.FileOptions.Types.OptimizeMode OptimizeForDefaultValue = global::LC.Google.Protobuf.Reflection.FileOptions.Types.OptimizeMode.Speed;
+
+    private global::LC.Google.Protobuf.Reflection.FileOptions.Types.OptimizeMode optimizeFor_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.FileOptions.Types.OptimizeMode OptimizeFor {
+      get { if ((_hasBits0 & 1) != 0) { return optimizeFor_; } else { return OptimizeForDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        optimizeFor_ = value;
+      }
+    }
+    /// <summary>Gets whether the "optimize_for" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasOptimizeFor {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "optimize_for" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearOptimizeFor() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "go_package" field.</summary>
+    public const int GoPackageFieldNumber = 11;
+    private readonly static string GoPackageDefaultValue = "";
+
+    private string goPackage_;
+    /// <summary>
+    /// Sets the Go package where structs generated from this .proto will be
+    /// placed. If omitted, the Go package will be derived from the following:
+    ///   - The basename of the package import path, if provided.
+    ///   - Otherwise, the package statement in the .proto file, if present.
+    ///   - Otherwise, the basename of the .proto file, without extension.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string GoPackage {
+      get { return goPackage_ ?? GoPackageDefaultValue; }
+      set {
+        goPackage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "go_package" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasGoPackage {
+      get { return goPackage_ != null; }
+    }
+    /// <summary>Clears the value of the "go_package" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearGoPackage() {
+      goPackage_ = null;
+    }
+
+    /// <summary>Field number for the "cc_generic_services" field.</summary>
+    public const int CcGenericServicesFieldNumber = 16;
+    private readonly static bool CcGenericServicesDefaultValue = false;
+
+    private bool ccGenericServices_;
+    /// <summary>
+    /// Should generic services be generated in each language?  "Generic" services
+    /// are not specific to any particular RPC system.  They are generated by the
+    /// main code generators in each language (without additional plugins).
+    /// Generic services were the only kind of service generation supported by
+    /// early versions of google.protobuf.
+    ///
+    /// Generic services are now considered deprecated in favor of using plugins
+    /// that generate code specific to your particular RPC system.  Therefore,
+    /// these default to false.  Old code which depends on generic services should
+    /// explicitly set them to true.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool CcGenericServices {
+      get { if ((_hasBits0 & 4) != 0) { return ccGenericServices_; } else { return CcGenericServicesDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        ccGenericServices_ = value;
+      }
+    }
+    /// <summary>Gets whether the "cc_generic_services" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasCcGenericServices {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "cc_generic_services" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearCcGenericServices() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "java_generic_services" field.</summary>
+    public const int JavaGenericServicesFieldNumber = 17;
+    private readonly static bool JavaGenericServicesDefaultValue = false;
+
+    private bool javaGenericServices_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool JavaGenericServices {
+      get { if ((_hasBits0 & 8) != 0) { return javaGenericServices_; } else { return JavaGenericServicesDefaultValue; } }
+      set {
+        _hasBits0 |= 8;
+        javaGenericServices_ = value;
+      }
+    }
+    /// <summary>Gets whether the "java_generic_services" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJavaGenericServices {
+      get { return (_hasBits0 & 8) != 0; }
+    }
+    /// <summary>Clears the value of the "java_generic_services" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJavaGenericServices() {
+      _hasBits0 &= ~8;
+    }
+
+    /// <summary>Field number for the "py_generic_services" field.</summary>
+    public const int PyGenericServicesFieldNumber = 18;
+    private readonly static bool PyGenericServicesDefaultValue = false;
+
+    private bool pyGenericServices_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool PyGenericServices {
+      get { if ((_hasBits0 & 16) != 0) { return pyGenericServices_; } else { return PyGenericServicesDefaultValue; } }
+      set {
+        _hasBits0 |= 16;
+        pyGenericServices_ = value;
+      }
+    }
+    /// <summary>Gets whether the "py_generic_services" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPyGenericServices {
+      get { return (_hasBits0 & 16) != 0; }
+    }
+    /// <summary>Clears the value of the "py_generic_services" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPyGenericServices() {
+      _hasBits0 &= ~16;
+    }
+
+    /// <summary>Field number for the "php_generic_services" field.</summary>
+    public const int PhpGenericServicesFieldNumber = 42;
+    private readonly static bool PhpGenericServicesDefaultValue = false;
+
+    private bool phpGenericServices_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool PhpGenericServices {
+      get { if ((_hasBits0 & 512) != 0) { return phpGenericServices_; } else { return PhpGenericServicesDefaultValue; } }
+      set {
+        _hasBits0 |= 512;
+        phpGenericServices_ = value;
+      }
+    }
+    /// <summary>Gets whether the "php_generic_services" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPhpGenericServices {
+      get { return (_hasBits0 & 512) != 0; }
+    }
+    /// <summary>Clears the value of the "php_generic_services" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPhpGenericServices() {
+      _hasBits0 &= ~512;
+    }
+
+    /// <summary>Field number for the "deprecated" field.</summary>
+    public const int DeprecatedFieldNumber = 23;
+    private readonly static bool DeprecatedDefaultValue = false;
+
+    private bool deprecated_;
+    /// <summary>
+    /// Is this file deprecated?
+    /// Depending on the target platform, this can emit Deprecated annotations
+    /// for everything in the file, or it will be completely ignored; in the very
+    /// least, this is a formalization for deprecating files.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Deprecated {
+      get { if ((_hasBits0 & 64) != 0) { return deprecated_; } else { return DeprecatedDefaultValue; } }
+      set {
+        _hasBits0 |= 64;
+        deprecated_ = value;
+      }
+    }
+    /// <summary>Gets whether the "deprecated" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDeprecated {
+      get { return (_hasBits0 & 64) != 0; }
+    }
+    /// <summary>Clears the value of the "deprecated" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDeprecated() {
+      _hasBits0 &= ~64;
+    }
+
+    /// <summary>Field number for the "cc_enable_arenas" field.</summary>
+    public const int CcEnableArenasFieldNumber = 31;
+    private readonly static bool CcEnableArenasDefaultValue = true;
+
+    private bool ccEnableArenas_;
+    /// <summary>
+    /// Enables the use of arenas for the proto messages in this file. This applies
+    /// only to generated classes for C++.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool CcEnableArenas {
+      get { if ((_hasBits0 & 256) != 0) { return ccEnableArenas_; } else { return CcEnableArenasDefaultValue; } }
+      set {
+        _hasBits0 |= 256;
+        ccEnableArenas_ = value;
+      }
+    }
+    /// <summary>Gets whether the "cc_enable_arenas" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasCcEnableArenas {
+      get { return (_hasBits0 & 256) != 0; }
+    }
+    /// <summary>Clears the value of the "cc_enable_arenas" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearCcEnableArenas() {
+      _hasBits0 &= ~256;
+    }
+
+    /// <summary>Field number for the "objc_class_prefix" field.</summary>
+    public const int ObjcClassPrefixFieldNumber = 36;
+    private readonly static string ObjcClassPrefixDefaultValue = "";
+
+    private string objcClassPrefix_;
+    /// <summary>
+    /// Sets the objective c class prefix which is prepended to all objective c
+    /// generated classes from this .proto. There is no default.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string ObjcClassPrefix {
+      get { return objcClassPrefix_ ?? ObjcClassPrefixDefaultValue; }
+      set {
+        objcClassPrefix_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "objc_class_prefix" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasObjcClassPrefix {
+      get { return objcClassPrefix_ != null; }
+    }
+    /// <summary>Clears the value of the "objc_class_prefix" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearObjcClassPrefix() {
+      objcClassPrefix_ = null;
+    }
+
+    /// <summary>Field number for the "csharp_namespace" field.</summary>
+    public const int CsharpNamespaceFieldNumber = 37;
+    private readonly static string CsharpNamespaceDefaultValue = "";
+
+    private string csharpNamespace_;
+    /// <summary>
+    /// Namespace for generated classes; defaults to the package.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string CsharpNamespace {
+      get { return csharpNamespace_ ?? CsharpNamespaceDefaultValue; }
+      set {
+        csharpNamespace_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "csharp_namespace" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasCsharpNamespace {
+      get { return csharpNamespace_ != null; }
+    }
+    /// <summary>Clears the value of the "csharp_namespace" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearCsharpNamespace() {
+      csharpNamespace_ = null;
+    }
+
+    /// <summary>Field number for the "swift_prefix" field.</summary>
+    public const int SwiftPrefixFieldNumber = 39;
+    private readonly static string SwiftPrefixDefaultValue = "";
+
+    private string swiftPrefix_;
+    /// <summary>
+    /// By default Swift generators will take the proto package and CamelCase it
+    /// replacing '.' with underscore and use that to prefix the types/symbols
+    /// defined. When this options is provided, they will use this value instead
+    /// to prefix the types/symbols defined.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string SwiftPrefix {
+      get { return swiftPrefix_ ?? SwiftPrefixDefaultValue; }
+      set {
+        swiftPrefix_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "swift_prefix" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasSwiftPrefix {
+      get { return swiftPrefix_ != null; }
+    }
+    /// <summary>Clears the value of the "swift_prefix" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearSwiftPrefix() {
+      swiftPrefix_ = null;
+    }
+
+    /// <summary>Field number for the "php_class_prefix" field.</summary>
+    public const int PhpClassPrefixFieldNumber = 40;
+    private readonly static string PhpClassPrefixDefaultValue = "";
+
+    private string phpClassPrefix_;
+    /// <summary>
+    /// Sets the php class prefix which is prepended to all php generated classes
+    /// from this .proto. Default is empty.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string PhpClassPrefix {
+      get { return phpClassPrefix_ ?? PhpClassPrefixDefaultValue; }
+      set {
+        phpClassPrefix_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "php_class_prefix" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPhpClassPrefix {
+      get { return phpClassPrefix_ != null; }
+    }
+    /// <summary>Clears the value of the "php_class_prefix" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPhpClassPrefix() {
+      phpClassPrefix_ = null;
+    }
+
+    /// <summary>Field number for the "php_namespace" field.</summary>
+    public const int PhpNamespaceFieldNumber = 41;
+    private readonly static string PhpNamespaceDefaultValue = "";
+
+    private string phpNamespace_;
+    /// <summary>
+    /// Use this option to change the namespace of php generated classes. Default
+    /// is empty. When this option is empty, the package name will be used for
+    /// determining the namespace.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string PhpNamespace {
+      get { return phpNamespace_ ?? PhpNamespaceDefaultValue; }
+      set {
+        phpNamespace_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "php_namespace" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPhpNamespace {
+      get { return phpNamespace_ != null; }
+    }
+    /// <summary>Clears the value of the "php_namespace" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPhpNamespace() {
+      phpNamespace_ = null;
+    }
+
+    /// <summary>Field number for the "php_metadata_namespace" field.</summary>
+    public const int PhpMetadataNamespaceFieldNumber = 44;
+    private readonly static string PhpMetadataNamespaceDefaultValue = "";
+
+    private string phpMetadataNamespace_;
+    /// <summary>
+    /// Use this option to change the namespace of php generated metadata classes.
+    /// Default is empty. When this option is empty, the proto file name will be
+    /// used for determining the namespace.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string PhpMetadataNamespace {
+      get { return phpMetadataNamespace_ ?? PhpMetadataNamespaceDefaultValue; }
+      set {
+        phpMetadataNamespace_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "php_metadata_namespace" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPhpMetadataNamespace {
+      get { return phpMetadataNamespace_ != null; }
+    }
+    /// <summary>Clears the value of the "php_metadata_namespace" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPhpMetadataNamespace() {
+      phpMetadataNamespace_ = null;
+    }
+
+    /// <summary>Field number for the "ruby_package" field.</summary>
+    public const int RubyPackageFieldNumber = 45;
+    private readonly static string RubyPackageDefaultValue = "";
+
+    private string rubyPackage_;
+    /// <summary>
+    /// Use this option to change the package of ruby generated classes. Default
+    /// is empty. When this option is not set, the package name will be used for
+    /// determining the ruby package.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string RubyPackage {
+      get { return rubyPackage_ ?? RubyPackageDefaultValue; }
+      set {
+        rubyPackage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "ruby_package" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasRubyPackage {
+      get { return rubyPackage_ != null; }
+    }
+    /// <summary>Clears the value of the "ruby_package" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearRubyPackage() {
+      rubyPackage_ = null;
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here.
+    /// See the documentation for the "Options" section above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as FileOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(FileOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (JavaPackage != other.JavaPackage) return false;
+      if (JavaOuterClassname != other.JavaOuterClassname) return false;
+      if (JavaMultipleFiles != other.JavaMultipleFiles) return false;
+      if (JavaGenerateEqualsAndHash != other.JavaGenerateEqualsAndHash) return false;
+      if (JavaStringCheckUtf8 != other.JavaStringCheckUtf8) return false;
+      if (OptimizeFor != other.OptimizeFor) return false;
+      if (GoPackage != other.GoPackage) return false;
+      if (CcGenericServices != other.CcGenericServices) return false;
+      if (JavaGenericServices != other.JavaGenericServices) return false;
+      if (PyGenericServices != other.PyGenericServices) return false;
+      if (PhpGenericServices != other.PhpGenericServices) return false;
+      if (Deprecated != other.Deprecated) return false;
+      if (CcEnableArenas != other.CcEnableArenas) return false;
+      if (ObjcClassPrefix != other.ObjcClassPrefix) return false;
+      if (CsharpNamespace != other.CsharpNamespace) return false;
+      if (SwiftPrefix != other.SwiftPrefix) return false;
+      if (PhpClassPrefix != other.PhpClassPrefix) return false;
+      if (PhpNamespace != other.PhpNamespace) return false;
+      if (PhpMetadataNamespace != other.PhpMetadataNamespace) return false;
+      if (RubyPackage != other.RubyPackage) return false;
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasJavaPackage) hash ^= JavaPackage.GetHashCode();
+      if (HasJavaOuterClassname) hash ^= JavaOuterClassname.GetHashCode();
+      if (HasJavaMultipleFiles) hash ^= JavaMultipleFiles.GetHashCode();
+      if (HasJavaGenerateEqualsAndHash) hash ^= JavaGenerateEqualsAndHash.GetHashCode();
+      if (HasJavaStringCheckUtf8) hash ^= JavaStringCheckUtf8.GetHashCode();
+      if (HasOptimizeFor) hash ^= OptimizeFor.GetHashCode();
+      if (HasGoPackage) hash ^= GoPackage.GetHashCode();
+      if (HasCcGenericServices) hash ^= CcGenericServices.GetHashCode();
+      if (HasJavaGenericServices) hash ^= JavaGenericServices.GetHashCode();
+      if (HasPyGenericServices) hash ^= PyGenericServices.GetHashCode();
+      if (HasPhpGenericServices) hash ^= PhpGenericServices.GetHashCode();
+      if (HasDeprecated) hash ^= Deprecated.GetHashCode();
+      if (HasCcEnableArenas) hash ^= CcEnableArenas.GetHashCode();
+      if (HasObjcClassPrefix) hash ^= ObjcClassPrefix.GetHashCode();
+      if (HasCsharpNamespace) hash ^= CsharpNamespace.GetHashCode();
+      if (HasSwiftPrefix) hash ^= SwiftPrefix.GetHashCode();
+      if (HasPhpClassPrefix) hash ^= PhpClassPrefix.GetHashCode();
+      if (HasPhpNamespace) hash ^= PhpNamespace.GetHashCode();
+      if (HasPhpMetadataNamespace) hash ^= PhpMetadataNamespace.GetHashCode();
+      if (HasRubyPackage) hash ^= RubyPackage.GetHashCode();
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasJavaPackage) {
+        output.WriteRawTag(10);
+        output.WriteString(JavaPackage);
+      }
+      if (HasJavaOuterClassname) {
+        output.WriteRawTag(66);
+        output.WriteString(JavaOuterClassname);
+      }
+      if (HasOptimizeFor) {
+        output.WriteRawTag(72);
+        output.WriteEnum((int) OptimizeFor);
+      }
+      if (HasJavaMultipleFiles) {
+        output.WriteRawTag(80);
+        output.WriteBool(JavaMultipleFiles);
+      }
+      if (HasGoPackage) {
+        output.WriteRawTag(90);
+        output.WriteString(GoPackage);
+      }
+      if (HasCcGenericServices) {
+        output.WriteRawTag(128, 1);
+        output.WriteBool(CcGenericServices);
+      }
+      if (HasJavaGenericServices) {
+        output.WriteRawTag(136, 1);
+        output.WriteBool(JavaGenericServices);
+      }
+      if (HasPyGenericServices) {
+        output.WriteRawTag(144, 1);
+        output.WriteBool(PyGenericServices);
+      }
+      if (HasJavaGenerateEqualsAndHash) {
+        output.WriteRawTag(160, 1);
+        output.WriteBool(JavaGenerateEqualsAndHash);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(184, 1);
+        output.WriteBool(Deprecated);
+      }
+      if (HasJavaStringCheckUtf8) {
+        output.WriteRawTag(216, 1);
+        output.WriteBool(JavaStringCheckUtf8);
+      }
+      if (HasCcEnableArenas) {
+        output.WriteRawTag(248, 1);
+        output.WriteBool(CcEnableArenas);
+      }
+      if (HasObjcClassPrefix) {
+        output.WriteRawTag(162, 2);
+        output.WriteString(ObjcClassPrefix);
+      }
+      if (HasCsharpNamespace) {
+        output.WriteRawTag(170, 2);
+        output.WriteString(CsharpNamespace);
+      }
+      if (HasSwiftPrefix) {
+        output.WriteRawTag(186, 2);
+        output.WriteString(SwiftPrefix);
+      }
+      if (HasPhpClassPrefix) {
+        output.WriteRawTag(194, 2);
+        output.WriteString(PhpClassPrefix);
+      }
+      if (HasPhpNamespace) {
+        output.WriteRawTag(202, 2);
+        output.WriteString(PhpNamespace);
+      }
+      if (HasPhpGenericServices) {
+        output.WriteRawTag(208, 2);
+        output.WriteBool(PhpGenericServices);
+      }
+      if (HasPhpMetadataNamespace) {
+        output.WriteRawTag(226, 2);
+        output.WriteString(PhpMetadataNamespace);
+      }
+      if (HasRubyPackage) {
+        output.WriteRawTag(234, 2);
+        output.WriteString(RubyPackage);
+      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasJavaPackage) {
+        output.WriteRawTag(10);
+        output.WriteString(JavaPackage);
+      }
+      if (HasJavaOuterClassname) {
+        output.WriteRawTag(66);
+        output.WriteString(JavaOuterClassname);
+      }
+      if (HasOptimizeFor) {
+        output.WriteRawTag(72);
+        output.WriteEnum((int) OptimizeFor);
+      }
+      if (HasJavaMultipleFiles) {
+        output.WriteRawTag(80);
+        output.WriteBool(JavaMultipleFiles);
+      }
+      if (HasGoPackage) {
+        output.WriteRawTag(90);
+        output.WriteString(GoPackage);
+      }
+      if (HasCcGenericServices) {
+        output.WriteRawTag(128, 1);
+        output.WriteBool(CcGenericServices);
+      }
+      if (HasJavaGenericServices) {
+        output.WriteRawTag(136, 1);
+        output.WriteBool(JavaGenericServices);
+      }
+      if (HasPyGenericServices) {
+        output.WriteRawTag(144, 1);
+        output.WriteBool(PyGenericServices);
+      }
+      if (HasJavaGenerateEqualsAndHash) {
+        output.WriteRawTag(160, 1);
+        output.WriteBool(JavaGenerateEqualsAndHash);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(184, 1);
+        output.WriteBool(Deprecated);
+      }
+      if (HasJavaStringCheckUtf8) {
+        output.WriteRawTag(216, 1);
+        output.WriteBool(JavaStringCheckUtf8);
+      }
+      if (HasCcEnableArenas) {
+        output.WriteRawTag(248, 1);
+        output.WriteBool(CcEnableArenas);
+      }
+      if (HasObjcClassPrefix) {
+        output.WriteRawTag(162, 2);
+        output.WriteString(ObjcClassPrefix);
+      }
+      if (HasCsharpNamespace) {
+        output.WriteRawTag(170, 2);
+        output.WriteString(CsharpNamespace);
+      }
+      if (HasSwiftPrefix) {
+        output.WriteRawTag(186, 2);
+        output.WriteString(SwiftPrefix);
+      }
+      if (HasPhpClassPrefix) {
+        output.WriteRawTag(194, 2);
+        output.WriteString(PhpClassPrefix);
+      }
+      if (HasPhpNamespace) {
+        output.WriteRawTag(202, 2);
+        output.WriteString(PhpNamespace);
+      }
+      if (HasPhpGenericServices) {
+        output.WriteRawTag(208, 2);
+        output.WriteBool(PhpGenericServices);
+      }
+      if (HasPhpMetadataNamespace) {
+        output.WriteRawTag(226, 2);
+        output.WriteString(PhpMetadataNamespace);
+      }
+      if (HasRubyPackage) {
+        output.WriteRawTag(234, 2);
+        output.WriteString(RubyPackage);
+      }
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasJavaPackage) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(JavaPackage);
+      }
+      if (HasJavaOuterClassname) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(JavaOuterClassname);
+      }
+      if (HasJavaMultipleFiles) {
+        size += 1 + 1;
+      }
+      if (HasJavaGenerateEqualsAndHash) {
+        size += 2 + 1;
+      }
+      if (HasJavaStringCheckUtf8) {
+        size += 2 + 1;
+      }
+      if (HasOptimizeFor) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OptimizeFor);
+      }
+      if (HasGoPackage) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(GoPackage);
+      }
+      if (HasCcGenericServices) {
+        size += 2 + 1;
+      }
+      if (HasJavaGenericServices) {
+        size += 2 + 1;
+      }
+      if (HasPyGenericServices) {
+        size += 2 + 1;
+      }
+      if (HasPhpGenericServices) {
+        size += 2 + 1;
+      }
+      if (HasDeprecated) {
+        size += 2 + 1;
+      }
+      if (HasCcEnableArenas) {
+        size += 2 + 1;
+      }
+      if (HasObjcClassPrefix) {
+        size += 2 + pb::CodedOutputStream.ComputeStringSize(ObjcClassPrefix);
+      }
+      if (HasCsharpNamespace) {
+        size += 2 + pb::CodedOutputStream.ComputeStringSize(CsharpNamespace);
+      }
+      if (HasSwiftPrefix) {
+        size += 2 + pb::CodedOutputStream.ComputeStringSize(SwiftPrefix);
+      }
+      if (HasPhpClassPrefix) {
+        size += 2 + pb::CodedOutputStream.ComputeStringSize(PhpClassPrefix);
+      }
+      if (HasPhpNamespace) {
+        size += 2 + pb::CodedOutputStream.ComputeStringSize(PhpNamespace);
+      }
+      if (HasPhpMetadataNamespace) {
+        size += 2 + pb::CodedOutputStream.ComputeStringSize(PhpMetadataNamespace);
+      }
+      if (HasRubyPackage) {
+        size += 2 + pb::CodedOutputStream.ComputeStringSize(RubyPackage);
+      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(FileOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasJavaPackage) {
+        JavaPackage = other.JavaPackage;
+      }
+      if (other.HasJavaOuterClassname) {
+        JavaOuterClassname = other.JavaOuterClassname;
+      }
+      if (other.HasJavaMultipleFiles) {
+        JavaMultipleFiles = other.JavaMultipleFiles;
+      }
+      if (other.HasJavaGenerateEqualsAndHash) {
+        JavaGenerateEqualsAndHash = other.JavaGenerateEqualsAndHash;
+      }
+      if (other.HasJavaStringCheckUtf8) {
+        JavaStringCheckUtf8 = other.JavaStringCheckUtf8;
+      }
+      if (other.HasOptimizeFor) {
+        OptimizeFor = other.OptimizeFor;
+      }
+      if (other.HasGoPackage) {
+        GoPackage = other.GoPackage;
+      }
+      if (other.HasCcGenericServices) {
+        CcGenericServices = other.CcGenericServices;
+      }
+      if (other.HasJavaGenericServices) {
+        JavaGenericServices = other.JavaGenericServices;
+      }
+      if (other.HasPyGenericServices) {
+        PyGenericServices = other.PyGenericServices;
+      }
+      if (other.HasPhpGenericServices) {
+        PhpGenericServices = other.PhpGenericServices;
+      }
+      if (other.HasDeprecated) {
+        Deprecated = other.Deprecated;
+      }
+      if (other.HasCcEnableArenas) {
+        CcEnableArenas = other.CcEnableArenas;
+      }
+      if (other.HasObjcClassPrefix) {
+        ObjcClassPrefix = other.ObjcClassPrefix;
+      }
+      if (other.HasCsharpNamespace) {
+        CsharpNamespace = other.CsharpNamespace;
+      }
+      if (other.HasSwiftPrefix) {
+        SwiftPrefix = other.SwiftPrefix;
+      }
+      if (other.HasPhpClassPrefix) {
+        PhpClassPrefix = other.PhpClassPrefix;
+      }
+      if (other.HasPhpNamespace) {
+        PhpNamespace = other.PhpNamespace;
+      }
+      if (other.HasPhpMetadataNamespace) {
+        PhpMetadataNamespace = other.PhpMetadataNamespace;
+      }
+      if (other.HasRubyPackage) {
+        RubyPackage = other.RubyPackage;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 10: {
+            JavaPackage = input.ReadString();
+            break;
+          }
+          case 66: {
+            JavaOuterClassname = input.ReadString();
+            break;
+          }
+          case 72: {
+            OptimizeFor = (global::LC.Google.Protobuf.Reflection.FileOptions.Types.OptimizeMode) input.ReadEnum();
+            break;
+          }
+          case 80: {
+            JavaMultipleFiles = input.ReadBool();
+            break;
+          }
+          case 90: {
+            GoPackage = input.ReadString();
+            break;
+          }
+          case 128: {
+            CcGenericServices = input.ReadBool();
+            break;
+          }
+          case 136: {
+            JavaGenericServices = input.ReadBool();
+            break;
+          }
+          case 144: {
+            PyGenericServices = input.ReadBool();
+            break;
+          }
+          case 160: {
+            JavaGenerateEqualsAndHash = input.ReadBool();
+            break;
+          }
+          case 184: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 216: {
+            JavaStringCheckUtf8 = input.ReadBool();
+            break;
+          }
+          case 248: {
+            CcEnableArenas = input.ReadBool();
+            break;
+          }
+          case 290: {
+            ObjcClassPrefix = input.ReadString();
+            break;
+          }
+          case 298: {
+            CsharpNamespace = input.ReadString();
+            break;
+          }
+          case 314: {
+            SwiftPrefix = input.ReadString();
+            break;
+          }
+          case 322: {
+            PhpClassPrefix = input.ReadString();
+            break;
+          }
+          case 330: {
+            PhpNamespace = input.ReadString();
+            break;
+          }
+          case 336: {
+            PhpGenericServices = input.ReadBool();
+            break;
+          }
+          case 354: {
+            PhpMetadataNamespace = input.ReadString();
+            break;
+          }
+          case 362: {
+            RubyPackage = input.ReadString();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 10: {
+            JavaPackage = input.ReadString();
+            break;
+          }
+          case 66: {
+            JavaOuterClassname = input.ReadString();
+            break;
+          }
+          case 72: {
+            OptimizeFor = (global::LC.Google.Protobuf.Reflection.FileOptions.Types.OptimizeMode) input.ReadEnum();
+            break;
+          }
+          case 80: {
+            JavaMultipleFiles = input.ReadBool();
+            break;
+          }
+          case 90: {
+            GoPackage = input.ReadString();
+            break;
+          }
+          case 128: {
+            CcGenericServices = input.ReadBool();
+            break;
+          }
+          case 136: {
+            JavaGenericServices = input.ReadBool();
+            break;
+          }
+          case 144: {
+            PyGenericServices = input.ReadBool();
+            break;
+          }
+          case 160: {
+            JavaGenerateEqualsAndHash = input.ReadBool();
+            break;
+          }
+          case 184: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 216: {
+            JavaStringCheckUtf8 = input.ReadBool();
+            break;
+          }
+          case 248: {
+            CcEnableArenas = input.ReadBool();
+            break;
+          }
+          case 290: {
+            ObjcClassPrefix = input.ReadString();
+            break;
+          }
+          case 298: {
+            CsharpNamespace = input.ReadString();
+            break;
+          }
+          case 314: {
+            SwiftPrefix = input.ReadString();
+            break;
+          }
+          case 322: {
+            PhpClassPrefix = input.ReadString();
+            break;
+          }
+          case 330: {
+            PhpNamespace = input.ReadString();
+            break;
+          }
+          case 336: {
+            PhpGenericServices = input.ReadBool();
+            break;
+          }
+          case 354: {
+            PhpMetadataNamespace = input.ReadString();
+            break;
+          }
+          case 362: {
+            RubyPackage = input.ReadString();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<FileOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<FileOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<FileOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<FileOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<FileOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<FileOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<FileOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the FileOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      /// <summary>
+      /// Generated classes can be optimized for speed or code size.
+      /// </summary>
+      public enum OptimizeMode {
+        /// <summary>
+        /// Generate complete code for parsing, serialization,
+        /// </summary>
+        [pbr::OriginalName("SPEED")] Speed = 1,
+        /// <summary>
+        /// etc.
+        /// </summary>
+        [pbr::OriginalName("CODE_SIZE")] CodeSize = 2,
+        /// <summary>
+        /// Generate code using MessageLite and the lite runtime.
+        /// </summary>
+        [pbr::OriginalName("LITE_RUNTIME")] LiteRuntime = 3,
+      }
+
+    }
+    #endregion
+
+  }
+
+  public sealed partial class MessageOptions : pb::IExtendableMessage<MessageOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<MessageOptions> _parser = new pb::MessageParser<MessageOptions>(() => new MessageOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<MessageOptions> _extensions;
+    private pb::ExtensionSet<MessageOptions> _Extensions { get { return _extensions; } }
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<MessageOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[11]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MessageOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MessageOptions(MessageOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      messageSetWireFormat_ = other.messageSetWireFormat_;
+      noStandardDescriptorAccessor_ = other.noStandardDescriptorAccessor_;
+      deprecated_ = other.deprecated_;
+      mapEntry_ = other.mapEntry_;
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MessageOptions Clone() {
+      return new MessageOptions(this);
+    }
+
+    /// <summary>Field number for the "message_set_wire_format" field.</summary>
+    public const int MessageSetWireFormatFieldNumber = 1;
+    private readonly static bool MessageSetWireFormatDefaultValue = false;
+
+    private bool messageSetWireFormat_;
+    /// <summary>
+    /// Set true to use the old proto1 MessageSet wire format for extensions.
+    /// This is provided for backwards-compatibility with the MessageSet wire
+    /// format.  You should not use this for any other reason:  It's less
+    /// efficient, has fewer features, and is more complicated.
+    ///
+    /// The message must be defined exactly as follows:
+    ///   message Foo {
+    ///     option message_set_wire_format = true;
+    ///     extensions 4 to max;
+    ///   }
+    /// Note that the message cannot have any defined fields; MessageSets only
+    /// have extensions.
+    ///
+    /// All extensions of your type must be singular messages; e.g. they cannot
+    /// be int32s, enums, or repeated messages.
+    ///
+    /// Because this is an option, the above two restrictions are not enforced by
+    /// the protocol compiler.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool MessageSetWireFormat {
+      get { if ((_hasBits0 & 1) != 0) { return messageSetWireFormat_; } else { return MessageSetWireFormatDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        messageSetWireFormat_ = value;
+      }
+    }
+    /// <summary>Gets whether the "message_set_wire_format" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasMessageSetWireFormat {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "message_set_wire_format" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearMessageSetWireFormat() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "no_standard_descriptor_accessor" field.</summary>
+    public const int NoStandardDescriptorAccessorFieldNumber = 2;
+    private readonly static bool NoStandardDescriptorAccessorDefaultValue = false;
+
+    private bool noStandardDescriptorAccessor_;
+    /// <summary>
+    /// Disables the generation of the standard "descriptor()" accessor, which can
+    /// conflict with a field of the same name.  This is meant to make migration
+    /// from proto1 easier; new code should avoid fields named "descriptor".
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool NoStandardDescriptorAccessor {
+      get { if ((_hasBits0 & 2) != 0) { return noStandardDescriptorAccessor_; } else { return NoStandardDescriptorAccessorDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        noStandardDescriptorAccessor_ = value;
+      }
+    }
+    /// <summary>Gets whether the "no_standard_descriptor_accessor" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasNoStandardDescriptorAccessor {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "no_standard_descriptor_accessor" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearNoStandardDescriptorAccessor() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "deprecated" field.</summary>
+    public const int DeprecatedFieldNumber = 3;
+    private readonly static bool DeprecatedDefaultValue = false;
+
+    private bool deprecated_;
+    /// <summary>
+    /// Is this message deprecated?
+    /// Depending on the target platform, this can emit Deprecated annotations
+    /// for the message, or it will be completely ignored; in the very least,
+    /// this is a formalization for deprecating messages.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Deprecated {
+      get { if ((_hasBits0 & 4) != 0) { return deprecated_; } else { return DeprecatedDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        deprecated_ = value;
+      }
+    }
+    /// <summary>Gets whether the "deprecated" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDeprecated {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "deprecated" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDeprecated() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "map_entry" field.</summary>
+    public const int MapEntryFieldNumber = 7;
+    private readonly static bool MapEntryDefaultValue = false;
+
+    private bool mapEntry_;
+    /// <summary>
+    /// Whether the message is an automatically generated map entry type for the
+    /// maps field.
+    ///
+    /// For maps fields:
+    ///     map&lt;KeyType, ValueType> map_field = 1;
+    /// The parsed descriptor looks like:
+    ///     message MapFieldEntry {
+    ///         option map_entry = true;
+    ///         optional KeyType key = 1;
+    ///         optional ValueType value = 2;
+    ///     }
+    ///     repeated MapFieldEntry map_field = 1;
+    ///
+    /// Implementations may choose not to generate the map_entry=true message, but
+    /// use a native map in the target language to hold the keys and values.
+    /// The reflection APIs in such implementations still need to work as
+    /// if the field is a repeated message field.
+    ///
+    /// NOTE: Do not set the option in .proto files. Always use the maps syntax
+    /// instead. The option should only be implicitly set by the proto compiler
+    /// parser.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool MapEntry {
+      get { if ((_hasBits0 & 8) != 0) { return mapEntry_; } else { return MapEntryDefaultValue; } }
+      set {
+        _hasBits0 |= 8;
+        mapEntry_ = value;
+      }
+    }
+    /// <summary>Gets whether the "map_entry" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasMapEntry {
+      get { return (_hasBits0 & 8) != 0; }
+    }
+    /// <summary>Clears the value of the "map_entry" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearMapEntry() {
+      _hasBits0 &= ~8;
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as MessageOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(MessageOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (MessageSetWireFormat != other.MessageSetWireFormat) return false;
+      if (NoStandardDescriptorAccessor != other.NoStandardDescriptorAccessor) return false;
+      if (Deprecated != other.Deprecated) return false;
+      if (MapEntry != other.MapEntry) return false;
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasMessageSetWireFormat) hash ^= MessageSetWireFormat.GetHashCode();
+      if (HasNoStandardDescriptorAccessor) hash ^= NoStandardDescriptorAccessor.GetHashCode();
+      if (HasDeprecated) hash ^= Deprecated.GetHashCode();
+      if (HasMapEntry) hash ^= MapEntry.GetHashCode();
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasMessageSetWireFormat) {
+        output.WriteRawTag(8);
+        output.WriteBool(MessageSetWireFormat);
+      }
+      if (HasNoStandardDescriptorAccessor) {
+        output.WriteRawTag(16);
+        output.WriteBool(NoStandardDescriptorAccessor);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(24);
+        output.WriteBool(Deprecated);
+      }
+      if (HasMapEntry) {
+        output.WriteRawTag(56);
+        output.WriteBool(MapEntry);
+      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasMessageSetWireFormat) {
+        output.WriteRawTag(8);
+        output.WriteBool(MessageSetWireFormat);
+      }
+      if (HasNoStandardDescriptorAccessor) {
+        output.WriteRawTag(16);
+        output.WriteBool(NoStandardDescriptorAccessor);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(24);
+        output.WriteBool(Deprecated);
+      }
+      if (HasMapEntry) {
+        output.WriteRawTag(56);
+        output.WriteBool(MapEntry);
+      }
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasMessageSetWireFormat) {
+        size += 1 + 1;
+      }
+      if (HasNoStandardDescriptorAccessor) {
+        size += 1 + 1;
+      }
+      if (HasDeprecated) {
+        size += 1 + 1;
+      }
+      if (HasMapEntry) {
+        size += 1 + 1;
+      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(MessageOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasMessageSetWireFormat) {
+        MessageSetWireFormat = other.MessageSetWireFormat;
+      }
+      if (other.HasNoStandardDescriptorAccessor) {
+        NoStandardDescriptorAccessor = other.NoStandardDescriptorAccessor;
+      }
+      if (other.HasDeprecated) {
+        Deprecated = other.Deprecated;
+      }
+      if (other.HasMapEntry) {
+        MapEntry = other.MapEntry;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 8: {
+            MessageSetWireFormat = input.ReadBool();
+            break;
+          }
+          case 16: {
+            NoStandardDescriptorAccessor = input.ReadBool();
+            break;
+          }
+          case 24: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 56: {
+            MapEntry = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 8: {
+            MessageSetWireFormat = input.ReadBool();
+            break;
+          }
+          case 16: {
+            NoStandardDescriptorAccessor = input.ReadBool();
+            break;
+          }
+          case 24: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 56: {
+            MapEntry = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<MessageOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<MessageOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<MessageOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<MessageOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<MessageOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<MessageOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<MessageOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+  }
+
+  public sealed partial class FieldOptions : pb::IExtendableMessage<FieldOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FieldOptions> _parser = new pb::MessageParser<FieldOptions>(() => new FieldOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<FieldOptions> _extensions;
+    private pb::ExtensionSet<FieldOptions> _Extensions { get { return _extensions; } }
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<FieldOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[12]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldOptions(FieldOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      ctype_ = other.ctype_;
+      packed_ = other.packed_;
+      jstype_ = other.jstype_;
+      lazy_ = other.lazy_;
+      deprecated_ = other.deprecated_;
+      weak_ = other.weak_;
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldOptions Clone() {
+      return new FieldOptions(this);
+    }
+
+    /// <summary>Field number for the "ctype" field.</summary>
+    public const int CtypeFieldNumber = 1;
+    private readonly static global::LC.Google.Protobuf.Reflection.FieldOptions.Types.CType CtypeDefaultValue = global::LC.Google.Protobuf.Reflection.FieldOptions.Types.CType.String;
+
+    private global::LC.Google.Protobuf.Reflection.FieldOptions.Types.CType ctype_;
+    /// <summary>
+    /// The ctype option instructs the C++ code generator to use a different
+    /// representation of the field than it normally would.  See the specific
+    /// options below.  This option is not yet implemented in the open source
+    /// release -- sorry, we'll try to include it in a future version!
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.FieldOptions.Types.CType Ctype {
+      get { if ((_hasBits0 & 1) != 0) { return ctype_; } else { return CtypeDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        ctype_ = value;
+      }
+    }
+    /// <summary>Gets whether the "ctype" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasCtype {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "ctype" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearCtype() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "packed" field.</summary>
+    public const int PackedFieldNumber = 2;
+    private readonly static bool PackedDefaultValue = false;
+
+    private bool packed_;
+    /// <summary>
+    /// The packed option can be enabled for repeated primitive fields to enable
+    /// a more efficient representation on the wire. Rather than repeatedly
+    /// writing the tag and type for each element, the entire array is encoded as
+    /// a single length-delimited blob. In proto3, only explicit setting it to
+    /// false will avoid using packed encoding.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Packed {
+      get { if ((_hasBits0 & 2) != 0) { return packed_; } else { return PackedDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        packed_ = value;
+      }
+    }
+    /// <summary>Gets whether the "packed" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPacked {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "packed" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPacked() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "jstype" field.</summary>
+    public const int JstypeFieldNumber = 6;
+    private readonly static global::LC.Google.Protobuf.Reflection.FieldOptions.Types.JSType JstypeDefaultValue = global::LC.Google.Protobuf.Reflection.FieldOptions.Types.JSType.JsNormal;
+
+    private global::LC.Google.Protobuf.Reflection.FieldOptions.Types.JSType jstype_;
+    /// <summary>
+    /// The jstype option determines the JavaScript type used for values of the
+    /// field.  The option is permitted only for 64 bit integral and fixed types
+    /// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
+    /// is represented as JavaScript string, which avoids loss of precision that
+    /// can happen when a large value is converted to a floating point JavaScript.
+    /// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+    /// use the JavaScript "number" type.  The behavior of the default option
+    /// JS_NORMAL is implementation dependent.
+    ///
+    /// This option is an enum to permit additional types to be added, e.g.
+    /// goog.math.Integer.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.FieldOptions.Types.JSType Jstype {
+      get { if ((_hasBits0 & 16) != 0) { return jstype_; } else { return JstypeDefaultValue; } }
+      set {
+        _hasBits0 |= 16;
+        jstype_ = value;
+      }
+    }
+    /// <summary>Gets whether the "jstype" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasJstype {
+      get { return (_hasBits0 & 16) != 0; }
+    }
+    /// <summary>Clears the value of the "jstype" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearJstype() {
+      _hasBits0 &= ~16;
+    }
+
+    /// <summary>Field number for the "lazy" field.</summary>
+    public const int LazyFieldNumber = 5;
+    private readonly static bool LazyDefaultValue = false;
+
+    private bool lazy_;
+    /// <summary>
+    /// Should this field be parsed lazily?  Lazy applies only to message-type
+    /// fields.  It means that when the outer message is initially parsed, the
+    /// inner message's contents will not be parsed but instead stored in encoded
+    /// form.  The inner message will actually be parsed when it is first accessed.
+    ///
+    /// This is only a hint.  Implementations are free to choose whether to use
+    /// eager or lazy parsing regardless of the value of this option.  However,
+    /// setting this option true suggests that the protocol author believes that
+    /// using lazy parsing on this field is worth the additional bookkeeping
+    /// overhead typically needed to implement it.
+    ///
+    /// This option does not affect the public interface of any generated code;
+    /// all method signatures remain the same.  Furthermore, thread-safety of the
+    /// interface is not affected by this option; const methods remain safe to
+    /// call from multiple threads concurrently, while non-const methods continue
+    /// to require exclusive access.
+    ///
+    /// Note that implementations may choose not to check required fields within
+    /// a lazy sub-message.  That is, calling IsInitialized() on the outer message
+    /// may return true even if the inner message has missing required fields.
+    /// This is necessary because otherwise the inner message would have to be
+    /// parsed in order to perform the check, defeating the purpose of lazy
+    /// parsing.  An implementation which chooses not to check required fields
+    /// must be consistent about it.  That is, for any particular sub-message, the
+    /// implementation must either *always* check its required fields, or *never*
+    /// check its required fields, regardless of whether or not the message has
+    /// been parsed.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Lazy {
+      get { if ((_hasBits0 & 8) != 0) { return lazy_; } else { return LazyDefaultValue; } }
+      set {
+        _hasBits0 |= 8;
+        lazy_ = value;
+      }
+    }
+    /// <summary>Gets whether the "lazy" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasLazy {
+      get { return (_hasBits0 & 8) != 0; }
+    }
+    /// <summary>Clears the value of the "lazy" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearLazy() {
+      _hasBits0 &= ~8;
+    }
+
+    /// <summary>Field number for the "deprecated" field.</summary>
+    public const int DeprecatedFieldNumber = 3;
+    private readonly static bool DeprecatedDefaultValue = false;
+
+    private bool deprecated_;
+    /// <summary>
+    /// Is this field deprecated?
+    /// Depending on the target platform, this can emit Deprecated annotations
+    /// for accessors, or it will be completely ignored; in the very least, this
+    /// is a formalization for deprecating fields.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Deprecated {
+      get { if ((_hasBits0 & 4) != 0) { return deprecated_; } else { return DeprecatedDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        deprecated_ = value;
+      }
+    }
+    /// <summary>Gets whether the "deprecated" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDeprecated {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "deprecated" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDeprecated() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "weak" field.</summary>
+    public const int WeakFieldNumber = 10;
+    private readonly static bool WeakDefaultValue = false;
+
+    private bool weak_;
+    /// <summary>
+    /// For Google-internal migration only. Do not use.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Weak {
+      get { if ((_hasBits0 & 32) != 0) { return weak_; } else { return WeakDefaultValue; } }
+      set {
+        _hasBits0 |= 32;
+        weak_ = value;
+      }
+    }
+    /// <summary>Gets whether the "weak" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasWeak {
+      get { return (_hasBits0 & 32) != 0; }
+    }
+    /// <summary>Clears the value of the "weak" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearWeak() {
+      _hasBits0 &= ~32;
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as FieldOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(FieldOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Ctype != other.Ctype) return false;
+      if (Packed != other.Packed) return false;
+      if (Jstype != other.Jstype) return false;
+      if (Lazy != other.Lazy) return false;
+      if (Deprecated != other.Deprecated) return false;
+      if (Weak != other.Weak) return false;
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasCtype) hash ^= Ctype.GetHashCode();
+      if (HasPacked) hash ^= Packed.GetHashCode();
+      if (HasJstype) hash ^= Jstype.GetHashCode();
+      if (HasLazy) hash ^= Lazy.GetHashCode();
+      if (HasDeprecated) hash ^= Deprecated.GetHashCode();
+      if (HasWeak) hash ^= Weak.GetHashCode();
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasCtype) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) Ctype);
+      }
+      if (HasPacked) {
+        output.WriteRawTag(16);
+        output.WriteBool(Packed);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(24);
+        output.WriteBool(Deprecated);
+      }
+      if (HasLazy) {
+        output.WriteRawTag(40);
+        output.WriteBool(Lazy);
+      }
+      if (HasJstype) {
+        output.WriteRawTag(48);
+        output.WriteEnum((int) Jstype);
+      }
+      if (HasWeak) {
+        output.WriteRawTag(80);
+        output.WriteBool(Weak);
+      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasCtype) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) Ctype);
+      }
+      if (HasPacked) {
+        output.WriteRawTag(16);
+        output.WriteBool(Packed);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(24);
+        output.WriteBool(Deprecated);
+      }
+      if (HasLazy) {
+        output.WriteRawTag(40);
+        output.WriteBool(Lazy);
+      }
+      if (HasJstype) {
+        output.WriteRawTag(48);
+        output.WriteEnum((int) Jstype);
+      }
+      if (HasWeak) {
+        output.WriteRawTag(80);
+        output.WriteBool(Weak);
+      }
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasCtype) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Ctype);
+      }
+      if (HasPacked) {
+        size += 1 + 1;
+      }
+      if (HasJstype) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Jstype);
+      }
+      if (HasLazy) {
+        size += 1 + 1;
+      }
+      if (HasDeprecated) {
+        size += 1 + 1;
+      }
+      if (HasWeak) {
+        size += 1 + 1;
+      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(FieldOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasCtype) {
+        Ctype = other.Ctype;
+      }
+      if (other.HasPacked) {
+        Packed = other.Packed;
+      }
+      if (other.HasJstype) {
+        Jstype = other.Jstype;
+      }
+      if (other.HasLazy) {
+        Lazy = other.Lazy;
+      }
+      if (other.HasDeprecated) {
+        Deprecated = other.Deprecated;
+      }
+      if (other.HasWeak) {
+        Weak = other.Weak;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 8: {
+            Ctype = (global::LC.Google.Protobuf.Reflection.FieldOptions.Types.CType) input.ReadEnum();
+            break;
+          }
+          case 16: {
+            Packed = input.ReadBool();
+            break;
+          }
+          case 24: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 40: {
+            Lazy = input.ReadBool();
+            break;
+          }
+          case 48: {
+            Jstype = (global::LC.Google.Protobuf.Reflection.FieldOptions.Types.JSType) input.ReadEnum();
+            break;
+          }
+          case 80: {
+            Weak = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 8: {
+            Ctype = (global::LC.Google.Protobuf.Reflection.FieldOptions.Types.CType) input.ReadEnum();
+            break;
+          }
+          case 16: {
+            Packed = input.ReadBool();
+            break;
+          }
+          case 24: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 40: {
+            Lazy = input.ReadBool();
+            break;
+          }
+          case 48: {
+            Jstype = (global::LC.Google.Protobuf.Reflection.FieldOptions.Types.JSType) input.ReadEnum();
+            break;
+          }
+          case 80: {
+            Weak = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<FieldOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<FieldOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<FieldOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<FieldOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<FieldOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<FieldOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<FieldOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the FieldOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      public enum CType {
+        /// <summary>
+        /// Default mode.
+        /// </summary>
+        [pbr::OriginalName("STRING")] String = 0,
+        [pbr::OriginalName("CORD")] Cord = 1,
+        [pbr::OriginalName("STRING_PIECE")] StringPiece = 2,
+      }
+
+      public enum JSType {
+        /// <summary>
+        /// Use the default type.
+        /// </summary>
+        [pbr::OriginalName("JS_NORMAL")] JsNormal = 0,
+        /// <summary>
+        /// Use JavaScript strings.
+        /// </summary>
+        [pbr::OriginalName("JS_STRING")] JsString = 1,
+        /// <summary>
+        /// Use JavaScript numbers.
+        /// </summary>
+        [pbr::OriginalName("JS_NUMBER")] JsNumber = 2,
+      }
+
+    }
+    #endregion
+
+  }
+
+  public sealed partial class OneofOptions : pb::IExtendableMessage<OneofOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<OneofOptions> _parser = new pb::MessageParser<OneofOptions>(() => new OneofOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<OneofOptions> _extensions;
+    private pb::ExtensionSet<OneofOptions> _Extensions { get { return _extensions; } }
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<OneofOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[13]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public OneofOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public OneofOptions(OneofOptions other) : this() {
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public OneofOptions Clone() {
+      return new OneofOptions(this);
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as OneofOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(OneofOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(OneofOptions other) {
+      if (other == null) {
+        return;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<OneofOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<OneofOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<OneofOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<OneofOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<OneofOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<OneofOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<OneofOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+  }
+
+  public sealed partial class EnumOptions : pb::IExtendableMessage<EnumOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<EnumOptions> _parser = new pb::MessageParser<EnumOptions>(() => new EnumOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<EnumOptions> _extensions;
+    private pb::ExtensionSet<EnumOptions> _Extensions { get { return _extensions; } }
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<EnumOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[14]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumOptions(EnumOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      allowAlias_ = other.allowAlias_;
+      deprecated_ = other.deprecated_;
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumOptions Clone() {
+      return new EnumOptions(this);
+    }
+
+    /// <summary>Field number for the "allow_alias" field.</summary>
+    public const int AllowAliasFieldNumber = 2;
+    private readonly static bool AllowAliasDefaultValue = false;
+
+    private bool allowAlias_;
+    /// <summary>
+    /// Set this option to true to allow mapping different tag names to the same
+    /// value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool AllowAlias {
+      get { if ((_hasBits0 & 1) != 0) { return allowAlias_; } else { return AllowAliasDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        allowAlias_ = value;
+      }
+    }
+    /// <summary>Gets whether the "allow_alias" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasAllowAlias {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "allow_alias" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearAllowAlias() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "deprecated" field.</summary>
+    public const int DeprecatedFieldNumber = 3;
+    private readonly static bool DeprecatedDefaultValue = false;
+
+    private bool deprecated_;
+    /// <summary>
+    /// Is this enum deprecated?
+    /// Depending on the target platform, this can emit Deprecated annotations
+    /// for the enum, or it will be completely ignored; in the very least, this
+    /// is a formalization for deprecating enums.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Deprecated {
+      get { if ((_hasBits0 & 2) != 0) { return deprecated_; } else { return DeprecatedDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        deprecated_ = value;
+      }
+    }
+    /// <summary>Gets whether the "deprecated" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDeprecated {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "deprecated" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDeprecated() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as EnumOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(EnumOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (AllowAlias != other.AllowAlias) return false;
+      if (Deprecated != other.Deprecated) return false;
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasAllowAlias) hash ^= AllowAlias.GetHashCode();
+      if (HasDeprecated) hash ^= Deprecated.GetHashCode();
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasAllowAlias) {
+        output.WriteRawTag(16);
+        output.WriteBool(AllowAlias);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(24);
+        output.WriteBool(Deprecated);
+      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasAllowAlias) {
+        output.WriteRawTag(16);
+        output.WriteBool(AllowAlias);
+      }
+      if (HasDeprecated) {
+        output.WriteRawTag(24);
+        output.WriteBool(Deprecated);
+      }
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasAllowAlias) {
+        size += 1 + 1;
+      }
+      if (HasDeprecated) {
+        size += 1 + 1;
+      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(EnumOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasAllowAlias) {
+        AllowAlias = other.AllowAlias;
+      }
+      if (other.HasDeprecated) {
+        Deprecated = other.Deprecated;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 16: {
+            AllowAlias = input.ReadBool();
+            break;
+          }
+          case 24: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 16: {
+            AllowAlias = input.ReadBool();
+            break;
+          }
+          case 24: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<EnumOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<EnumOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<EnumOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<EnumOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<EnumOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<EnumOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<EnumOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+  }
+
+  public sealed partial class EnumValueOptions : pb::IExtendableMessage<EnumValueOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<EnumValueOptions> _parser = new pb::MessageParser<EnumValueOptions>(() => new EnumValueOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<EnumValueOptions> _extensions;
+    private pb::ExtensionSet<EnumValueOptions> _Extensions { get { return _extensions; } }
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<EnumValueOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[15]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValueOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValueOptions(EnumValueOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      deprecated_ = other.deprecated_;
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValueOptions Clone() {
+      return new EnumValueOptions(this);
+    }
+
+    /// <summary>Field number for the "deprecated" field.</summary>
+    public const int DeprecatedFieldNumber = 1;
+    private readonly static bool DeprecatedDefaultValue = false;
+
+    private bool deprecated_;
+    /// <summary>
+    /// Is this enum value deprecated?
+    /// Depending on the target platform, this can emit Deprecated annotations
+    /// for the enum value, or it will be completely ignored; in the very least,
+    /// this is a formalization for deprecating enum values.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Deprecated {
+      get { if ((_hasBits0 & 1) != 0) { return deprecated_; } else { return DeprecatedDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        deprecated_ = value;
+      }
+    }
+    /// <summary>Gets whether the "deprecated" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDeprecated {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "deprecated" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDeprecated() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as EnumValueOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(EnumValueOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Deprecated != other.Deprecated) return false;
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasDeprecated) hash ^= Deprecated.GetHashCode();
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasDeprecated) {
+        output.WriteRawTag(8);
+        output.WriteBool(Deprecated);
+      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasDeprecated) {
+        output.WriteRawTag(8);
+        output.WriteBool(Deprecated);
+      }
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasDeprecated) {
+        size += 1 + 1;
+      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(EnumValueOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasDeprecated) {
+        Deprecated = other.Deprecated;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 8: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 8: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<EnumValueOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<EnumValueOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<EnumValueOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<EnumValueOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<EnumValueOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<EnumValueOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<EnumValueOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+  }
+
+  public sealed partial class ServiceOptions : pb::IExtendableMessage<ServiceOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<ServiceOptions> _parser = new pb::MessageParser<ServiceOptions>(() => new ServiceOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<ServiceOptions> _extensions;
+    private pb::ExtensionSet<ServiceOptions> _Extensions { get { return _extensions; } }
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<ServiceOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[16]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ServiceOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ServiceOptions(ServiceOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      deprecated_ = other.deprecated_;
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ServiceOptions Clone() {
+      return new ServiceOptions(this);
+    }
+
+    /// <summary>Field number for the "deprecated" field.</summary>
+    public const int DeprecatedFieldNumber = 33;
+    private readonly static bool DeprecatedDefaultValue = false;
+
+    private bool deprecated_;
+    /// <summary>
+    /// Is this service deprecated?
+    /// Depending on the target platform, this can emit Deprecated annotations
+    /// for the service, or it will be completely ignored; in the very least,
+    /// this is a formalization for deprecating services.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Deprecated {
+      get { if ((_hasBits0 & 1) != 0) { return deprecated_; } else { return DeprecatedDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        deprecated_ = value;
+      }
+    }
+    /// <summary>Gets whether the "deprecated" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDeprecated {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "deprecated" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDeprecated() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as ServiceOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(ServiceOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Deprecated != other.Deprecated) return false;
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasDeprecated) hash ^= Deprecated.GetHashCode();
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasDeprecated) {
+        output.WriteRawTag(136, 2);
+        output.WriteBool(Deprecated);
+      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasDeprecated) {
+        output.WriteRawTag(136, 2);
+        output.WriteBool(Deprecated);
+      }
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasDeprecated) {
+        size += 2 + 1;
+      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(ServiceOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasDeprecated) {
+        Deprecated = other.Deprecated;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 264: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 264: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<ServiceOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<ServiceOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<ServiceOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<ServiceOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<ServiceOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<ServiceOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<ServiceOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+  }
+
+  public sealed partial class MethodOptions : pb::IExtendableMessage<MethodOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<MethodOptions> _parser = new pb::MessageParser<MethodOptions>(() => new MethodOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    internal pb::ExtensionSet<MethodOptions> _extensions;
+    private pb::ExtensionSet<MethodOptions> _Extensions { get { return _extensions; } }
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<MethodOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[17]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MethodOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MethodOptions(MethodOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      deprecated_ = other.deprecated_;
+      idempotencyLevel_ = other.idempotencyLevel_;
+      uninterpretedOption_ = other.uninterpretedOption_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+      _extensions = pb::ExtensionSet.Clone(other._extensions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public MethodOptions Clone() {
+      return new MethodOptions(this);
+    }
+
+    /// <summary>Field number for the "deprecated" field.</summary>
+    public const int DeprecatedFieldNumber = 33;
+    private readonly static bool DeprecatedDefaultValue = false;
+
+    private bool deprecated_;
+    /// <summary>
+    /// Is this method deprecated?
+    /// Depending on the target platform, this can emit Deprecated annotations
+    /// for the method, or it will be completely ignored; in the very least,
+    /// this is a formalization for deprecating methods.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Deprecated {
+      get { if ((_hasBits0 & 1) != 0) { return deprecated_; } else { return DeprecatedDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        deprecated_ = value;
+      }
+    }
+    /// <summary>Gets whether the "deprecated" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDeprecated {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "deprecated" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDeprecated() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "idempotency_level" field.</summary>
+    public const int IdempotencyLevelFieldNumber = 34;
+    private readonly static global::LC.Google.Protobuf.Reflection.MethodOptions.Types.IdempotencyLevel IdempotencyLevelDefaultValue = global::LC.Google.Protobuf.Reflection.MethodOptions.Types.IdempotencyLevel.IdempotencyUnknown;
+
+    private global::LC.Google.Protobuf.Reflection.MethodOptions.Types.IdempotencyLevel idempotencyLevel_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.Reflection.MethodOptions.Types.IdempotencyLevel IdempotencyLevel {
+      get { if ((_hasBits0 & 2) != 0) { return idempotencyLevel_; } else { return IdempotencyLevelDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        idempotencyLevel_ = value;
+      }
+    }
+    /// <summary>Gets whether the "idempotency_level" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasIdempotencyLevel {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "idempotency_level" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearIdempotencyLevel() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "uninterpreted_option" field.</summary>
+    public const int UninterpretedOptionFieldNumber = 999;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption> _repeated_uninterpretedOption_codec
+        = pb::FieldCodec.ForMessage(7994, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption>();
+    /// <summary>
+    /// The parser stores options it doesn't recognize here. See above.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption> UninterpretedOption {
+      get { return uninterpretedOption_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as MethodOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(MethodOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Deprecated != other.Deprecated) return false;
+      if (IdempotencyLevel != other.IdempotencyLevel) return false;
+      if(!uninterpretedOption_.Equals(other.uninterpretedOption_)) return false;
+      if (!Equals(_extensions, other._extensions)) {
+        return false;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasDeprecated) hash ^= Deprecated.GetHashCode();
+      if (HasIdempotencyLevel) hash ^= IdempotencyLevel.GetHashCode();
+      hash ^= uninterpretedOption_.GetHashCode();
+      if (_extensions != null) {
+        hash ^= _extensions.GetHashCode();
+      }
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasDeprecated) {
+        output.WriteRawTag(136, 2);
+        output.WriteBool(Deprecated);
+      }
+      if (HasIdempotencyLevel) {
+        output.WriteRawTag(144, 2);
+        output.WriteEnum((int) IdempotencyLevel);
+      }
+      uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasDeprecated) {
+        output.WriteRawTag(136, 2);
+        output.WriteBool(Deprecated);
+      }
+      if (HasIdempotencyLevel) {
+        output.WriteRawTag(144, 2);
+        output.WriteEnum((int) IdempotencyLevel);
+      }
+      uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        _extensions.WriteTo(ref output);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasDeprecated) {
+        size += 2 + 1;
+      }
+      if (HasIdempotencyLevel) {
+        size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) IdempotencyLevel);
+      }
+      size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
+      if (_extensions != null) {
+        size += _extensions.CalculateSize();
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(MethodOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasDeprecated) {
+        Deprecated = other.Deprecated;
+      }
+      if (other.HasIdempotencyLevel) {
+        IdempotencyLevel = other.IdempotencyLevel;
+      }
+      uninterpretedOption_.Add(other.uninterpretedOption_);
+      pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            }
+            break;
+          case 264: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 272: {
+            IdempotencyLevel = (global::LC.Google.Protobuf.Reflection.MethodOptions.Types.IdempotencyLevel) input.ReadEnum();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
+              _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            }
+            break;
+          case 264: {
+            Deprecated = input.ReadBool();
+            break;
+          }
+          case 272: {
+            IdempotencyLevel = (global::LC.Google.Protobuf.Reflection.MethodOptions.Types.IdempotencyLevel) input.ReadEnum();
+            break;
+          }
+          case 7994: {
+            uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    public TValue GetExtension<TValue>(pb::Extension<MethodOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<MethodOptions, TValue> extension) {
+      return pb::ExtensionSet.Get(ref _extensions, extension);
+    }
+    public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<MethodOptions, TValue> extension) {
+      return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
+    }
+    public void SetExtension<TValue>(pb::Extension<MethodOptions, TValue> extension, TValue value) {
+      pb::ExtensionSet.Set(ref _extensions, extension, value);
+    }
+    public bool HasExtension<TValue>(pb::Extension<MethodOptions, TValue> extension) {
+      return pb::ExtensionSet.Has(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::Extension<MethodOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+    public void ClearExtension<TValue>(pb::RepeatedExtension<MethodOptions, TValue> extension) {
+      pb::ExtensionSet.Clear(ref _extensions, extension);
+    }
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the MethodOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      /// <summary>
+      /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+      /// or neither? HTTP based RPC implementation may choose GET verb for safe
+      /// methods, and PUT verb for idempotent methods instead of the default POST.
+      /// </summary>
+      public enum IdempotencyLevel {
+        [pbr::OriginalName("IDEMPOTENCY_UNKNOWN")] IdempotencyUnknown = 0,
+        /// <summary>
+        /// implies idempotent
+        /// </summary>
+        [pbr::OriginalName("NO_SIDE_EFFECTS")] NoSideEffects = 1,
+        /// <summary>
+        /// idempotent, but may have side effects
+        /// </summary>
+        [pbr::OriginalName("IDEMPOTENT")] Idempotent = 2,
+      }
+
+    }
+    #endregion
+
+  }
+
+  /// <summary>
+  /// A message representing a option the parser does not recognize. This only
+  /// appears in options protos created by the compiler::Parser class.
+  /// DescriptorPool resolves these when building Descriptor objects. Therefore,
+  /// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+  /// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+  /// in them.
+  /// </summary>
+  public sealed partial class UninterpretedOption : pb::IMessage<UninterpretedOption>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<UninterpretedOption> _parser = new pb::MessageParser<UninterpretedOption>(() => new UninterpretedOption());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<UninterpretedOption> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[18]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UninterpretedOption() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UninterpretedOption(UninterpretedOption other) : this() {
+      _hasBits0 = other._hasBits0;
+      name_ = other.name_.Clone();
+      identifierValue_ = other.identifierValue_;
+      positiveIntValue_ = other.positiveIntValue_;
+      negativeIntValue_ = other.negativeIntValue_;
+      doubleValue_ = other.doubleValue_;
+      stringValue_ = other.stringValue_;
+      aggregateValue_ = other.aggregateValue_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UninterpretedOption Clone() {
+      return new UninterpretedOption(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.UninterpretedOption.Types.NamePart> _repeated_name_codec
+        = pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.Reflection.UninterpretedOption.Types.NamePart.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption.Types.NamePart> name_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption.Types.NamePart>();
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.UninterpretedOption.Types.NamePart> Name {
+      get { return name_; }
+    }
+
+    /// <summary>Field number for the "identifier_value" field.</summary>
+    public const int IdentifierValueFieldNumber = 3;
+    private readonly static string IdentifierValueDefaultValue = "";
+
+    private string identifierValue_;
+    /// <summary>
+    /// The value of the uninterpreted option, in whatever type the tokenizer
+    /// identified it as during parsing. Exactly one of these should be set.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string IdentifierValue {
+      get { return identifierValue_ ?? IdentifierValueDefaultValue; }
+      set {
+        identifierValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "identifier_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasIdentifierValue {
+      get { return identifierValue_ != null; }
+    }
+    /// <summary>Clears the value of the "identifier_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearIdentifierValue() {
+      identifierValue_ = null;
+    }
+
+    /// <summary>Field number for the "positive_int_value" field.</summary>
+    public const int PositiveIntValueFieldNumber = 4;
+    private readonly static ulong PositiveIntValueDefaultValue = 0UL;
+
+    private ulong positiveIntValue_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ulong PositiveIntValue {
+      get { if ((_hasBits0 & 1) != 0) { return positiveIntValue_; } else { return PositiveIntValueDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        positiveIntValue_ = value;
+      }
+    }
+    /// <summary>Gets whether the "positive_int_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasPositiveIntValue {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "positive_int_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearPositiveIntValue() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "negative_int_value" field.</summary>
+    public const int NegativeIntValueFieldNumber = 5;
+    private readonly static long NegativeIntValueDefaultValue = 0L;
+
+    private long negativeIntValue_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public long NegativeIntValue {
+      get { if ((_hasBits0 & 2) != 0) { return negativeIntValue_; } else { return NegativeIntValueDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        negativeIntValue_ = value;
+      }
+    }
+    /// <summary>Gets whether the "negative_int_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasNegativeIntValue {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "negative_int_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearNegativeIntValue() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "double_value" field.</summary>
+    public const int DoubleValueFieldNumber = 6;
+    private readonly static double DoubleValueDefaultValue = 0D;
+
+    private double doubleValue_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public double DoubleValue {
+      get { if ((_hasBits0 & 4) != 0) { return doubleValue_; } else { return DoubleValueDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        doubleValue_ = value;
+      }
+    }
+    /// <summary>Gets whether the "double_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasDoubleValue {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "double_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearDoubleValue() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "string_value" field.</summary>
+    public const int StringValueFieldNumber = 7;
+    private readonly static pb::ByteString StringValueDefaultValue = pb::ByteString.Empty;
+
+    private pb::ByteString stringValue_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pb::ByteString StringValue {
+      get { return stringValue_ ?? StringValueDefaultValue; }
+      set {
+        stringValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "string_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasStringValue {
+      get { return stringValue_ != null; }
+    }
+    /// <summary>Clears the value of the "string_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearStringValue() {
+      stringValue_ = null;
+    }
+
+    /// <summary>Field number for the "aggregate_value" field.</summary>
+    public const int AggregateValueFieldNumber = 8;
+    private readonly static string AggregateValueDefaultValue = "";
+
+    private string aggregateValue_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string AggregateValue {
+      get { return aggregateValue_ ?? AggregateValueDefaultValue; }
+      set {
+        aggregateValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "aggregate_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool HasAggregateValue {
+      get { return aggregateValue_ != null; }
+    }
+    /// <summary>Clears the value of the "aggregate_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearAggregateValue() {
+      aggregateValue_ = null;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as UninterpretedOption);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(UninterpretedOption other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!name_.Equals(other.name_)) return false;
+      if (IdentifierValue != other.IdentifierValue) return false;
+      if (PositiveIntValue != other.PositiveIntValue) return false;
+      if (NegativeIntValue != other.NegativeIntValue) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DoubleValue, other.DoubleValue)) return false;
+      if (StringValue != other.StringValue) return false;
+      if (AggregateValue != other.AggregateValue) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= name_.GetHashCode();
+      if (HasIdentifierValue) hash ^= IdentifierValue.GetHashCode();
+      if (HasPositiveIntValue) hash ^= PositiveIntValue.GetHashCode();
+      if (HasNegativeIntValue) hash ^= NegativeIntValue.GetHashCode();
+      if (HasDoubleValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DoubleValue);
+      if (HasStringValue) hash ^= StringValue.GetHashCode();
+      if (HasAggregateValue) hash ^= AggregateValue.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      name_.WriteTo(output, _repeated_name_codec);
+      if (HasIdentifierValue) {
+        output.WriteRawTag(26);
+        output.WriteString(IdentifierValue);
+      }
+      if (HasPositiveIntValue) {
+        output.WriteRawTag(32);
+        output.WriteUInt64(PositiveIntValue);
+      }
+      if (HasNegativeIntValue) {
+        output.WriteRawTag(40);
+        output.WriteInt64(NegativeIntValue);
+      }
+      if (HasDoubleValue) {
+        output.WriteRawTag(49);
+        output.WriteDouble(DoubleValue);
+      }
+      if (HasStringValue) {
+        output.WriteRawTag(58);
+        output.WriteBytes(StringValue);
+      }
+      if (HasAggregateValue) {
+        output.WriteRawTag(66);
+        output.WriteString(AggregateValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      name_.WriteTo(ref output, _repeated_name_codec);
+      if (HasIdentifierValue) {
+        output.WriteRawTag(26);
+        output.WriteString(IdentifierValue);
+      }
+      if (HasPositiveIntValue) {
+        output.WriteRawTag(32);
+        output.WriteUInt64(PositiveIntValue);
+      }
+      if (HasNegativeIntValue) {
+        output.WriteRawTag(40);
+        output.WriteInt64(NegativeIntValue);
+      }
+      if (HasDoubleValue) {
+        output.WriteRawTag(49);
+        output.WriteDouble(DoubleValue);
+      }
+      if (HasStringValue) {
+        output.WriteRawTag(58);
+        output.WriteBytes(StringValue);
+      }
+      if (HasAggregateValue) {
+        output.WriteRawTag(66);
+        output.WriteString(AggregateValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += name_.CalculateSize(_repeated_name_codec);
+      if (HasIdentifierValue) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(IdentifierValue);
+      }
+      if (HasPositiveIntValue) {
+        size += 1 + pb::CodedOutputStream.ComputeUInt64Size(PositiveIntValue);
+      }
+      if (HasNegativeIntValue) {
+        size += 1 + pb::CodedOutputStream.ComputeInt64Size(NegativeIntValue);
+      }
+      if (HasDoubleValue) {
+        size += 1 + 8;
+      }
+      if (HasStringValue) {
+        size += 1 + pb::CodedOutputStream.ComputeBytesSize(StringValue);
+      }
+      if (HasAggregateValue) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(AggregateValue);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(UninterpretedOption other) {
+      if (other == null) {
+        return;
+      }
+      name_.Add(other.name_);
+      if (other.HasIdentifierValue) {
+        IdentifierValue = other.IdentifierValue;
+      }
+      if (other.HasPositiveIntValue) {
+        PositiveIntValue = other.PositiveIntValue;
+      }
+      if (other.HasNegativeIntValue) {
+        NegativeIntValue = other.NegativeIntValue;
+      }
+      if (other.HasDoubleValue) {
+        DoubleValue = other.DoubleValue;
+      }
+      if (other.HasStringValue) {
+        StringValue = other.StringValue;
+      }
+      if (other.HasAggregateValue) {
+        AggregateValue = other.AggregateValue;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 18: {
+            name_.AddEntriesFrom(input, _repeated_name_codec);
+            break;
+          }
+          case 26: {
+            IdentifierValue = input.ReadString();
+            break;
+          }
+          case 32: {
+            PositiveIntValue = input.ReadUInt64();
+            break;
+          }
+          case 40: {
+            NegativeIntValue = input.ReadInt64();
+            break;
+          }
+          case 49: {
+            DoubleValue = input.ReadDouble();
+            break;
+          }
+          case 58: {
+            StringValue = input.ReadBytes();
+            break;
+          }
+          case 66: {
+            AggregateValue = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 18: {
+            name_.AddEntriesFrom(ref input, _repeated_name_codec);
+            break;
+          }
+          case 26: {
+            IdentifierValue = input.ReadString();
+            break;
+          }
+          case 32: {
+            PositiveIntValue = input.ReadUInt64();
+            break;
+          }
+          case 40: {
+            NegativeIntValue = input.ReadInt64();
+            break;
+          }
+          case 49: {
+            DoubleValue = input.ReadDouble();
+            break;
+          }
+          case 58: {
+            StringValue = input.ReadBytes();
+            break;
+          }
+          case 66: {
+            AggregateValue = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the UninterpretedOption message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      /// <summary>
+      /// The name of the uninterpreted option.  Each string represents a segment in
+      /// a dot-separated name.  is_extension is true iff a segment represents an
+      /// extension (denoted with parentheses in options specs in .proto files).
+      /// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+      /// "foo.(bar.baz).qux".
+      /// </summary>
+      public sealed partial class NamePart : pb::IMessage<NamePart>
+      #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          , pb::IBufferMessage
+      #endif
+      {
+        private static readonly pb::MessageParser<NamePart> _parser = new pb::MessageParser<NamePart>(() => new NamePart());
+        private pb::UnknownFieldSet _unknownFields;
+        private int _hasBits0;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pb::MessageParser<NamePart> Parser { get { return _parser; } }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pbr::MessageDescriptor Descriptor {
+          get { return global::LC.Google.Protobuf.Reflection.UninterpretedOption.Descriptor.NestedTypes[0]; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        pbr::MessageDescriptor pb::IMessage.Descriptor {
+          get { return Descriptor; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public NamePart() {
+          OnConstruction();
+        }
+
+        partial void OnConstruction();
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public NamePart(NamePart other) : this() {
+          _hasBits0 = other._hasBits0;
+          namePart_ = other.namePart_;
+          isExtension_ = other.isExtension_;
+          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public NamePart Clone() {
+          return new NamePart(this);
+        }
+
+        /// <summary>Field number for the "name_part" field.</summary>
+        public const int NamePart_FieldNumber = 1;
+        private readonly static string NamePart_DefaultValue = "";
+
+        private string namePart_;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public string NamePart_ {
+          get { return namePart_ ?? NamePart_DefaultValue; }
+          set {
+            namePart_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+          }
+        }
+        /// <summary>Gets whether the "name_part" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasNamePart_ {
+          get { return namePart_ != null; }
+        }
+        /// <summary>Clears the value of the "name_part" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearNamePart_() {
+          namePart_ = null;
+        }
+
+        /// <summary>Field number for the "is_extension" field.</summary>
+        public const int IsExtensionFieldNumber = 2;
+        private readonly static bool IsExtensionDefaultValue = false;
+
+        private bool isExtension_;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool IsExtension {
+          get { if ((_hasBits0 & 1) != 0) { return isExtension_; } else { return IsExtensionDefaultValue; } }
+          set {
+            _hasBits0 |= 1;
+            isExtension_ = value;
+          }
+        }
+        /// <summary>Gets whether the "is_extension" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasIsExtension {
+          get { return (_hasBits0 & 1) != 0; }
+        }
+        /// <summary>Clears the value of the "is_extension" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearIsExtension() {
+          _hasBits0 &= ~1;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override bool Equals(object other) {
+          return Equals(other as NamePart);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool Equals(NamePart other) {
+          if (ReferenceEquals(other, null)) {
+            return false;
+          }
+          if (ReferenceEquals(other, this)) {
+            return true;
+          }
+          if (NamePart_ != other.NamePart_) return false;
+          if (IsExtension != other.IsExtension) return false;
+          return Equals(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override int GetHashCode() {
+          int hash = 1;
+          if (HasNamePart_) hash ^= NamePart_.GetHashCode();
+          if (HasIsExtension) hash ^= IsExtension.GetHashCode();
+          if (_unknownFields != null) {
+            hash ^= _unknownFields.GetHashCode();
+          }
+          return hash;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override string ToString() {
+          return pb::JsonFormatter.ToDiagnosticString(this);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void WriteTo(pb::CodedOutputStream output) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          output.WriteRawMessage(this);
+        #else
+          if (HasNamePart_) {
+            output.WriteRawTag(10);
+            output.WriteString(NamePart_);
+          }
+          if (HasIsExtension) {
+            output.WriteRawTag(16);
+            output.WriteBool(IsExtension);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(output);
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+          if (HasNamePart_) {
+            output.WriteRawTag(10);
+            output.WriteString(NamePart_);
+          }
+          if (HasIsExtension) {
+            output.WriteRawTag(16);
+            output.WriteBool(IsExtension);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(ref output);
+          }
+        }
+        #endif
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int CalculateSize() {
+          int size = 0;
+          if (HasNamePart_) {
+            size += 1 + pb::CodedOutputStream.ComputeStringSize(NamePart_);
+          }
+          if (HasIsExtension) {
+            size += 1 + 1;
+          }
+          if (_unknownFields != null) {
+            size += _unknownFields.CalculateSize();
+          }
+          return size;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(NamePart other) {
+          if (other == null) {
+            return;
+          }
+          if (other.HasNamePart_) {
+            NamePart_ = other.NamePart_;
+          }
+          if (other.HasIsExtension) {
+            IsExtension = other.IsExtension;
+          }
+          _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(pb::CodedInputStream input) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          input.ReadRawMessage(this);
+        #else
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+                break;
+              case 10: {
+                NamePart_ = input.ReadString();
+                break;
+              }
+              case 16: {
+                IsExtension = input.ReadBool();
+                break;
+              }
+            }
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+                break;
+              case 10: {
+                NamePart_ = input.ReadString();
+                break;
+              }
+              case 16: {
+                IsExtension = input.ReadBool();
+                break;
+              }
+            }
+          }
+        }
+        #endif
+
+      }
+
+    }
+    #endregion
+
+  }
+
+  /// <summary>
+  /// Encapsulates information about the original source file from which a
+  /// FileDescriptorProto was generated.
+  /// </summary>
+  public sealed partial class SourceCodeInfo : pb::IMessage<SourceCodeInfo>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<SourceCodeInfo> _parser = new pb::MessageParser<SourceCodeInfo>(() => new SourceCodeInfo());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<SourceCodeInfo> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[19]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public SourceCodeInfo() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public SourceCodeInfo(SourceCodeInfo other) : this() {
+      location_ = other.location_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public SourceCodeInfo Clone() {
+      return new SourceCodeInfo(this);
+    }
+
+    /// <summary>Field number for the "location" field.</summary>
+    public const int LocationFieldNumber = 1;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Types.Location> _repeated_location_codec
+        = pb::FieldCodec.ForMessage(10, global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Types.Location.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Types.Location> location_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Types.Location>();
+    /// <summary>
+    /// A Location identifies a piece of source code in a .proto file which
+    /// corresponds to a particular definition.  This information is intended
+    /// to be useful to IDEs, code indexers, documentation generators, and similar
+    /// tools.
+    ///
+    /// For example, say we have a file like:
+    ///   message Foo {
+    ///     optional string foo = 1;
+    ///   }
+    /// Let's look at just the field definition:
+    ///   optional string foo = 1;
+    ///   ^       ^^     ^^  ^  ^^^
+    ///   a       bc     de  f  ghi
+    /// We have the following locations:
+    ///   span   path               represents
+    ///   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
+    ///   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
+    ///   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
+    ///   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
+    ///   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
+    ///
+    /// Notes:
+    /// - A location may refer to a repeated field itself (i.e. not to any
+    ///   particular index within it).  This is used whenever a set of elements are
+    ///   logically enclosed in a single code segment.  For example, an entire
+    ///   extend block (possibly containing multiple extension definitions) will
+    ///   have an outer location whose path refers to the "extensions" repeated
+    ///   field without an index.
+    /// - Multiple locations may have the same path.  This happens when a single
+    ///   logical declaration is spread out across multiple places.  The most
+    ///   obvious example is the "extend" block again -- there may be multiple
+    ///   extend blocks in the same scope, each of which will have the same path.
+    /// - A location's span is not always a subset of its parent's span.  For
+    ///   example, the "extendee" of an extension declaration appears at the
+    ///   beginning of the "extend" block and is shared by all extensions within
+    ///   the block.
+    /// - Just because a location's span is a subset of some other location's span
+    ///   does not mean that it is a descendant.  For example, a "group" defines
+    ///   both a type and a field in a single declaration.  Thus, the locations
+    ///   corresponding to the type and field and their components will overlap.
+    /// - Code which tries to interpret locations should probably be designed to
+    ///   ignore those that it doesn't understand, as more types of locations could
+    ///   be recorded in the future.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Types.Location> Location {
+      get { return location_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as SourceCodeInfo);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(SourceCodeInfo other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!location_.Equals(other.location_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= location_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      location_.WriteTo(output, _repeated_location_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      location_.WriteTo(ref output, _repeated_location_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += location_.CalculateSize(_repeated_location_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(SourceCodeInfo other) {
+      if (other == null) {
+        return;
+      }
+      location_.Add(other.location_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            location_.AddEntriesFrom(input, _repeated_location_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            location_.AddEntriesFrom(ref input, _repeated_location_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the SourceCodeInfo message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      public sealed partial class Location : pb::IMessage<Location>
+      #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          , pb::IBufferMessage
+      #endif
+      {
+        private static readonly pb::MessageParser<Location> _parser = new pb::MessageParser<Location>(() => new Location());
+        private pb::UnknownFieldSet _unknownFields;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pb::MessageParser<Location> Parser { get { return _parser; } }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pbr::MessageDescriptor Descriptor {
+          get { return global::LC.Google.Protobuf.Reflection.SourceCodeInfo.Descriptor.NestedTypes[0]; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        pbr::MessageDescriptor pb::IMessage.Descriptor {
+          get { return Descriptor; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public Location() {
+          OnConstruction();
+        }
+
+        partial void OnConstruction();
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public Location(Location other) : this() {
+          path_ = other.path_.Clone();
+          span_ = other.span_.Clone();
+          leadingComments_ = other.leadingComments_;
+          trailingComments_ = other.trailingComments_;
+          leadingDetachedComments_ = other.leadingDetachedComments_.Clone();
+          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public Location Clone() {
+          return new Location(this);
+        }
+
+        /// <summary>Field number for the "path" field.</summary>
+        public const int PathFieldNumber = 1;
+        private static readonly pb::FieldCodec<int> _repeated_path_codec
+            = pb::FieldCodec.ForInt32(10);
+        private readonly pbc::RepeatedField<int> path_ = new pbc::RepeatedField<int>();
+        /// <summary>
+        /// Identifies which part of the FileDescriptorProto was defined at this
+        /// location.
+        ///
+        /// Each element is a field number or an index.  They form a path from
+        /// the root FileDescriptorProto to the place where the definition.  For
+        /// example, this path:
+        ///   [ 4, 3, 2, 7, 1 ]
+        /// refers to:
+        ///   file.message_type(3)  // 4, 3
+        ///       .field(7)         // 2, 7
+        ///       .name()           // 1
+        /// This is because FileDescriptorProto.message_type has field number 4:
+        ///   repeated DescriptorProto message_type = 4;
+        /// and DescriptorProto.field has field number 2:
+        ///   repeated FieldDescriptorProto field = 2;
+        /// and FieldDescriptorProto.name has field number 1:
+        ///   optional string name = 1;
+        ///
+        /// Thus, the above path gives the location of a field name.  If we removed
+        /// the last element:
+        ///   [ 4, 3, 2, 7 ]
+        /// this path refers to the whole field declaration (from the beginning
+        /// of the label to the terminating semicolon).
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public pbc::RepeatedField<int> Path {
+          get { return path_; }
+        }
+
+        /// <summary>Field number for the "span" field.</summary>
+        public const int SpanFieldNumber = 2;
+        private static readonly pb::FieldCodec<int> _repeated_span_codec
+            = pb::FieldCodec.ForInt32(18);
+        private readonly pbc::RepeatedField<int> span_ = new pbc::RepeatedField<int>();
+        /// <summary>
+        /// Always has exactly three or four elements: start line, start column,
+        /// end line (optional, otherwise assumed same as start line), end column.
+        /// These are packed into a single field for efficiency.  Note that line
+        /// and column numbers are zero-based -- typically you will want to add
+        /// 1 to each before displaying to a user.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public pbc::RepeatedField<int> Span {
+          get { return span_; }
+        }
+
+        /// <summary>Field number for the "leading_comments" field.</summary>
+        public const int LeadingCommentsFieldNumber = 3;
+        private readonly static string LeadingCommentsDefaultValue = "";
+
+        private string leadingComments_;
+        /// <summary>
+        /// If this SourceCodeInfo represents a complete declaration, these are any
+        /// comments appearing before and after the declaration which appear to be
+        /// attached to the declaration.
+        ///
+        /// A series of line comments appearing on consecutive lines, with no other
+        /// tokens appearing on those lines, will be treated as a single comment.
+        ///
+        /// leading_detached_comments will keep paragraphs of comments that appear
+        /// before (but not connected to) the current element. Each paragraph,
+        /// separated by empty lines, will be one comment element in the repeated
+        /// field.
+        ///
+        /// Only the comment content is provided; comment markers (e.g. //) are
+        /// stripped out.  For block comments, leading whitespace and an asterisk
+        /// will be stripped from the beginning of each line other than the first.
+        /// Newlines are included in the output.
+        ///
+        /// Examples:
+        ///
+        ///   optional int32 foo = 1;  // Comment attached to foo.
+        ///   // Comment attached to bar.
+        ///   optional int32 bar = 2;
+        ///
+        ///   optional string baz = 3;
+        ///   // Comment attached to baz.
+        ///   // Another line attached to baz.
+        ///
+        ///   // Comment attached to qux.
+        ///   //
+        ///   // Another line attached to qux.
+        ///   optional double qux = 4;
+        ///
+        ///   // Detached comment for corge. This is not leading or trailing comments
+        ///   // to qux or corge because there are blank lines separating it from
+        ///   // both.
+        ///
+        ///   // Detached comment for corge paragraph 2.
+        ///
+        ///   optional string corge = 5;
+        ///   /* Block comment attached
+        ///    * to corge.  Leading asterisks
+        ///    * will be removed. */
+        ///   /* Block comment attached to
+        ///    * grault. */
+        ///   optional int32 grault = 6;
+        ///
+        ///   // ignored detached comments.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public string LeadingComments {
+          get { return leadingComments_ ?? LeadingCommentsDefaultValue; }
+          set {
+            leadingComments_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+          }
+        }
+        /// <summary>Gets whether the "leading_comments" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasLeadingComments {
+          get { return leadingComments_ != null; }
+        }
+        /// <summary>Clears the value of the "leading_comments" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearLeadingComments() {
+          leadingComments_ = null;
+        }
+
+        /// <summary>Field number for the "trailing_comments" field.</summary>
+        public const int TrailingCommentsFieldNumber = 4;
+        private readonly static string TrailingCommentsDefaultValue = "";
+
+        private string trailingComments_;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public string TrailingComments {
+          get { return trailingComments_ ?? TrailingCommentsDefaultValue; }
+          set {
+            trailingComments_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+          }
+        }
+        /// <summary>Gets whether the "trailing_comments" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasTrailingComments {
+          get { return trailingComments_ != null; }
+        }
+        /// <summary>Clears the value of the "trailing_comments" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearTrailingComments() {
+          trailingComments_ = null;
+        }
+
+        /// <summary>Field number for the "leading_detached_comments" field.</summary>
+        public const int LeadingDetachedCommentsFieldNumber = 6;
+        private static readonly pb::FieldCodec<string> _repeated_leadingDetachedComments_codec
+            = pb::FieldCodec.ForString(50);
+        private readonly pbc::RepeatedField<string> leadingDetachedComments_ = new pbc::RepeatedField<string>();
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public pbc::RepeatedField<string> LeadingDetachedComments {
+          get { return leadingDetachedComments_; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override bool Equals(object other) {
+          return Equals(other as Location);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool Equals(Location other) {
+          if (ReferenceEquals(other, null)) {
+            return false;
+          }
+          if (ReferenceEquals(other, this)) {
+            return true;
+          }
+          if(!path_.Equals(other.path_)) return false;
+          if(!span_.Equals(other.span_)) return false;
+          if (LeadingComments != other.LeadingComments) return false;
+          if (TrailingComments != other.TrailingComments) return false;
+          if(!leadingDetachedComments_.Equals(other.leadingDetachedComments_)) return false;
+          return Equals(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override int GetHashCode() {
+          int hash = 1;
+          hash ^= path_.GetHashCode();
+          hash ^= span_.GetHashCode();
+          if (HasLeadingComments) hash ^= LeadingComments.GetHashCode();
+          if (HasTrailingComments) hash ^= TrailingComments.GetHashCode();
+          hash ^= leadingDetachedComments_.GetHashCode();
+          if (_unknownFields != null) {
+            hash ^= _unknownFields.GetHashCode();
+          }
+          return hash;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override string ToString() {
+          return pb::JsonFormatter.ToDiagnosticString(this);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void WriteTo(pb::CodedOutputStream output) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          output.WriteRawMessage(this);
+        #else
+          path_.WriteTo(output, _repeated_path_codec);
+          span_.WriteTo(output, _repeated_span_codec);
+          if (HasLeadingComments) {
+            output.WriteRawTag(26);
+            output.WriteString(LeadingComments);
+          }
+          if (HasTrailingComments) {
+            output.WriteRawTag(34);
+            output.WriteString(TrailingComments);
+          }
+          leadingDetachedComments_.WriteTo(output, _repeated_leadingDetachedComments_codec);
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(output);
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+          path_.WriteTo(ref output, _repeated_path_codec);
+          span_.WriteTo(ref output, _repeated_span_codec);
+          if (HasLeadingComments) {
+            output.WriteRawTag(26);
+            output.WriteString(LeadingComments);
+          }
+          if (HasTrailingComments) {
+            output.WriteRawTag(34);
+            output.WriteString(TrailingComments);
+          }
+          leadingDetachedComments_.WriteTo(ref output, _repeated_leadingDetachedComments_codec);
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(ref output);
+          }
+        }
+        #endif
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int CalculateSize() {
+          int size = 0;
+          size += path_.CalculateSize(_repeated_path_codec);
+          size += span_.CalculateSize(_repeated_span_codec);
+          if (HasLeadingComments) {
+            size += 1 + pb::CodedOutputStream.ComputeStringSize(LeadingComments);
+          }
+          if (HasTrailingComments) {
+            size += 1 + pb::CodedOutputStream.ComputeStringSize(TrailingComments);
+          }
+          size += leadingDetachedComments_.CalculateSize(_repeated_leadingDetachedComments_codec);
+          if (_unknownFields != null) {
+            size += _unknownFields.CalculateSize();
+          }
+          return size;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(Location other) {
+          if (other == null) {
+            return;
+          }
+          path_.Add(other.path_);
+          span_.Add(other.span_);
+          if (other.HasLeadingComments) {
+            LeadingComments = other.LeadingComments;
+          }
+          if (other.HasTrailingComments) {
+            TrailingComments = other.TrailingComments;
+          }
+          leadingDetachedComments_.Add(other.leadingDetachedComments_);
+          _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(pb::CodedInputStream input) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          input.ReadRawMessage(this);
+        #else
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+                break;
+              case 10:
+              case 8: {
+                path_.AddEntriesFrom(input, _repeated_path_codec);
+                break;
+              }
+              case 18:
+              case 16: {
+                span_.AddEntriesFrom(input, _repeated_span_codec);
+                break;
+              }
+              case 26: {
+                LeadingComments = input.ReadString();
+                break;
+              }
+              case 34: {
+                TrailingComments = input.ReadString();
+                break;
+              }
+              case 50: {
+                leadingDetachedComments_.AddEntriesFrom(input, _repeated_leadingDetachedComments_codec);
+                break;
+              }
+            }
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+                break;
+              case 10:
+              case 8: {
+                path_.AddEntriesFrom(ref input, _repeated_path_codec);
+                break;
+              }
+              case 18:
+              case 16: {
+                span_.AddEntriesFrom(ref input, _repeated_span_codec);
+                break;
+              }
+              case 26: {
+                LeadingComments = input.ReadString();
+                break;
+              }
+              case 34: {
+                TrailingComments = input.ReadString();
+                break;
+              }
+              case 50: {
+                leadingDetachedComments_.AddEntriesFrom(ref input, _repeated_leadingDetachedComments_codec);
+                break;
+              }
+            }
+          }
+        }
+        #endif
+
+      }
+
+    }
+    #endregion
+
+  }
+
+  /// <summary>
+  /// Describes the relationship between generated code and its original source
+  /// file. A GeneratedCodeInfo message is associated with only one generated
+  /// source file, but may contain references to different source .proto files.
+  /// </summary>
+  public sealed partial class GeneratedCodeInfo : pb::IMessage<GeneratedCodeInfo>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<GeneratedCodeInfo> _parser = new pb::MessageParser<GeneratedCodeInfo>(() => new GeneratedCodeInfo());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<GeneratedCodeInfo> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.Reflection.DescriptorReflection.Descriptor.MessageTypes[20]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public GeneratedCodeInfo() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public GeneratedCodeInfo(GeneratedCodeInfo other) : this() {
+      annotation_ = other.annotation_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public GeneratedCodeInfo Clone() {
+      return new GeneratedCodeInfo(this);
+    }
+
+    /// <summary>Field number for the "annotation" field.</summary>
+    public const int AnnotationFieldNumber = 1;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Types.Annotation> _repeated_annotation_codec
+        = pb::FieldCodec.ForMessage(10, global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Types.Annotation.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Types.Annotation> annotation_ = new pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Types.Annotation>();
+    /// <summary>
+    /// An Annotation connects some span of text in generated code to an element
+    /// of its generating .proto file.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Types.Annotation> Annotation {
+      get { return annotation_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as GeneratedCodeInfo);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(GeneratedCodeInfo other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!annotation_.Equals(other.annotation_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= annotation_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      annotation_.WriteTo(output, _repeated_annotation_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      annotation_.WriteTo(ref output, _repeated_annotation_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += annotation_.CalculateSize(_repeated_annotation_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(GeneratedCodeInfo other) {
+      if (other == null) {
+        return;
+      }
+      annotation_.Add(other.annotation_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            annotation_.AddEntriesFrom(input, _repeated_annotation_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            annotation_.AddEntriesFrom(ref input, _repeated_annotation_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the GeneratedCodeInfo message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      public sealed partial class Annotation : pb::IMessage<Annotation>
+      #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          , pb::IBufferMessage
+      #endif
+      {
+        private static readonly pb::MessageParser<Annotation> _parser = new pb::MessageParser<Annotation>(() => new Annotation());
+        private pb::UnknownFieldSet _unknownFields;
+        private int _hasBits0;
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pb::MessageParser<Annotation> Parser { get { return _parser; } }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public static pbr::MessageDescriptor Descriptor {
+          get { return global::LC.Google.Protobuf.Reflection.GeneratedCodeInfo.Descriptor.NestedTypes[0]; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        pbr::MessageDescriptor pb::IMessage.Descriptor {
+          get { return Descriptor; }
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public Annotation() {
+          OnConstruction();
+        }
+
+        partial void OnConstruction();
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public Annotation(Annotation other) : this() {
+          _hasBits0 = other._hasBits0;
+          path_ = other.path_.Clone();
+          sourceFile_ = other.sourceFile_;
+          begin_ = other.begin_;
+          end_ = other.end_;
+          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public Annotation Clone() {
+          return new Annotation(this);
+        }
+
+        /// <summary>Field number for the "path" field.</summary>
+        public const int PathFieldNumber = 1;
+        private static readonly pb::FieldCodec<int> _repeated_path_codec
+            = pb::FieldCodec.ForInt32(10);
+        private readonly pbc::RepeatedField<int> path_ = new pbc::RepeatedField<int>();
+        /// <summary>
+        /// Identifies the element in the original source .proto file. This field
+        /// is formatted the same as SourceCodeInfo.Location.path.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public pbc::RepeatedField<int> Path {
+          get { return path_; }
+        }
+
+        /// <summary>Field number for the "source_file" field.</summary>
+        public const int SourceFileFieldNumber = 2;
+        private readonly static string SourceFileDefaultValue = "";
+
+        private string sourceFile_;
+        /// <summary>
+        /// Identifies the filesystem path to the original source .proto.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public string SourceFile {
+          get { return sourceFile_ ?? SourceFileDefaultValue; }
+          set {
+            sourceFile_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+          }
+        }
+        /// <summary>Gets whether the "source_file" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasSourceFile {
+          get { return sourceFile_ != null; }
+        }
+        /// <summary>Clears the value of the "source_file" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearSourceFile() {
+          sourceFile_ = null;
+        }
+
+        /// <summary>Field number for the "begin" field.</summary>
+        public const int BeginFieldNumber = 3;
+        private readonly static int BeginDefaultValue = 0;
+
+        private int begin_;
+        /// <summary>
+        /// Identifies the starting offset in bytes in the generated code
+        /// that relates to the identified object.
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int Begin {
+          get { if ((_hasBits0 & 1) != 0) { return begin_; } else { return BeginDefaultValue; } }
+          set {
+            _hasBits0 |= 1;
+            begin_ = value;
+          }
+        }
+        /// <summary>Gets whether the "begin" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasBegin {
+          get { return (_hasBits0 & 1) != 0; }
+        }
+        /// <summary>Clears the value of the "begin" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearBegin() {
+          _hasBits0 &= ~1;
+        }
+
+        /// <summary>Field number for the "end" field.</summary>
+        public const int EndFieldNumber = 4;
+        private readonly static int EndDefaultValue = 0;
+
+        private int end_;
+        /// <summary>
+        /// Identifies the ending offset in bytes in the generated code that
+        /// relates to the identified offset. The end offset should be one past
+        /// the last relevant byte (so the length of the text = end - begin).
+        /// </summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int End {
+          get { if ((_hasBits0 & 2) != 0) { return end_; } else { return EndDefaultValue; } }
+          set {
+            _hasBits0 |= 2;
+            end_ = value;
+          }
+        }
+        /// <summary>Gets whether the "end" field is set</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool HasEnd {
+          get { return (_hasBits0 & 2) != 0; }
+        }
+        /// <summary>Clears the value of the "end" field</summary>
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void ClearEnd() {
+          _hasBits0 &= ~2;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override bool Equals(object other) {
+          return Equals(other as Annotation);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public bool Equals(Annotation other) {
+          if (ReferenceEquals(other, null)) {
+            return false;
+          }
+          if (ReferenceEquals(other, this)) {
+            return true;
+          }
+          if(!path_.Equals(other.path_)) return false;
+          if (SourceFile != other.SourceFile) return false;
+          if (Begin != other.Begin) return false;
+          if (End != other.End) return false;
+          return Equals(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override int GetHashCode() {
+          int hash = 1;
+          hash ^= path_.GetHashCode();
+          if (HasSourceFile) hash ^= SourceFile.GetHashCode();
+          if (HasBegin) hash ^= Begin.GetHashCode();
+          if (HasEnd) hash ^= End.GetHashCode();
+          if (_unknownFields != null) {
+            hash ^= _unknownFields.GetHashCode();
+          }
+          return hash;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public override string ToString() {
+          return pb::JsonFormatter.ToDiagnosticString(this);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void WriteTo(pb::CodedOutputStream output) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          output.WriteRawMessage(this);
+        #else
+          path_.WriteTo(output, _repeated_path_codec);
+          if (HasSourceFile) {
+            output.WriteRawTag(18);
+            output.WriteString(SourceFile);
+          }
+          if (HasBegin) {
+            output.WriteRawTag(24);
+            output.WriteInt32(Begin);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(32);
+            output.WriteInt32(End);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(output);
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+          path_.WriteTo(ref output, _repeated_path_codec);
+          if (HasSourceFile) {
+            output.WriteRawTag(18);
+            output.WriteString(SourceFile);
+          }
+          if (HasBegin) {
+            output.WriteRawTag(24);
+            output.WriteInt32(Begin);
+          }
+          if (HasEnd) {
+            output.WriteRawTag(32);
+            output.WriteInt32(End);
+          }
+          if (_unknownFields != null) {
+            _unknownFields.WriteTo(ref output);
+          }
+        }
+        #endif
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public int CalculateSize() {
+          int size = 0;
+          size += path_.CalculateSize(_repeated_path_codec);
+          if (HasSourceFile) {
+            size += 1 + pb::CodedOutputStream.ComputeStringSize(SourceFile);
+          }
+          if (HasBegin) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Begin);
+          }
+          if (HasEnd) {
+            size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
+          }
+          if (_unknownFields != null) {
+            size += _unknownFields.CalculateSize();
+          }
+          return size;
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(Annotation other) {
+          if (other == null) {
+            return;
+          }
+          path_.Add(other.path_);
+          if (other.HasSourceFile) {
+            SourceFile = other.SourceFile;
+          }
+          if (other.HasBegin) {
+            Begin = other.Begin;
+          }
+          if (other.HasEnd) {
+            End = other.End;
+          }
+          _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        public void MergeFrom(pb::CodedInputStream input) {
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+          input.ReadRawMessage(this);
+        #else
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+                break;
+              case 10:
+              case 8: {
+                path_.AddEntriesFrom(input, _repeated_path_codec);
+                break;
+              }
+              case 18: {
+                SourceFile = input.ReadString();
+                break;
+              }
+              case 24: {
+                Begin = input.ReadInt32();
+                break;
+              }
+              case 32: {
+                End = input.ReadInt32();
+                break;
+              }
+            }
+          }
+        #endif
+        }
+
+        #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+        void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+          uint tag;
+          while ((tag = input.ReadTag()) != 0) {
+            switch(tag) {
+              default:
+                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+                break;
+              case 10:
+              case 8: {
+                path_.AddEntriesFrom(ref input, _repeated_path_codec);
+                break;
+              }
+              case 18: {
+                SourceFile = input.ReadString();
+                break;
+              }
+              case 24: {
+                Begin = input.ReadInt32();
+                break;
+              }
+              case 32: {
+                End = input.ReadInt32();
+                break;
+              }
+            }
+          }
+        }
+        #endif
+
+      }
+
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/Reflection/DescriptorBase.cs b/Libs/Google.Protobuf/Reflection/DescriptorBase.cs
new file mode 100644
index 0000000..459e72b
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/DescriptorBase.cs
@@ -0,0 +1,92 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Collections.Generic;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Base class for nearly all descriptors, providing common functionality.
+    /// </summary>
+    public abstract class DescriptorBase : IDescriptor
+    {
+        internal DescriptorBase(FileDescriptor file, string fullName, int index)
+        {
+            File = file;
+            FullName = fullName;
+            Index = index;
+        }
+
+        /// <value>
+        /// The index of this descriptor within its parent descriptor.
+        /// </value>
+        /// <remarks>
+        /// This returns the index of this descriptor within its parent, for
+        /// this descriptor's type. (There can be duplicate values for different
+        /// types, e.g. one enum type with index 0 and one message type with index 0.)
+        /// </remarks>
+        public int Index { get; }
+
+        /// <summary>
+        /// Returns the name of the entity (field, message etc) being described.
+        /// </summary>
+        public abstract string Name { get; }
+
+        /// <summary>
+        /// The fully qualified name of the descriptor's target.
+        /// </summary>
+        public string FullName { get; }
+
+        /// <value>
+        /// The file this descriptor was declared in.
+        /// </value>
+        public FileDescriptor File { get; }
+
+        /// <summary>
+        /// The declaration information about the descriptor, or null if no declaration information
+        /// is available for this descriptor.
+        /// </summary>
+        /// <remarks>
+        /// This information is typically only available for dynamically loaded descriptors,
+        /// for example within a protoc plugin where the full descriptors, including source info,
+        /// are passed to the code by protoc.
+        /// </remarks>
+        public DescriptorDeclaration Declaration => File.GetDeclaration(this);
+
+        /// <summary>
+        /// Retrieves the list of nested descriptors corresponding to the given field number, if any.
+        /// If the field is unknown or not a nested descriptor list, return null to terminate the search.
+        /// The default implementation returns null.
+        /// </summary>
+        internal virtual IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber) => null;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/DescriptorDeclaration.cs b/Libs/Google.Protobuf/Reflection/DescriptorDeclaration.cs
new file mode 100644
index 0000000..bf0cb06
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/DescriptorDeclaration.cs
@@ -0,0 +1,112 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2018 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using static LC.Google.Protobuf.Reflection.SourceCodeInfo.Types;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Provides additional information about the declaration of a descriptor,
+    /// such as source location and comments.
+    /// </summary>
+    public sealed class DescriptorDeclaration
+    {
+        /// <summary>
+        /// The descriptor this declaration relates to.
+        /// </summary>
+        public IDescriptor Descriptor { get; }
+
+        /// <summary>
+        /// The start line of the declaration within the source file. This value is 1-based.
+        /// </summary>
+        public int StartLine { get; }
+        /// <summary>
+        /// The start column of the declaration within the source file. This value is 1-based.
+        /// </summary>
+        public int StartColumn { get; }
+
+        /// <summary>
+        /// // The end line of the declaration within the source file. This value is 1-based.
+        /// </summary>
+        public int EndLine { get; }
+        /// <summary>
+        /// The end column of the declaration within the source file. This value is 1-based, and
+        /// exclusive. (The final character of the declaration is on the column before this value.)
+        /// </summary>
+        public int EndColumn { get; }
+
+        /// <summary>
+        /// Comments appearing before the declaration. Never null, but may be empty. Multi-line comments
+        /// are represented as a newline-separated string. Leading whitespace and the comment marker ("//")
+        /// are removed from each line.
+        /// </summary>
+        public string LeadingComments { get; }
+
+        /// <summary>
+        /// Comments appearing after the declaration. Never null, but may be empty. Multi-line comments
+        /// are represented as a newline-separated string. Leading whitespace and the comment marker ("//")
+        /// are removed from each line.
+        /// </summary>
+        public string TrailingComments { get; }
+
+        /// <summary>
+        /// Comments appearing before the declaration, but separated from it by blank
+        /// lines. Each string represents a newline-separated paragraph of comments.
+        /// Leading whitespace and the comment marker ("//") are removed from each line.
+        /// The list is never null, but may be empty. Likewise each element is never null, but may be empty.
+        /// </summary>
+        public IReadOnlyList<string> LeadingDetachedComments { get; }
+
+        private DescriptorDeclaration(IDescriptor descriptor, Location location)
+        {
+            // TODO: Validation
+            Descriptor = descriptor;
+            bool hasEndLine = location.Span.Count == 4;
+            // Lines and columns are 0-based in the proto.
+            StartLine = location.Span[0] + 1;
+            StartColumn = location.Span[1] + 1;
+            EndLine = hasEndLine ? location.Span[2] + 1 : StartLine;
+            EndColumn = location.Span[hasEndLine ? 3 : 2] + 1;
+            LeadingComments = location.LeadingComments;
+            TrailingComments = location.TrailingComments;
+            LeadingDetachedComments = new ReadOnlyCollection<string>(location.LeadingDetachedComments.ToList());
+        }
+
+        internal static DescriptorDeclaration FromProto(IDescriptor descriptor, Location location) =>
+            new DescriptorDeclaration(descriptor, location);
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/DescriptorPool.cs b/Libs/Google.Protobuf/Reflection/DescriptorPool.cs
new file mode 100644
index 0000000..c6660d0
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/DescriptorPool.cs
@@ -0,0 +1,334 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Contains lookup tables containing all the descriptors defined in a particular file.
+    /// </summary>
+    internal sealed class DescriptorPool
+    {
+        private readonly IDictionary<string, IDescriptor> descriptorsByName =
+            new Dictionary<string, IDescriptor>();
+
+        private readonly IDictionary<ObjectIntPair<IDescriptor>, FieldDescriptor> fieldsByNumber =
+            new Dictionary<ObjectIntPair<IDescriptor>, FieldDescriptor>();
+
+        private readonly IDictionary<ObjectIntPair<IDescriptor>, EnumValueDescriptor> enumValuesByNumber =
+            new Dictionary<ObjectIntPair<IDescriptor>, EnumValueDescriptor>();
+
+        private readonly HashSet<FileDescriptor> dependencies;
+
+        internal DescriptorPool(IEnumerable<FileDescriptor> dependencyFiles)
+        {
+            dependencies = new HashSet<FileDescriptor>();
+            foreach (var dependencyFile in dependencyFiles)
+            {
+                dependencies.Add(dependencyFile);
+                ImportPublicDependencies(dependencyFile);
+            }
+
+            foreach (FileDescriptor dependency in dependencyFiles)
+            {
+                AddPackage(dependency.Package, dependency);
+            }
+        }
+
+        private void ImportPublicDependencies(FileDescriptor file)
+        {
+            foreach (FileDescriptor dependency in file.PublicDependencies)
+            {
+                if (dependencies.Add(dependency))
+                {
+                    ImportPublicDependencies(dependency);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finds a symbol of the given name within the pool.
+        /// </summary>
+        /// <typeparam name="T">The type of symbol to look for</typeparam>
+        /// <param name="fullName">Fully-qualified name to look up</param>
+        /// <returns>The symbol with the given name and type,
+        /// or null if the symbol doesn't exist or has the wrong type</returns>
+        internal T FindSymbol<T>(string fullName) where T : class
+        {
+            IDescriptor result;
+            descriptorsByName.TryGetValue(fullName, out result);
+            T descriptor = result as T;
+            if (descriptor != null)
+            {
+                return descriptor;
+            }
+
+            // dependencies contains direct dependencies and any *public* dependencies
+            // of those dependencies (transitively)... so we don't need to recurse here.
+            foreach (FileDescriptor dependency in dependencies)
+            {
+                dependency.DescriptorPool.descriptorsByName.TryGetValue(fullName, out result);
+                descriptor = result as T;
+                if (descriptor != null)
+                {
+                    return descriptor;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Adds a package to the symbol tables. If a package by the same name
+        /// already exists, that is fine, but if some other kind of symbol
+        /// exists under the same name, an exception is thrown. If the package
+        /// has multiple components, this also adds the parent package(s).
+        /// </summary>
+        internal void AddPackage(string fullName, FileDescriptor file)
+        {
+            int dotpos = fullName.LastIndexOf('.');
+            String name;
+            if (dotpos != -1)
+            {
+                AddPackage(fullName.Substring(0, dotpos), file);
+                name = fullName.Substring(dotpos + 1);
+            }
+            else
+            {
+                name = fullName;
+            }
+
+            IDescriptor old;
+            if (descriptorsByName.TryGetValue(fullName, out old))
+            {
+                if (!(old is PackageDescriptor))
+                {
+                    throw new DescriptorValidationException(file,
+                                                            "\"" + name +
+                                                            "\" is already defined (as something other than a " +
+                                                            "package) in file \"" + old.File.Name + "\".");
+                }
+            }
+            descriptorsByName[fullName] = new PackageDescriptor(name, fullName, file);
+        }
+
+        /// <summary>
+        /// Adds a symbol to the symbol table.
+        /// </summary>
+        /// <exception cref="DescriptorValidationException">The symbol already existed
+        /// in the symbol table.</exception>
+        internal void AddSymbol(IDescriptor descriptor)
+        {
+            ValidateSymbolName(descriptor);
+            String fullName = descriptor.FullName;
+
+            IDescriptor old;
+            if (descriptorsByName.TryGetValue(fullName, out old))
+            {
+                int dotPos = fullName.LastIndexOf('.');
+                string message;
+                if (descriptor.File == old.File)
+                {
+                    if (dotPos == -1)
+                    {
+                        message = "\"" + fullName + "\" is already defined.";
+                    }
+                    else
+                    {
+                        message = "\"" + fullName.Substring(dotPos + 1) + "\" is already defined in \"" +
+                                  fullName.Substring(0, dotPos) + "\".";
+                    }
+                }
+                else
+                {
+                    message = "\"" + fullName + "\" is already defined in file \"" + old.File.Name + "\".";
+                }
+                throw new DescriptorValidationException(descriptor, message);
+            }
+            descriptorsByName[fullName] = descriptor;
+        }
+
+        private static readonly Regex ValidationRegex = new Regex("^[_A-Za-z][_A-Za-z0-9]*$",
+                                                                  FrameworkPortability.CompiledRegexWhereAvailable);
+
+        /// <summary>
+        /// Verifies that the descriptor's name is valid (i.e. it contains
+        /// only letters, digits and underscores, and does not start with a digit).
+        /// </summary>
+        /// <param name="descriptor"></param>
+        private static void ValidateSymbolName(IDescriptor descriptor)
+        {
+            if (descriptor.Name == "")
+            {
+                throw new DescriptorValidationException(descriptor, "Missing name.");
+            }
+            if (!ValidationRegex.IsMatch(descriptor.Name))
+            {
+                throw new DescriptorValidationException(descriptor,
+                                                        "\"" + descriptor.Name + "\" is not a valid identifier.");
+            }
+        }
+
+        /// <summary>
+        /// Returns the field with the given number in the given descriptor,
+        /// or null if it can't be found.
+        /// </summary>
+        internal FieldDescriptor FindFieldByNumber(MessageDescriptor messageDescriptor, int number)
+        {
+            FieldDescriptor ret;
+            fieldsByNumber.TryGetValue(new ObjectIntPair<IDescriptor>(messageDescriptor, number), out ret);
+            return ret;
+        }
+
+        internal EnumValueDescriptor FindEnumValueByNumber(EnumDescriptor enumDescriptor, int number)
+        {
+            EnumValueDescriptor ret;
+            enumValuesByNumber.TryGetValue(new ObjectIntPair<IDescriptor>(enumDescriptor, number), out ret);
+            return ret;
+        }
+
+        /// <summary>
+        /// Adds a field to the fieldsByNumber table.
+        /// </summary>
+        /// <exception cref="DescriptorValidationException">A field with the same
+        /// containing type and number already exists.</exception>
+        internal void AddFieldByNumber(FieldDescriptor field)
+        {
+            // for extensions, we use the extended type, otherwise we use the containing type
+            ObjectIntPair<IDescriptor> key = new ObjectIntPair<IDescriptor>(field.Proto.HasExtendee ? field.ExtendeeType : field.ContainingType, field.FieldNumber);
+            FieldDescriptor old;
+            if (fieldsByNumber.TryGetValue(key, out old))
+            {
+                throw new DescriptorValidationException(field, "Field number " + field.FieldNumber +
+                                                               "has already been used in \"" +
+                                                               field.ContainingType.FullName +
+                                                               "\" by field \"" + old.Name + "\".");
+            }
+            fieldsByNumber[key] = field;
+        }
+
+        /// <summary>
+        /// Adds an enum value to the enumValuesByNumber table. If an enum value
+        /// with the same type and number already exists, this method does nothing.
+        /// (This is allowed; the first value defined with the number takes precedence.)
+        /// </summary>
+        internal void AddEnumValueByNumber(EnumValueDescriptor enumValue)
+        {
+            ObjectIntPair<IDescriptor> key = new ObjectIntPair<IDescriptor>(enumValue.EnumDescriptor, enumValue.Number);
+            if (!enumValuesByNumber.ContainsKey(key))
+            {
+                enumValuesByNumber[key] = enumValue;
+            }
+        }
+
+        /// <summary>
+        /// Looks up a descriptor by name, relative to some other descriptor.
+        /// The name may be fully-qualified (with a leading '.'), partially-qualified,
+        /// or unqualified. C++-like name lookup semantics are used to search for the
+        /// matching descriptor.
+        /// </summary>
+        /// <remarks>
+        /// This isn't heavily optimized, but it's only used during cross linking anyway.
+        /// If it starts being used more widely, we should look at performance more carefully.
+        /// </remarks>
+        internal IDescriptor LookupSymbol(string name, IDescriptor relativeTo)
+        {
+            IDescriptor result;
+            if (name.StartsWith("."))
+            {
+                // Fully-qualified name.
+                result = FindSymbol<IDescriptor>(name.Substring(1));
+            }
+            else
+            {
+                // If "name" is a compound identifier, we want to search for the
+                // first component of it, then search within it for the rest.
+                int firstPartLength = name.IndexOf('.');
+                string firstPart = firstPartLength == -1 ? name : name.Substring(0, firstPartLength);
+
+                // We will search each parent scope of "relativeTo" looking for the
+                // symbol.
+                StringBuilder scopeToTry = new StringBuilder(relativeTo.FullName);
+
+                while (true)
+                {
+                    // Chop off the last component of the scope.
+
+                    int dotpos = scopeToTry.ToString().LastIndexOf(".");
+                    if (dotpos == -1)
+                    {
+                        result = FindSymbol<IDescriptor>(name);
+                        break;
+                    }
+                    else
+                    {
+                        scopeToTry.Length = dotpos + 1;
+
+                        // Append firstPart and try to find.
+                        scopeToTry.Append(firstPart);
+                        result = FindSymbol<IDescriptor>(scopeToTry.ToString());
+
+                        if (result != null)
+                        {
+                            if (firstPartLength != -1)
+                            {
+                                // We only found the first part of the symbol.  Now look for
+                                // the whole thing.  If this fails, we *don't* want to keep
+                                // searching parent scopes.
+                                scopeToTry.Length = dotpos + 1;
+                                scopeToTry.Append(name);
+                                result = FindSymbol<IDescriptor>(scopeToTry.ToString());
+                            }
+                            break;
+                        }
+
+                        // Not found.  Remove the name so we can try again.
+                        scopeToTry.Length = dotpos;
+                    }
+                }
+            }
+
+            if (result == null)
+            {
+                throw new DescriptorValidationException(relativeTo, "\"" + name + "\" is not defined.");
+            }
+            else
+            {
+                return result;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/DescriptorUtil.cs b/Libs/Google.Protobuf/Reflection/DescriptorUtil.cs
new file mode 100644
index 0000000..f5da0ff
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/DescriptorUtil.cs
@@ -0,0 +1,64 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Internal class containing utility methods when working with descriptors.
+    /// </summary>
+    internal static class DescriptorUtil
+    {
+        /// <summary>
+        /// Equivalent to Func[TInput, int, TOutput] but usable in .NET 2.0. Only used to convert
+        /// arrays.
+        /// </summary>
+        internal delegate TOutput IndexedConverter<TInput, TOutput>(TInput element, int index);
+
+        /// <summary>
+        /// Converts the given array into a read-only list, applying the specified conversion to
+        /// each input element.
+        /// </summary>
+        internal static IList<TOutput> ConvertAndMakeReadOnly<TInput, TOutput>
+            (IList<TInput> input, IndexedConverter<TInput, TOutput> converter)
+        {
+            TOutput[] array = new TOutput[input.Count];
+            for (int i = 0; i < array.Length; i++)
+            {
+                array[i] = converter(input[i], i);
+            }
+            return new ReadOnlyCollection<TOutput>(array);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/DescriptorValidationException.cs b/Libs/Google.Protobuf/Reflection/DescriptorValidationException.cs
new file mode 100644
index 0000000..bdaf396
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/DescriptorValidationException.cs
@@ -0,0 +1,80 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Thrown when building descriptors fails because the source DescriptorProtos
+    /// are not valid.
+    /// </summary>
+    public sealed class DescriptorValidationException : Exception
+    {
+        private readonly String name;
+        private readonly string description;
+
+        /// <value>
+        /// The full name of the descriptor where the error occurred.
+        /// </value>
+        public String ProblemSymbolName
+        {
+            get { return name; }
+        }
+
+        /// <value>
+        /// A human-readable description of the error. (The Message property
+        /// is made up of the descriptor's name and this description.)
+        /// </value>
+        public string Description
+        {
+            get { return description; }
+        }
+
+        internal DescriptorValidationException(IDescriptor problemDescriptor, string description) :
+            base(problemDescriptor.FullName + ": " + description)
+        {
+            // Note that problemDescriptor may be partially uninitialized, so we
+            // don't want to expose it directly to the user.  So, we only provide
+            // the name and the original proto.
+            name = problemDescriptor.FullName;
+            this.description = description;
+        }
+
+        internal DescriptorValidationException(IDescriptor problemDescriptor, string description, Exception cause) :
+            base(problemDescriptor.FullName + ": " + description, cause)
+        {
+            name = problemDescriptor.FullName;
+            this.description = description;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/EnumDescriptor.cs b/Libs/Google.Protobuf/Reflection/EnumDescriptor.cs
new file mode 100644
index 0000000..09a5ebb
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/EnumDescriptor.cs
@@ -0,0 +1,161 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+using System.Collections.Generic;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Descriptor for an enum type in a .proto file.
+    /// </summary>
+    public sealed class EnumDescriptor : DescriptorBase
+    {
+        private readonly EnumDescriptorProto proto;
+        private readonly MessageDescriptor containingType;
+        private readonly IList<EnumValueDescriptor> values;
+        private readonly Type clrType;
+
+        internal EnumDescriptor(EnumDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index, Type clrType)
+            : base(file, file.ComputeFullName(parent, proto.Name), index)
+        {
+            this.proto = proto;
+            this.clrType = clrType;
+            containingType = parent;
+
+            if (proto.Value.Count == 0)
+            {
+                // We cannot allow enums with no values because this would mean there
+                // would be no valid default value for fields of this type.
+                throw new DescriptorValidationException(this, "Enums must contain at least one value.");
+            }
+
+            values = DescriptorUtil.ConvertAndMakeReadOnly(proto.Value,
+                                                           (value, i) => new EnumValueDescriptor(value, file, this, i));
+
+            File.DescriptorPool.AddSymbol(this);
+        }
+
+        internal EnumDescriptorProto Proto { get { return proto; } }
+
+        /// <summary>
+        /// The brief name of the descriptor's target.
+        /// </summary>
+        public override string Name { get { return proto.Name; } }
+
+        internal override IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
+        {
+            switch (fieldNumber)
+            {
+                case EnumDescriptorProto.ValueFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) Values;
+                default:
+                    return null;
+            }
+        }
+
+        /// <summary>
+        /// The CLR type for this enum. For generated code, this will be a CLR enum type.
+        /// </summary>
+        public Type ClrType { get { return clrType; } }
+
+        /// <value>
+        /// If this is a nested type, get the outer descriptor, otherwise null.
+        /// </value>
+        public MessageDescriptor ContainingType
+        {
+            get { return containingType; }
+        }
+
+        /// <value>
+        /// An unmodifiable list of defined value descriptors for this enum.
+        /// </value>
+        public IList<EnumValueDescriptor> Values
+        {
+            get { return values; }
+        }
+
+        /// <summary>
+        /// Finds an enum value by number. If multiple enum values have the
+        /// same number, this returns the first defined value with that number.
+        /// If there is no value for the given number, this returns <c>null</c>.
+        /// </summary>
+        public EnumValueDescriptor FindValueByNumber(int number)
+        {
+            return File.DescriptorPool.FindEnumValueByNumber(this, number);
+        }
+
+        /// <summary>
+        /// Finds an enum value by name.
+        /// </summary>
+        /// <param name="name">The unqualified name of the value (e.g. "FOO").</param>
+        /// <returns>The value's descriptor, or null if not found.</returns>
+        public EnumValueDescriptor FindValueByName(string name)
+        {
+            return File.DescriptorPool.FindSymbol<EnumValueDescriptor>(FullName + "." + name);
+        }
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this enum.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
+        public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>EnumOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public EnumOptions GetOptions() => Proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value enum option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<EnumOptions, T> extension)
+        {
+            var value = Proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value enum option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public RepeatedField<T> GetOption<T>(RepeatedExtension<EnumOptions, T> extension)
+        {
+            return Proto.Options.GetExtension(extension).Clone();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/EnumValueDescriptor.cs b/Libs/Google.Protobuf/Reflection/EnumValueDescriptor.cs
new file mode 100644
index 0000000..5556751
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/EnumValueDescriptor.cs
@@ -0,0 +1,107 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Descriptor for a single enum value within an enum in a .proto file.
+    /// </summary>
+    public sealed class EnumValueDescriptor : DescriptorBase
+    {
+        private readonly EnumDescriptor enumDescriptor;
+        private readonly EnumValueDescriptorProto proto;
+
+        internal EnumValueDescriptor(EnumValueDescriptorProto proto, FileDescriptor file,
+                                     EnumDescriptor parent, int index)
+            : base(file, parent.FullName + "." + proto.Name, index)
+        {
+            this.proto = proto;
+            enumDescriptor = parent;
+            file.DescriptorPool.AddSymbol(this);
+            file.DescriptorPool.AddEnumValueByNumber(this);
+        }
+
+        internal EnumValueDescriptorProto Proto { get { return proto; } }
+
+        /// <summary>
+        /// Returns the name of the enum value described by this object.
+        /// </summary>
+        public override string Name { get { return proto.Name; } }
+
+        /// <summary>
+        /// Returns the number associated with this enum value.
+        /// </summary>
+        public int Number { get { return Proto.Number; } }
+
+        /// <summary>
+        /// Returns the enum descriptor that this value is part of.
+        /// </summary>
+        public EnumDescriptor EnumDescriptor { get { return enumDescriptor; } }
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this enum value.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
+        public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>EnumValueOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public EnumValueOptions GetOptions() => Proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value enum value option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<EnumValueOptions, T> extension)
+        {
+            var value = Proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value enum value option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public RepeatedField<T> GetOption<T>(RepeatedExtension<EnumValueOptions, T> extension)
+        {
+            return Proto.Options.GetExtension(extension).Clone();
+        }
+    }
+}
+ 
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/ExtensionAccessor.cs b/Libs/Google.Protobuf/Reflection/ExtensionAccessor.cs
new file mode 100644
index 0000000..79c6053
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/ExtensionAccessor.cs
@@ -0,0 +1,69 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf.Reflection
+{
+    internal sealed class ExtensionAccessor : IFieldAccessor
+    {
+        private readonly Extension extension;
+        private readonly ReflectionUtil.IExtensionReflectionHelper helper;
+
+        internal ExtensionAccessor(FieldDescriptor descriptor)
+        {
+            Descriptor = descriptor;
+            extension = descriptor.Extension;
+            helper = ReflectionUtil.CreateExtensionHelper(extension);
+        }
+
+        public FieldDescriptor Descriptor { get; }
+
+        public void Clear(IMessage message)
+        {
+            helper.ClearExtension(message);
+        }
+
+        public bool HasValue(IMessage message)
+        {
+            return helper.HasExtension(message);
+        }
+
+        public object GetValue(IMessage message)
+        {
+            return helper.GetExtension(message);
+        }
+
+        public void SetValue(IMessage message, object value)
+        {
+            helper.SetExtension(message, value);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/ExtensionCollection.cs b/Libs/Google.Protobuf/Reflection/ExtensionCollection.cs
new file mode 100644
index 0000000..288aa19
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/ExtensionCollection.cs
@@ -0,0 +1,126 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// A collection to simplify retrieving the descriptors of extensions in a descriptor for a message
+    /// </summary>
+    public sealed class ExtensionCollection
+    {
+        private IDictionary<MessageDescriptor, IList<FieldDescriptor>> extensionsByTypeInDeclarationOrder;
+        private IDictionary<MessageDescriptor, IList<FieldDescriptor>> extensionsByTypeInNumberOrder;
+
+        internal ExtensionCollection(FileDescriptor file, Extension[] extensions)
+        {
+            UnorderedExtensions = DescriptorUtil.ConvertAndMakeReadOnly(
+                file.Proto.Extension,
+                (extension, i) => {
+                    if (extensions?.Length != 0)
+                    {
+                        return new FieldDescriptor(extension, file, null, i, null, extensions?[i]);
+                    }
+                    else
+                    {
+                        return new FieldDescriptor(extension, file, null, i, null, null); // return null if there's no extensions in this array for old code-gen
+                    }
+                });
+        }
+
+        internal ExtensionCollection(MessageDescriptor message, Extension[] extensions)
+        {
+            UnorderedExtensions = DescriptorUtil.ConvertAndMakeReadOnly(
+                message.Proto.Extension,
+                (extension, i) => {
+                    if (extensions?.Length != 0)
+                    {
+                        return new FieldDescriptor(extension, message.File, message, i, null, extensions?[i]);
+                    }
+                    else
+                    {
+                        return new FieldDescriptor(extension, message.File, message, i, null, null);
+                    }
+                });
+        }
+
+        /// <summary>
+        /// Returns a readonly list of all the extensions defined in this type in 
+        /// the order they were defined in the source .proto file
+        /// </summary>
+        public IList<FieldDescriptor> UnorderedExtensions { get; }
+
+        /// <summary>
+        /// Returns a readonly list of all the extensions define in this type that extend 
+        /// the provided descriptor type in the order they were defined in the source .proto file
+        /// </summary>
+        public IList<FieldDescriptor> GetExtensionsInDeclarationOrder(MessageDescriptor descriptor)
+        {
+            return extensionsByTypeInDeclarationOrder[descriptor];
+        }
+
+        /// <summary>
+        /// Returns a readonly list of all the extensions define in this type that extend 
+        /// the provided descriptor type in accending field order
+        /// </summary>
+        public IList<FieldDescriptor> GetExtensionsInNumberOrder(MessageDescriptor descriptor)
+        {
+            return extensionsByTypeInNumberOrder[descriptor];
+        }
+
+        internal void CrossLink()
+        {
+            Dictionary<MessageDescriptor, IList<FieldDescriptor>> declarationOrder = new Dictionary<MessageDescriptor, IList<FieldDescriptor>>();
+            foreach (FieldDescriptor descriptor in UnorderedExtensions)
+            {
+                descriptor.CrossLink();
+
+                IList<FieldDescriptor> list;
+                if (!declarationOrder.TryGetValue(descriptor.ExtendeeType, out list))
+                {
+                    list = new List<FieldDescriptor>();
+                    declarationOrder.Add(descriptor.ExtendeeType, list);
+                }
+
+                list.Add(descriptor);
+            }
+
+            extensionsByTypeInDeclarationOrder = declarationOrder
+                .ToDictionary(kvp => kvp.Key, kvp => (IList<FieldDescriptor>)new ReadOnlyCollection<FieldDescriptor>(kvp.Value));
+            extensionsByTypeInNumberOrder = declarationOrder
+                .ToDictionary(kvp => kvp.Key, kvp => (IList<FieldDescriptor>)new ReadOnlyCollection<FieldDescriptor>(kvp.Value.OrderBy(field => field.FieldNumber).ToArray()));
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/FieldAccessorBase.cs b/Libs/Google.Protobuf/Reflection/FieldAccessorBase.cs
new file mode 100644
index 0000000..04cc5b1
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/FieldAccessorBase.cs
@@ -0,0 +1,64 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Reflection;
+using LC.Google.Protobuf.Compatibility;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Base class for field accessors.
+    /// </summary>
+    internal abstract class FieldAccessorBase : IFieldAccessor
+    {
+        private readonly Func<IMessage, object> getValueDelegate;
+        private readonly FieldDescriptor descriptor;
+
+        internal FieldAccessorBase(PropertyInfo property, FieldDescriptor descriptor)
+        {
+            this.descriptor = descriptor;
+            getValueDelegate = ReflectionUtil.CreateFuncIMessageObject(property.GetGetMethod());
+        }
+
+        public FieldDescriptor Descriptor { get { return descriptor; } }
+
+        public object GetValue(IMessage message)
+        {
+            return getValueDelegate(message);
+        }
+
+        public abstract bool HasValue(IMessage message);
+        public abstract void Clear(IMessage message);
+        public abstract void SetValue(IMessage message, object value);
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/FieldDescriptor.cs b/Libs/Google.Protobuf/Reflection/FieldDescriptor.cs
new file mode 100644
index 0000000..ac85195
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/FieldDescriptor.cs
@@ -0,0 +1,455 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using LC.Google.Protobuf.Compatibility;
+using System;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Descriptor for a field or extension within a message in a .proto file.
+    /// </summary>
+    public sealed class FieldDescriptor : DescriptorBase, IComparable<FieldDescriptor>
+    {
+        private EnumDescriptor enumType;
+        private MessageDescriptor extendeeType;
+        private MessageDescriptor messageType;
+        private FieldType fieldType;
+        private readonly string propertyName; // Annoyingly, needed in Crosslink.
+        private IFieldAccessor accessor;
+
+        /// <summary>
+        /// Get the field's containing message type, or <c>null</c> if it is a field defined at the top level of a file as an extension.
+        /// </summary>
+        public MessageDescriptor ContainingType { get; }
+
+        /// <summary>
+        /// Returns the oneof containing this field, or <c>null</c> if it is not part of a oneof.
+        /// </summary>
+        public OneofDescriptor ContainingOneof { get; }
+
+        /// <summary>
+        /// Returns the oneof containing this field if it's a "real" oneof, or <c>null</c> if either this
+        /// field is not part of a oneof, or the oneof is synthetic.
+        /// </summary>
+        public OneofDescriptor RealContainingOneof => ContainingOneof?.IsSynthetic == false ? ContainingOneof : null;
+
+        /// <summary>
+        /// The effective JSON name for this field. This is usually the lower-camel-cased form of the field name,
+        /// but can be overridden using the <c>json_name</c> option in the .proto file.
+        /// </summary>
+        public string JsonName { get; }
+
+        /// <summary>
+        /// Indicates whether this field supports presence, either implicitly (e.g. due to it being a message
+        /// type field) or explicitly via Has/Clear members. If this returns true, it is safe to call
+        /// <see cref="IFieldAccessor.Clear(IMessage)"/> and <see cref="IFieldAccessor.HasValue(IMessage)"/>
+        /// on this field's accessor with a suitable message.
+        /// </summary>
+        public bool HasPresence =>
+            Extension != null ? !Extension.IsRepeated
+            : IsRepeated ? false
+            : IsMap ? false
+            : FieldType == FieldType.Message ? true
+            // This covers "real oneof members" and "proto3 optional fields"
+            : ContainingOneof != null ? true
+            : File.Syntax == Syntax.Proto2;
+
+        internal FieldDescriptorProto Proto { get; }
+
+        /// <summary>
+        /// An extension identifier for this field, or <c>null</c> if this field isn't an extension.
+        /// </summary>
+        public Extension Extension { get; }
+
+        internal FieldDescriptor(FieldDescriptorProto proto, FileDescriptor file,
+                                 MessageDescriptor parent, int index, string propertyName, Extension extension)
+            : base(file, file.ComputeFullName(parent, proto.Name), index)
+        {
+            Proto = proto;
+            if (proto.Type != 0)
+            {
+                fieldType = GetFieldTypeFromProtoType(proto.Type);
+            }
+
+            if (FieldNumber <= 0)
+            {
+                throw new DescriptorValidationException(this, "Field numbers must be positive integers.");
+            }
+            ContainingType = parent;
+            if (proto.HasOneofIndex)
+            {
+                if (proto.OneofIndex < 0 || proto.OneofIndex >= parent.Proto.OneofDecl.Count)
+                {
+                    throw new DescriptorValidationException(this,
+                        $"FieldDescriptorProto.oneof_index is out of range for type {parent.Name}");
+                }
+                ContainingOneof = parent.Oneofs[proto.OneofIndex];
+            }
+
+            file.DescriptorPool.AddSymbol(this);
+            // We can't create the accessor until we've cross-linked, unfortunately, as we
+            // may not know whether the type of the field is a map or not. Remember the property name
+            // for later.
+            // We could trust the generated code and check whether the type of the property is
+            // a MapField, but that feels a tad nasty.
+            this.propertyName = propertyName;
+            Extension = extension;
+            JsonName =  Proto.JsonName == "" ? JsonFormatter.ToJsonName(Proto.Name) : Proto.JsonName;
+        }
+
+
+        /// <summary>
+        /// The brief name of the descriptor's target.
+        /// </summary>
+        public override string Name => Proto.Name;
+
+        /// <summary>
+        /// Returns the accessor for this field.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// While a <see cref="FieldDescriptor"/> describes the field, it does not provide
+        /// any way of obtaining or changing the value of the field within a specific message;
+        /// that is the responsibility of the accessor.
+        /// </para>
+        /// <para>
+        /// In descriptors for generated code, the value returned by this property will be non-null for all
+        /// regular fields. However, if a message containing a map field is introspected, the list of nested messages will include
+        /// an auto-generated nested key/value pair message for the field. This is not represented in any
+        /// generated type, and the value of the map field itself is represented by a dictionary in the
+        /// reflection API. There are never instances of those "hidden" messages, so no accessor is provided
+        /// and this property will return null.
+        /// </para>
+        /// <para>
+        /// In dynamically loaded descriptors, the value returned by this property will current be null;
+        /// if and when dynamic messages are supported, it will return a suitable accessor to work with
+        /// them.
+        /// </para>
+        /// </remarks>
+        public IFieldAccessor Accessor => accessor;
+
+        /// <summary>
+        /// Maps a field type as included in the .proto file to a FieldType.
+        /// </summary>
+        private static FieldType GetFieldTypeFromProtoType(FieldDescriptorProto.Types.Type type)
+        {
+            switch (type)
+            {
+                case FieldDescriptorProto.Types.Type.Double:
+                    return FieldType.Double;
+                case FieldDescriptorProto.Types.Type.Float:
+                    return FieldType.Float;
+                case FieldDescriptorProto.Types.Type.Int64:
+                    return FieldType.Int64;
+                case FieldDescriptorProto.Types.Type.Uint64:
+                    return FieldType.UInt64;
+                case FieldDescriptorProto.Types.Type.Int32:
+                    return FieldType.Int32;
+                case FieldDescriptorProto.Types.Type.Fixed64:
+                    return FieldType.Fixed64;
+                case FieldDescriptorProto.Types.Type.Fixed32:
+                    return FieldType.Fixed32;
+                case FieldDescriptorProto.Types.Type.Bool:
+                    return FieldType.Bool;
+                case FieldDescriptorProto.Types.Type.String:
+                    return FieldType.String;
+                case FieldDescriptorProto.Types.Type.Group:
+                    return FieldType.Group;
+                case FieldDescriptorProto.Types.Type.Message:
+                    return FieldType.Message;
+                case FieldDescriptorProto.Types.Type.Bytes:
+                    return FieldType.Bytes;
+                case FieldDescriptorProto.Types.Type.Uint32:
+                    return FieldType.UInt32;
+                case FieldDescriptorProto.Types.Type.Enum:
+                    return FieldType.Enum;
+                case FieldDescriptorProto.Types.Type.Sfixed32:
+                    return FieldType.SFixed32;
+                case FieldDescriptorProto.Types.Type.Sfixed64:
+                    return FieldType.SFixed64;
+                case FieldDescriptorProto.Types.Type.Sint32:
+                    return FieldType.SInt32;
+                case FieldDescriptorProto.Types.Type.Sint64:
+                    return FieldType.SInt64;
+                default:
+                    throw new ArgumentException("Invalid type specified");
+            }
+        }
+
+        /// <summary>
+        /// Returns <c>true</c> if this field is a repeated field; <c>false</c> otherwise.
+        /// </summary>
+        public bool IsRepeated => Proto.Label == FieldDescriptorProto.Types.Label.Repeated;
+
+        /// <summary>
+        /// Returns <c>true</c> if this field is a required field; <c>false</c> otherwise.
+        /// </summary>
+        public bool IsRequired => Proto.Label == FieldDescriptorProto.Types.Label.Required;
+
+        /// <summary>
+        /// Returns <c>true</c> if this field is a map field; <c>false</c> otherwise.
+        /// </summary>
+        public bool IsMap => fieldType == FieldType.Message && messageType.Proto.Options != null && messageType.Proto.Options.MapEntry;
+
+        /// <summary>
+        /// Returns <c>true</c> if this field is a packed, repeated field; <c>false</c> otherwise.
+        /// </summary>
+        public bool IsPacked
+        {
+            get
+            {
+                if (File.Syntax != Syntax.Proto3)
+                {
+                    return Proto.Options?.Packed ?? false;
+                }
+                else
+                {
+                    return !Proto.Options.HasPacked || Proto.Options.Packed;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns <c>true</c> if this field extends another message type; <c>false</c> otherwise.
+        /// </summary>
+        public bool IsExtension => Proto.HasExtendee;
+
+        /// <summary>
+        /// Returns the type of the field.
+        /// </summary>
+        public FieldType FieldType => fieldType;
+
+        /// <summary>
+        /// Returns the field number declared in the proto file.
+        /// </summary>
+        public int FieldNumber => Proto.Number;
+
+        /// <summary>
+        /// Compares this descriptor with another one, ordering in "canonical" order
+        /// which simply means ascending order by field number. <paramref name="other"/>
+        /// must be a field of the same type, i.e. the <see cref="ContainingType"/> of
+        /// both fields must be the same.
+        /// </summary>
+        public int CompareTo(FieldDescriptor other)
+        {
+            if (other.ContainingType != ContainingType)
+            {
+                throw new ArgumentException("FieldDescriptors can only be compared to other FieldDescriptors " +
+                                            "for fields of the same message type.");
+            }
+            return FieldNumber - other.FieldNumber;
+        }
+
+        /// <summary>
+        /// For enum fields, returns the field's type.
+        /// </summary>
+        public EnumDescriptor EnumType
+        {
+            get
+            {
+                if (fieldType != FieldType.Enum)
+                {
+                    throw new InvalidOperationException("EnumType is only valid for enum fields.");
+                }
+                return enumType;
+            }
+        }
+
+        /// <summary>
+        /// For embedded message and group fields, returns the field's type.
+        /// </summary>
+        public MessageDescriptor MessageType
+        {
+            get
+            {
+                if (fieldType != FieldType.Message && fieldType != FieldType.Group)
+                {
+                    throw new InvalidOperationException("MessageType is only valid for message or group fields.");
+                }
+                return messageType;
+            }
+        }
+
+        /// <summary>
+        /// For extension fields, returns the extended type
+        /// </summary>
+        public MessageDescriptor ExtendeeType
+        {
+            get
+            {
+                if (!Proto.HasExtendee)
+                {
+                    throw new InvalidOperationException("ExtendeeType is only valid for extension fields.");
+                }
+                return extendeeType;
+            }
+        }
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this field.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
+        public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>FieldOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public FieldOptions GetOptions() => Proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value field option for this descriptor
+        /// </summary>
+         [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<FieldOptions, T> extension)
+        {
+            var value = Proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value field option for this descriptor
+        /// </summary>
+         [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public RepeatedField<T> GetOption<T>(RepeatedExtension<FieldOptions, T> extension)
+        {
+            return Proto.Options.GetExtension(extension).Clone();
+        }
+
+        /// <summary>
+        /// Look up and cross-link all field types etc.
+        /// </summary>
+        internal void CrossLink()
+        {
+            if (Proto.HasTypeName)
+            {
+                IDescriptor typeDescriptor =
+                    File.DescriptorPool.LookupSymbol(Proto.TypeName, this);
+
+                if (Proto.HasType)
+                {
+                    // Choose field type based on symbol.
+                    if (typeDescriptor is MessageDescriptor)
+                    {
+                        fieldType = FieldType.Message;
+                    }
+                    else if (typeDescriptor is EnumDescriptor)
+                    {
+                        fieldType = FieldType.Enum;
+                    }
+                    else
+                    {
+                        throw new DescriptorValidationException(this, $"\"{Proto.TypeName}\" is not a type.");
+                    }
+                }
+
+                if (fieldType == FieldType.Message || fieldType == FieldType.Group)
+                {
+                    if (!(typeDescriptor is MessageDescriptor))
+                    {
+                        throw new DescriptorValidationException(this, $"\"{Proto.TypeName}\" is not a message type.");
+                    }
+                    messageType = (MessageDescriptor) typeDescriptor;
+
+                    if (Proto.HasDefaultValue)
+                    {
+                        throw new DescriptorValidationException(this, "Messages can't have default values.");
+                    }
+                }
+                else if (fieldType == FieldType.Enum)
+                {
+                    if (!(typeDescriptor is EnumDescriptor))
+                    {
+                        throw new DescriptorValidationException(this, $"\"{Proto.TypeName}\" is not an enum type.");
+                    }
+                    enumType = (EnumDescriptor) typeDescriptor;
+                }
+                else
+                {
+                    throw new DescriptorValidationException(this, "Field with primitive type has type_name.");
+                }
+            }
+            else
+            {
+                if (fieldType == FieldType.Message || fieldType == FieldType.Enum)
+                {
+                    throw new DescriptorValidationException(this, "Field with message or enum type missing type_name.");
+                }
+            }
+
+            if (Proto.HasExtendee)
+            {
+                extendeeType = File.DescriptorPool.LookupSymbol(Proto.Extendee, this) as MessageDescriptor;
+            }
+
+            // Note: no attempt to perform any default value parsing
+
+            File.DescriptorPool.AddFieldByNumber(this);
+
+            if (ContainingType != null && ContainingType.Proto.Options != null && ContainingType.Proto.Options.MessageSetWireFormat)
+            {
+                throw new DescriptorValidationException(this, "MessageSet format is not supported.");
+            }
+            accessor = CreateAccessor();
+        }
+
+        private IFieldAccessor CreateAccessor()
+        {
+            if (Extension != null)
+            {
+                return new ExtensionAccessor(this);
+            }
+
+            // If we're given no property name, that's because we really don't want an accessor.
+            // This could be because it's a map message, or it could be that we're loading a FileDescriptor dynamically.
+            // TODO: Support dynamic messages.
+            if (propertyName == null)
+            {
+                return null;
+            }
+
+            var property = ContainingType.ClrType.GetProperty(propertyName);
+            if (property == null)
+            {
+                throw new DescriptorValidationException(this, $"Property {propertyName} not found in {ContainingType.ClrType}");
+            }
+            return IsMap ? new MapFieldAccessor(property, this)
+                : IsRepeated ? new RepeatedFieldAccessor(property, this)
+                : (IFieldAccessor) new SingleFieldAccessor(property, this);
+        }
+    }
+}
+ 
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/FieldType.cs b/Libs/Google.Protobuf/Reflection/FieldType.cs
new file mode 100644
index 0000000..c6d0c24
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/FieldType.cs
@@ -0,0 +1,113 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Enumeration of all the possible field types.
+    /// </summary>
+    public enum FieldType
+    {
+        /// <summary>
+        /// The <c>double</c> field type.
+        /// </summary>
+        Double,
+        /// <summary>
+        /// The <c>float</c> field type.
+        /// </summary>
+        Float,
+        /// <summary>
+        /// The <c>int64</c> field type.
+        /// </summary>
+        Int64,
+        /// <summary>
+        /// The <c>uint64</c> field type.
+        /// </summary>
+        UInt64,
+        /// <summary>
+        /// The <c>int32</c> field type.
+        /// </summary>
+        Int32,
+        /// <summary>
+        /// The <c>fixed64</c> field type.
+        /// </summary>
+        Fixed64,
+        /// <summary>
+        /// The <c>fixed32</c> field type.
+        /// </summary>
+        Fixed32,
+        /// <summary>
+        /// The <c>bool</c> field type.
+        /// </summary>
+        Bool,
+        /// <summary>
+        /// The <c>string</c> field type.
+        /// </summary>
+        String,
+        /// <summary>
+        /// The field type used for groups.
+        /// </summary>
+        Group,
+        /// <summary>
+        /// The field type used for message fields.
+        /// </summary>
+        Message,
+        /// <summary>
+        /// The <c>bytes</c> field type.
+        /// </summary>
+        Bytes,
+        /// <summary>
+        /// The <c>uint32</c> field type.
+        /// </summary>
+        UInt32,
+        /// <summary>
+        /// The <c>sfixed32</c> field type.
+        /// </summary>
+        SFixed32,
+        /// <summary>
+        /// The <c>sfixed64</c> field type.
+        /// </summary>
+        SFixed64,
+        /// <summary>
+        /// The <c>sint32</c> field type.
+        /// </summary>
+        SInt32,
+        /// <summary>
+        /// The <c>sint64</c> field type.
+        /// </summary>
+        SInt64,
+        /// <summary>
+        /// The field type used for enum fields.
+        /// </summary>
+        Enum
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/FileDescriptor.cs b/Libs/Google.Protobuf/Reflection/FileDescriptor.cs
new file mode 100644
index 0000000..6724ef5
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/FileDescriptor.cs
@@ -0,0 +1,608 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using LC.Google.Protobuf.WellKnownTypes;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using static LC.Google.Protobuf.Reflection.SourceCodeInfo.Types;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// The syntax of a .proto file
+    /// </summary>
+    public enum Syntax
+    {
+        /// <summary>
+        /// Proto2 syntax
+        /// </summary>
+        Proto2,
+        /// <summary>
+        /// Proto3 syntax
+        /// </summary>
+        Proto3,
+        /// <summary>
+        /// An unknown declared syntax
+        /// </summary>
+        Unknown
+    }
+
+    /// <summary>
+    /// Describes a .proto file, including everything defined within.
+    /// IDescriptor is implemented such that the File property returns this descriptor,
+    /// and the FullName is the same as the Name.
+    /// </summary>
+    public sealed class FileDescriptor : IDescriptor
+    {
+        // Prevent linker failures when using IL2CPP with the well-known types.
+        static FileDescriptor()
+        {
+            ForceReflectionInitialization<Syntax>();
+            ForceReflectionInitialization<NullValue>();
+            ForceReflectionInitialization<Field.Types.Cardinality>();
+            ForceReflectionInitialization<Field.Types.Kind>();
+            ForceReflectionInitialization<Value.KindOneofCase>();
+        }
+
+        private readonly Lazy<Dictionary<IDescriptor, DescriptorDeclaration>> declarations;
+
+        private FileDescriptor(ByteString descriptorData, FileDescriptorProto proto, IEnumerable<FileDescriptor> dependencies, DescriptorPool pool, bool allowUnknownDependencies, GeneratedClrTypeInfo generatedCodeInfo)
+        {
+            SerializedData = descriptorData;
+            DescriptorPool = pool;
+            Proto = proto;
+            Dependencies = new ReadOnlyCollection<FileDescriptor>(dependencies.ToList());
+
+            PublicDependencies = DeterminePublicDependencies(this, proto, dependencies, allowUnknownDependencies);
+
+            pool.AddPackage(Package, this);
+
+            MessageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageType,
+                                                                 (message, index) =>
+                                                                 new MessageDescriptor(message, this, null, index, generatedCodeInfo?.NestedTypes[index]));
+
+            EnumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumType,
+                                                              (enumType, index) =>
+                                                              new EnumDescriptor(enumType, this, null, index, generatedCodeInfo?.NestedEnums[index]));
+
+            Services = DescriptorUtil.ConvertAndMakeReadOnly(proto.Service,
+                                                             (service, index) =>
+                                                             new ServiceDescriptor(service, this, index));
+
+            Extensions = new ExtensionCollection(this, generatedCodeInfo?.Extensions);
+
+            declarations = new Lazy<Dictionary<IDescriptor, DescriptorDeclaration>>(CreateDeclarationMap, LazyThreadSafetyMode.ExecutionAndPublication);
+
+            if (!proto.HasSyntax || proto.Syntax == "proto2")
+            {
+                Syntax = Syntax.Proto2;
+            }
+            else if (proto.Syntax == "proto3")
+            {
+                Syntax = Syntax.Proto3;
+            }
+            else
+            {
+                Syntax = Syntax.Unknown;
+            }
+        }
+
+        private Dictionary<IDescriptor, DescriptorDeclaration> CreateDeclarationMap()
+        {
+            var dictionary = new Dictionary<IDescriptor, DescriptorDeclaration>();
+            foreach (var location in Proto.SourceCodeInfo?.Location ?? Enumerable.Empty<Location>())
+            {
+                var descriptor = FindDescriptorForPath(location.Path);
+                if (descriptor != null)
+                {
+                    dictionary[descriptor] = DescriptorDeclaration.FromProto(descriptor, location);
+                }
+            }
+            return dictionary;
+        }
+
+        private IDescriptor FindDescriptorForPath(IList<int> path)
+        {
+            // All complete declarations have an even, non-empty path length
+            // (There can be an empty path for a descriptor declaration, but that can't have any comments,
+            // so we currently ignore it.)
+            if (path.Count == 0 || (path.Count & 1) != 0)
+            {
+                return null;
+            }
+            IReadOnlyList<DescriptorBase> topLevelList = GetNestedDescriptorListForField(path[0]);
+            DescriptorBase current = GetDescriptorFromList(topLevelList, path[1]);
+
+            for (int i = 2; current != null && i < path.Count; i += 2)
+            {
+                var list = current.GetNestedDescriptorListForField(path[i]);
+                current = GetDescriptorFromList(list, path[i + 1]);
+            }
+            return current;
+        }
+
+        private DescriptorBase GetDescriptorFromList(IReadOnlyList<DescriptorBase> list, int index)
+        {
+            // This is fine: it may be a newer version of protobuf than we understand, with a new descriptor
+            // field.
+            if (list == null)
+            {
+                return null;
+            }
+            // We *could* return null to silently continue, but this is basically data corruption.
+            if (index < 0 || index >= list.Count)
+            {
+                // We don't have much extra information to give at this point unfortunately. If this becomes a problem,
+                // we can pass in the complete path and report that and the file name.
+                throw new InvalidProtocolBufferException($"Invalid descriptor location path: index out of range");
+            }
+            return list[index];
+        }
+
+        private IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
+        {
+            switch (fieldNumber)
+            {
+                case FileDescriptorProto.ServiceFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) Services;
+                case FileDescriptorProto.MessageTypeFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) MessageTypes;
+                case FileDescriptorProto.EnumTypeFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) EnumTypes;
+                default:
+                    return null;
+            }
+        }
+
+        internal DescriptorDeclaration GetDeclaration(IDescriptor descriptor)
+        {
+            DescriptorDeclaration declaration;
+            declarations.Value.TryGetValue(descriptor, out declaration);
+            return declaration;
+        }
+
+        /// <summary>
+        /// Computes the full name of a descriptor within this file, with an optional parent message.
+        /// </summary>
+        internal string ComputeFullName(MessageDescriptor parent, string name)
+        {
+            if (parent != null)
+            {
+                return parent.FullName + "." + name;
+            }
+            if (Package.Length > 0)
+            {
+                return Package + "." + name;
+            }
+            return name;
+        }
+
+        /// <summary>
+        /// Extracts public dependencies from direct dependencies. This is a static method despite its
+        /// first parameter, as the value we're in the middle of constructing is only used for exceptions.
+        /// </summary>
+        private static IList<FileDescriptor> DeterminePublicDependencies(FileDescriptor @this, FileDescriptorProto proto, IEnumerable<FileDescriptor> dependencies, bool allowUnknownDependencies)
+        {
+            var nameToFileMap = dependencies.ToDictionary(file => file.Name);
+            var publicDependencies = new List<FileDescriptor>();
+            for (int i = 0; i < proto.PublicDependency.Count; i++)
+            {
+                int index = proto.PublicDependency[i];
+                if (index < 0 || index >= proto.Dependency.Count)
+                {
+                    throw new DescriptorValidationException(@this, "Invalid public dependency index.");
+                }
+                string name = proto.Dependency[index];
+                FileDescriptor file;
+                if (!nameToFileMap.TryGetValue(name, out file))
+                {
+                    if (!allowUnknownDependencies)
+                    {
+                        throw new DescriptorValidationException(@this, "Invalid public dependency: " + name);
+                    }
+                    // Ignore unknown dependencies.
+                }
+                else
+                {
+                    publicDependencies.Add(file);
+                }
+            }
+            return new ReadOnlyCollection<FileDescriptor>(publicDependencies);
+        }
+
+        /// <value>
+        /// The descriptor in its protocol message representation.
+        /// </value>
+        internal FileDescriptorProto Proto { get; }
+
+        /// <summary>
+        /// The syntax of the file
+        /// </summary>
+        public Syntax Syntax { get; }
+
+        /// <value>
+        /// The file name.
+        /// </value>
+        public string Name => Proto.Name;
+
+        /// <summary>
+        /// The package as declared in the .proto file. This may or may not
+        /// be equivalent to the .NET namespace of the generated classes.
+        /// </summary>
+        public string Package => Proto.Package;
+
+        /// <value>
+        /// Unmodifiable list of top-level message types declared in this file.
+        /// </value>
+        public IList<MessageDescriptor> MessageTypes { get; }
+
+        /// <value>
+        /// Unmodifiable list of top-level enum types declared in this file.
+        /// </value>
+        public IList<EnumDescriptor> EnumTypes { get; }
+
+        /// <value>
+        /// Unmodifiable list of top-level services declared in this file.
+        /// </value>
+        public IList<ServiceDescriptor> Services { get; }
+
+        /// <summary>
+        /// Unmodifiable list of top-level extensions declared in this file.
+        /// Note that some extensions may be incomplete (FieldDescriptor.Extension may be null)
+        /// if this descriptor was generated using a version of protoc that did not fully
+        /// support extensions in C#.
+        /// </summary>
+        public ExtensionCollection Extensions { get; }
+
+        /// <value>
+        /// Unmodifiable list of this file's dependencies (imports).
+        /// </value>
+        public IList<FileDescriptor> Dependencies { get; }
+
+        /// <value>
+        /// Unmodifiable list of this file's public dependencies (public imports).
+        /// </value>
+        public IList<FileDescriptor> PublicDependencies { get; }
+
+        /// <value>
+        /// The original serialized binary form of this descriptor.
+        /// </value>
+        public ByteString SerializedData { get; }
+
+        /// <value>
+        /// Implementation of IDescriptor.FullName - just returns the same as Name.
+        /// </value>
+        string IDescriptor.FullName => Name;
+
+        /// <value>
+        /// Implementation of IDescriptor.File - just returns this descriptor.
+        /// </value>
+        FileDescriptor IDescriptor.File => this;
+
+        /// <value>
+        /// Pool containing symbol descriptors.
+        /// </value>
+        internal DescriptorPool DescriptorPool { get; }
+
+        /// <summary>
+        /// Finds a type (message, enum, service or extension) in the file by name. Does not find nested types.
+        /// </summary>
+        /// <param name="name">The unqualified type name to look for.</param>
+        /// <typeparam name="T">The type of descriptor to look for</typeparam>
+        /// <returns>The type's descriptor, or null if not found.</returns>
+        public T FindTypeByName<T>(String name)
+            where T : class, IDescriptor
+        {
+            // Don't allow looking up nested types.  This will make optimization
+            // easier later.
+            if (name.IndexOf('.') != -1)
+            {
+                return null;
+            }
+            if (Package.Length > 0)
+            {
+                name = Package + "." + name;
+            }
+            T result = DescriptorPool.FindSymbol<T>(name);
+            if (result != null && result.File == this)
+            {
+                return result;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Builds a FileDescriptor from its protocol buffer representation.
+        /// </summary>
+        /// <param name="descriptorData">The original serialized descriptor data.
+        /// We have only limited proto2 support, so serializing FileDescriptorProto
+        /// would not necessarily give us this.</param>
+        /// <param name="proto">The protocol message form of the FileDescriptor.</param>
+        /// <param name="dependencies">FileDescriptors corresponding to all of the
+        /// file's dependencies, in the exact order listed in the .proto file. May be null,
+        /// in which case it is treated as an empty array.</param>
+        /// <param name="allowUnknownDependencies">Whether unknown dependencies are ignored (true) or cause an exception to be thrown (false).</param>
+        /// <param name="generatedCodeInfo">Details about generated code, for the purposes of reflection.</param>
+        /// <exception cref="DescriptorValidationException">If <paramref name="proto"/> is not
+        /// a valid descriptor. This can occur for a number of reasons, such as a field
+        /// having an undefined type or because two messages were defined with the same name.</exception>
+        private static FileDescriptor BuildFrom(ByteString descriptorData, FileDescriptorProto proto, FileDescriptor[] dependencies, bool allowUnknownDependencies, GeneratedClrTypeInfo generatedCodeInfo)
+        {
+            // Building descriptors involves two steps: translating and linking.
+            // In the translation step (implemented by FileDescriptor's
+            // constructor), we build an object tree mirroring the
+            // FileDescriptorProto's tree and put all of the descriptors into the
+            // DescriptorPool's lookup tables.  In the linking step, we look up all
+            // type references in the DescriptorPool, so that, for example, a
+            // FieldDescriptor for an embedded message contains a pointer directly
+            // to the Descriptor for that message's type.  We also detect undefined
+            // types in the linking step.
+            if (dependencies == null)
+            {
+                dependencies = new FileDescriptor[0];
+            }
+
+            DescriptorPool pool = new DescriptorPool(dependencies);
+            FileDescriptor result = new FileDescriptor(descriptorData, proto, dependencies, pool, allowUnknownDependencies, generatedCodeInfo);
+
+            // Validate that the dependencies we've been passed (as FileDescriptors) are actually the ones we
+            // need.
+            if (dependencies.Length != proto.Dependency.Count)
+            {
+                throw new DescriptorValidationException(
+                    result,
+                    "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
+                    "those listed in the FileDescriptorProto.");
+            }
+
+            result.CrossLink();
+            return result;
+        }
+
+        private void CrossLink()
+        {
+            foreach (MessageDescriptor message in MessageTypes)
+            {
+                message.CrossLink();
+            }
+
+            foreach (ServiceDescriptor service in Services)
+            {
+                service.CrossLink();
+            }
+
+            Extensions.CrossLink();
+        }
+
+        /// <summary>
+        /// Creates a descriptor for generated code.
+        /// </summary>
+        /// <remarks>
+        /// This method is only designed to be used by the results of generating code with protoc,
+        /// which creates the appropriate dependencies etc. It has to be public because the generated
+        /// code is "external", but should not be called directly by end users.
+        /// </remarks>
+        public static FileDescriptor FromGeneratedCode(
+            byte[] descriptorData,
+            FileDescriptor[] dependencies,
+            GeneratedClrTypeInfo generatedCodeInfo)
+        {
+            ExtensionRegistry registry = new ExtensionRegistry();
+            registry.AddRange(GetAllExtensions(dependencies, generatedCodeInfo));
+    
+            FileDescriptorProto proto;
+            try
+            {
+                proto = FileDescriptorProto.Parser.WithExtensionRegistry(registry).ParseFrom(descriptorData);
+            }
+            catch (InvalidProtocolBufferException e)
+            {
+                throw new ArgumentException("Failed to parse protocol buffer descriptor for generated code.", e);
+            }
+
+            try
+            {
+                // When building descriptors for generated code, we allow unknown
+                // dependencies by default.
+                return BuildFrom(ByteString.CopyFrom(descriptorData), proto, dependencies, true, generatedCodeInfo);
+            }
+            catch (DescriptorValidationException e)
+            {
+                throw new ArgumentException($"Invalid embedded descriptor for \"{proto.Name}\".", e);
+            }
+        }
+
+        private static IEnumerable<Extension> GetAllExtensions(FileDescriptor[] dependencies, GeneratedClrTypeInfo generatedInfo)
+        {
+            return dependencies.SelectMany(GetAllDependedExtensions).Distinct(ExtensionRegistry.ExtensionComparer.Instance).Concat(GetAllGeneratedExtensions(generatedInfo));
+        }
+
+        private static IEnumerable<Extension> GetAllGeneratedExtensions(GeneratedClrTypeInfo generated)
+        {
+            return generated.Extensions.Concat(generated.NestedTypes.Where(t => t != null).SelectMany(GetAllGeneratedExtensions));
+        }
+
+        private static IEnumerable<Extension> GetAllDependedExtensions(FileDescriptor descriptor)
+        {
+            return descriptor.Extensions.UnorderedExtensions
+                .Select(s => s.Extension)
+                .Where(e => e != null)
+                .Concat(descriptor.Dependencies.Concat(descriptor.PublicDependencies).SelectMany(GetAllDependedExtensions))
+                .Concat(descriptor.MessageTypes.SelectMany(GetAllDependedExtensionsFromMessage));
+        }
+
+        private static IEnumerable<Extension> GetAllDependedExtensionsFromMessage(MessageDescriptor descriptor)
+        {
+            return descriptor.Extensions.UnorderedExtensions
+                .Select(s => s.Extension)
+                .Where(e => e != null)
+                .Concat(descriptor.NestedTypes.SelectMany(GetAllDependedExtensionsFromMessage));
+        }
+
+        /// <summary>
+        /// Converts the given descriptor binary data into FileDescriptor objects.
+        /// Note: reflection using the returned FileDescriptors is not currently supported.
+        /// </summary>
+        /// <param name="descriptorData">The binary file descriptor proto data. Must not be null, and any
+        /// dependencies must come before the descriptor which depends on them. (If A depends on B, and B
+        /// depends on C, then the descriptors must be presented in the order C, B, A.) This is compatible
+        /// with the order in which protoc provides descriptors to plugins.</param>
+        /// <param name="registry">The extension registry to use when parsing, or null if no extensions are required.</param>
+        /// <returns>The file descriptors corresponding to <paramref name="descriptorData"/>.</returns>
+        public static IReadOnlyList<FileDescriptor> BuildFromByteStrings(IEnumerable<ByteString> descriptorData, ExtensionRegistry registry)
+        {
+            ProtoPreconditions.CheckNotNull(descriptorData, nameof(descriptorData));
+
+            var parser = FileDescriptorProto.Parser.WithExtensionRegistry(registry);
+
+            // TODO: See if we can build a single DescriptorPool instead of building lots of them.
+            // This will all behave correctly, but it's less efficient than we'd like.
+            var descriptors = new List<FileDescriptor>();
+            var descriptorsByName = new Dictionary<string, FileDescriptor>();
+            foreach (var data in descriptorData)
+            {
+                var proto = parser.ParseFrom(data);
+                var dependencies = new List<FileDescriptor>();
+                foreach (var dependencyName in proto.Dependency)
+                {
+                    FileDescriptor dependency;
+                    if (!descriptorsByName.TryGetValue(dependencyName, out dependency))
+                    {
+                        throw new ArgumentException($"Dependency missing: {dependencyName}");
+                    }
+                    dependencies.Add(dependency);
+                }
+                var pool = new DescriptorPool(dependencies);
+                FileDescriptor descriptor = new FileDescriptor(
+                    data, proto, dependencies, pool,
+                    allowUnknownDependencies: false, generatedCodeInfo: null);
+                descriptor.CrossLink();
+                descriptors.Add(descriptor);
+                if (descriptorsByName.ContainsKey(descriptor.Name))
+                {
+                    throw new ArgumentException($"Duplicate descriptor name: {descriptor.Name}");
+                }
+                descriptorsByName.Add(descriptor.Name, descriptor);
+            }
+            return new ReadOnlyCollection<FileDescriptor>(descriptors);
+        }
+
+        /// <summary>
+        /// Converts the given descriptor binary data into FileDescriptor objects.
+        /// Note: reflection using the returned FileDescriptors is not currently supported.
+        /// </summary>
+        /// <param name="descriptorData">The binary file descriptor proto data. Must not be null, and any
+        /// dependencies must come before the descriptor which depends on them. (If A depends on B, and B
+        /// depends on C, then the descriptors must be presented in the order C, B, A.) This is compatible
+        /// with the order in which protoc provides descriptors to plugins.</param>
+        /// <returns>The file descriptors corresponding to <paramref name="descriptorData"/>.</returns>
+        public static IReadOnlyList<FileDescriptor> BuildFromByteStrings(IEnumerable<ByteString> descriptorData) =>
+            BuildFromByteStrings(descriptorData, null);
+
+        /// <summary>
+        /// Returns a <see cref="System.String" /> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="System.String" /> that represents this instance.
+        /// </returns>
+        public override string ToString()
+        {
+            return $"FileDescriptor for {Name}";
+        }
+
+        /// <summary>
+        /// Returns the file descriptor for descriptor.proto.
+        /// </summary>
+        /// <remarks>
+        /// This is used for protos which take a direct dependency on <c>descriptor.proto</c>, typically for
+        /// annotations. While <c>descriptor.proto</c> is a proto2 file, it is built into the Google.Protobuf
+        /// runtime for reflection purposes. The messages are internal to the runtime as they would require
+        /// proto2 semantics for full support, but the file descriptor is available via this property. The
+        /// C# codegen in protoc automatically uses this property when it detects a dependency on <c>descriptor.proto</c>.
+        /// </remarks>
+        /// <value>
+        /// The file descriptor for <c>descriptor.proto</c>.
+        /// </value>
+        public static FileDescriptor DescriptorProtoFileDescriptor { get { return DescriptorReflection.Descriptor; } }
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this file.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
+        public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>FileOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public FileOptions GetOptions() => Proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value file option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<FileOptions, T> extension)
+        {
+            var value = Proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value file option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public RepeatedField<T> GetOption<T>(RepeatedExtension<FileOptions, T> extension)
+        {
+            return Proto.Options.GetExtension(extension).Clone();
+        }
+
+        /// <summary>
+        /// Performs initialization for the given generic type argument.
+        /// </summary>
+        /// <remarks>
+        /// This method is present for the sake of AOT compilers. It allows code (whether handwritten or generated)
+        /// to make calls into the reflection machinery of this library to express an intention to use that type
+        /// reflectively (e.g. for JSON parsing and formatting). The call itself does almost nothing, but AOT compilers
+        /// attempting to determine which generic type arguments need to be handled will spot the code path and act
+        /// accordingly.
+        /// </remarks>
+        /// <typeparam name="T">The type to force initialization for.</typeparam>
+        public static void ForceReflectionInitialization<T>() => ReflectionUtil.ForceInitialize<T>();
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/GeneratedClrTypeInfo.cs b/Libs/Google.Protobuf/Reflection/GeneratedClrTypeInfo.cs
new file mode 100644
index 0000000..74666c2
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/GeneratedClrTypeInfo.cs
@@ -0,0 +1,128 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+using System;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Extra information provided by generated code when initializing a message or file descriptor.
+    /// These are constructed as required, and are not long-lived. Hand-written code should
+    /// never need to use this type.
+    /// </summary>
+    public sealed class GeneratedClrTypeInfo
+    {
+        private static readonly string[] EmptyNames = new string[0];
+        private static readonly GeneratedClrTypeInfo[] EmptyCodeInfo = new GeneratedClrTypeInfo[0];
+        private static readonly Extension[] EmptyExtensions = new Extension[0];
+
+        /// <summary>
+        /// Irrelevant for file descriptors; the CLR type for the message for message descriptors.
+        /// </summary>
+        public Type ClrType { get; private set; }
+
+        /// <summary>
+        /// Irrelevant for file descriptors; the parser for message descriptors.
+        /// </summary>
+        public MessageParser Parser { get; }
+
+        /// <summary>
+        /// Irrelevant for file descriptors; the CLR property names (in message descriptor field order)
+        /// for fields in the message for message descriptors.
+        /// </summary>
+        public string[] PropertyNames { get; }
+
+        /// <summary>
+        /// The extensions defined within this file/message descriptor
+        /// </summary>
+        public Extension[] Extensions { get; }
+
+        /// <summary>
+        /// Irrelevant for file descriptors; the CLR property "base" names (in message descriptor oneof order)
+        /// for oneofs in the message for message descriptors. It is expected that for a oneof name of "Foo",
+        /// there will be a "FooCase" property and a "ClearFoo" method.
+        /// </summary>
+        public string[] OneofNames { get; }
+
+        /// <summary>
+        /// The reflection information for types within this file/message descriptor. Elements may be null
+        /// if there is no corresponding generated type, e.g. for map entry types.
+        /// </summary>
+        public GeneratedClrTypeInfo[] NestedTypes { get; }
+
+        /// <summary>
+        /// The CLR types for enums within this file/message descriptor.
+        /// </summary>
+        public Type[] NestedEnums { get; }
+
+        /// <summary>
+        /// Creates a GeneratedClrTypeInfo for a message descriptor, with nested types, nested enums, the CLR type, property names and oneof names.
+        /// Each array parameter may be null, to indicate a lack of values.
+        /// The parameter order is designed to make it feasible to format the generated code readably.
+        /// </summary>
+        public GeneratedClrTypeInfo(Type clrType, MessageParser parser, string[] propertyNames, string[] oneofNames, Type[] nestedEnums, Extension[] extensions, GeneratedClrTypeInfo[] nestedTypes)
+        {
+            NestedTypes = nestedTypes ?? EmptyCodeInfo;
+            NestedEnums = nestedEnums ?? ReflectionUtil.EmptyTypes;
+            ClrType = clrType;
+            Extensions = extensions ?? EmptyExtensions;
+            Parser = parser;
+            PropertyNames = propertyNames ?? EmptyNames;
+            OneofNames = oneofNames ?? EmptyNames;
+        }
+
+        /// <summary>
+        /// Creates a GeneratedClrTypeInfo for a message descriptor, with nested types, nested enums, the CLR type, property names and oneof names.
+        /// Each array parameter may be null, to indicate a lack of values.
+        /// The parameter order is designed to make it feasible to format the generated code readably.
+        /// </summary>
+        public GeneratedClrTypeInfo(Type clrType, MessageParser parser, string[] propertyNames, string[] oneofNames, Type[] nestedEnums, GeneratedClrTypeInfo[] nestedTypes)
+            : this(clrType, parser, propertyNames, oneofNames, nestedEnums, null, nestedTypes)
+        {
+        }
+
+        /// <summary>
+        /// Creates a GeneratedClrTypeInfo for a file descriptor, with only types, enums, and extensions.
+        /// </summary>
+        public GeneratedClrTypeInfo(Type[] nestedEnums, Extension[] extensions, GeneratedClrTypeInfo[] nestedTypes)
+            : this(null, null, null, null, nestedEnums, extensions, nestedTypes)
+        {
+        }
+
+        /// <summary>
+        /// Creates a GeneratedClrTypeInfo for a file descriptor, with only types and enums.
+        /// </summary>
+        public GeneratedClrTypeInfo(Type[] nestedEnums, GeneratedClrTypeInfo[] nestedTypes)
+            : this(null, null, null, null, nestedEnums, nestedTypes)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/IDescriptor.cs b/Libs/Google.Protobuf/Reflection/IDescriptor.cs
new file mode 100644
index 0000000..527a39a
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/IDescriptor.cs
@@ -0,0 +1,55 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Interface implemented by all descriptor types.
+    /// </summary>
+    public interface IDescriptor
+    {
+        /// <summary>
+        /// Returns the name of the entity (message, field etc) being described.
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Returns the fully-qualified name of the entity being described.
+        /// </summary>
+        string FullName { get; }
+
+        /// <summary>
+        /// Returns the descriptor for the .proto file that this entity is part of.
+        /// </summary>
+        FileDescriptor File { get; }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/IFieldAccessor.cs b/Libs/Google.Protobuf/Reflection/IFieldAccessor.cs
new file mode 100644
index 0000000..e45517b
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/IFieldAccessor.cs
@@ -0,0 +1,77 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Allows fields to be reflectively accessed.
+    /// </summary>
+    public interface IFieldAccessor
+    {
+        /// <summary>
+        /// Returns the descriptor associated with this field.
+        /// </summary>
+        FieldDescriptor Descriptor { get; }
+
+        /// <summary>
+        /// Clears the field in the specified message. (For repeated fields,
+        /// this clears the list.)
+        /// </summary>
+        void Clear(IMessage message);
+
+        /// <summary>
+        /// Fetches the field value. For repeated values, this will be an
+        /// <see cref="IList"/> implementation. For map values, this will be an
+        /// <see cref="IDictionary"/> implementation.
+        /// </summary>
+        object GetValue(IMessage message);
+
+        /// <summary>
+        /// Indicates whether the field in the specified message is set.
+        /// For proto3 fields that aren't explicitly optional, this throws an <see cref="InvalidOperationException"/>
+        /// </summary>
+        bool HasValue(IMessage message);
+
+        /// <summary>
+        /// Mutator for single "simple" fields only.
+        /// </summary>
+        /// <remarks>
+        /// Repeated fields are mutated by fetching the value and manipulating it as a list.
+        /// Map fields are mutated by fetching the value and manipulating it as a dictionary.
+        /// </remarks>
+        /// <exception cref="InvalidOperationException">The field is not a "simple" field.</exception>
+        void SetValue(IMessage message, object value);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/MapFieldAccessor.cs b/Libs/Google.Protobuf/Reflection/MapFieldAccessor.cs
new file mode 100644
index 0000000..71a1c3c
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/MapFieldAccessor.cs
@@ -0,0 +1,64 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Reflection;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Accessor for map fields.
+    /// </summary>
+    internal sealed class MapFieldAccessor : FieldAccessorBase
+    {
+        internal MapFieldAccessor(PropertyInfo property, FieldDescriptor descriptor) : base(property, descriptor)
+        {
+        }
+
+        public override void Clear(IMessage message)
+        {
+            IDictionary list = (IDictionary) GetValue(message);
+            list.Clear();
+        }
+
+        public override bool HasValue(IMessage message)
+        {
+            throw new InvalidOperationException("HasValue is not implemented for map fields");
+        }
+
+        public override void SetValue(IMessage message, object value)
+        {
+            throw new InvalidOperationException("SetValue is not implemented for map fields");
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/MessageDescriptor.cs b/Libs/Google.Protobuf/Reflection/MessageDescriptor.cs
new file mode 100644
index 0000000..a2a1dad
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/MessageDescriptor.cs
@@ -0,0 +1,420 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Reflection;
+#if NET35
+// Needed for ReadOnlyDictionary, which does not exist in .NET 3.5
+using LC.Google.Protobuf.Collections;
+#endif
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Describes a message type.
+    /// </summary>
+    public sealed class MessageDescriptor : DescriptorBase
+    {
+        private static readonly HashSet<string> WellKnownTypeNames = new HashSet<string>
+        {
+            "google/protobuf/any.proto",
+            "google/protobuf/api.proto",
+            "google/protobuf/duration.proto",
+            "google/protobuf/empty.proto",
+            "google/protobuf/wrappers.proto",
+            "google/protobuf/timestamp.proto",
+            "google/protobuf/field_mask.proto",
+            "google/protobuf/source_context.proto",
+            "google/protobuf/struct.proto",
+            "google/protobuf/type.proto",
+        };
+
+        private readonly IList<FieldDescriptor> fieldsInDeclarationOrder;
+        private readonly IList<FieldDescriptor> fieldsInNumberOrder;
+        private readonly IDictionary<string, FieldDescriptor> jsonFieldMap;
+        private Func<IMessage, bool> extensionSetIsInitialized;
+
+        internal MessageDescriptor(DescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int typeIndex, GeneratedClrTypeInfo generatedCodeInfo)
+            : base(file, file.ComputeFullName(parent, proto.Name), typeIndex)
+        {
+            Proto = proto;
+            Parser = generatedCodeInfo?.Parser;
+            ClrType = generatedCodeInfo?.ClrType;
+            ContainingType = parent;
+
+            // If generatedCodeInfo is null, we just won't generate an accessor for any fields.
+            Oneofs = DescriptorUtil.ConvertAndMakeReadOnly(
+                proto.OneofDecl,
+                (oneof, index) =>
+                new OneofDescriptor(oneof, file, this, index, generatedCodeInfo?.OneofNames[index]));
+
+            int syntheticOneofCount = 0;
+            foreach (var oneof in Oneofs)
+            {
+                if (oneof.IsSynthetic)
+                {
+                    syntheticOneofCount++;
+                }
+                else if (syntheticOneofCount != 0)
+                {
+                    throw new ArgumentException("All synthetic oneofs should come after real oneofs");
+                }
+            }
+            RealOneofCount = Oneofs.Count - syntheticOneofCount;
+
+            NestedTypes = DescriptorUtil.ConvertAndMakeReadOnly(
+                proto.NestedType,
+                (type, index) =>
+                new MessageDescriptor(type, file, this, index, generatedCodeInfo?.NestedTypes[index]));
+
+            EnumTypes = DescriptorUtil.ConvertAndMakeReadOnly(
+                proto.EnumType,
+                (type, index) =>
+                new EnumDescriptor(type, file, this, index, generatedCodeInfo?.NestedEnums[index]));
+
+            Extensions = new ExtensionCollection(this, generatedCodeInfo?.Extensions);
+
+            fieldsInDeclarationOrder = DescriptorUtil.ConvertAndMakeReadOnly(
+                proto.Field,
+                (field, index) =>
+                new FieldDescriptor(field, file, this, index, generatedCodeInfo?.PropertyNames[index], null));
+            fieldsInNumberOrder = new ReadOnlyCollection<FieldDescriptor>(fieldsInDeclarationOrder.OrderBy(field => field.FieldNumber).ToArray());
+            // TODO: Use field => field.Proto.JsonName when we're confident it's appropriate. (And then use it in the formatter, too.)
+            jsonFieldMap = CreateJsonFieldMap(fieldsInNumberOrder);
+            file.DescriptorPool.AddSymbol(this);
+            Fields = new FieldCollection(this);
+        }
+
+        private static ReadOnlyDictionary<string, FieldDescriptor> CreateJsonFieldMap(IList<FieldDescriptor> fields)
+        {
+            var map = new Dictionary<string, FieldDescriptor>();
+            foreach (var field in fields)
+            {
+                map[field.Name] = field;
+                map[field.JsonName] = field;
+            }
+            return new ReadOnlyDictionary<string, FieldDescriptor>(map);
+        }
+
+        /// <summary>
+        /// The brief name of the descriptor's target.
+        /// </summary>
+        public override string Name => Proto.Name;
+
+        internal override IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
+        {
+            switch (fieldNumber)
+            {
+                case DescriptorProto.FieldFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) fieldsInDeclarationOrder;
+                case DescriptorProto.NestedTypeFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) NestedTypes;
+                case DescriptorProto.EnumTypeFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) EnumTypes;
+                default:
+                    return null;
+            }
+        }
+
+        internal DescriptorProto Proto { get; }
+
+        internal bool IsExtensionsInitialized(IMessage message)
+        {
+            if (Proto.ExtensionRange.Count == 0)
+            {
+                return true;
+            }
+
+            if (extensionSetIsInitialized == null)
+            {
+                extensionSetIsInitialized = ReflectionUtil.CreateIsInitializedCaller(ClrType);
+            }
+
+            return extensionSetIsInitialized(message);
+        }
+
+        /// <summary>
+        /// The CLR type used to represent message instances from this descriptor.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// The value returned by this property will be non-null for all regular fields. However,
+        /// if a message containing a map field is introspected, the list of nested messages will include
+        /// an auto-generated nested key/value pair message for the field. This is not represented in any
+        /// generated type, so this property will return null in such cases.
+        /// </para>
+        /// <para>
+        /// For wrapper types (<see cref="Google.Protobuf.WellKnownTypes.StringValue"/> and the like), the type returned here
+        /// will be the generated message type, not the native type used by reflection for fields of those types. Code
+        /// using reflection should call <see cref="IsWrapperType"/> to determine whether a message descriptor represents
+        /// a wrapper type, and handle the result appropriately.
+        /// </para>
+        /// </remarks>
+        public Type ClrType { get; }
+
+        /// <summary>
+        /// A parser for this message type.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// As <see cref="MessageDescriptor"/> is not generic, this cannot be statically
+        /// typed to the relevant type, but it should produce objects of a type compatible with <see cref="ClrType"/>.
+        /// </para>
+        /// <para>
+        /// The value returned by this property will be non-null for all regular fields. However,
+        /// if a message containing a map field is introspected, the list of nested messages will include
+        /// an auto-generated nested key/value pair message for the field. No message parser object is created for
+        /// such messages, so this property will return null in such cases.
+        /// </para>
+        /// <para>
+        /// For wrapper types (<see cref="Google.Protobuf.WellKnownTypes.StringValue"/> and the like), the parser returned here
+        /// will be the generated message type, not the native type used by reflection for fields of those types. Code
+        /// using reflection should call <see cref="IsWrapperType"/> to determine whether a message descriptor represents
+        /// a wrapper type, and handle the result appropriately.
+        /// </para>
+        /// </remarks>
+        public MessageParser Parser { get; }
+
+        /// <summary>
+        /// Returns whether this message is one of the "well known types" which may have runtime/protoc support.
+        /// </summary>
+        internal bool IsWellKnownType => File.Package == "google.protobuf" && WellKnownTypeNames.Contains(File.Name);
+
+        /// <summary>
+        /// Returns whether this message is one of the "wrapper types" used for fields which represent primitive values
+        /// with the addition of presence.
+        /// </summary>
+        internal bool IsWrapperType => File.Package == "google.protobuf" && File.Name == "google/protobuf/wrappers.proto";
+
+        /// <value>
+        /// If this is a nested type, get the outer descriptor, otherwise null.
+        /// </value>
+        public MessageDescriptor ContainingType { get; }
+
+        /// <value>
+        /// A collection of fields, which can be retrieved by name or field number.
+        /// </value>
+        public FieldCollection Fields { get; }
+
+        /// <summary>
+        /// An unmodifiable list of extensions defined in this message's scope.
+        /// Note that some extensions may be incomplete (FieldDescriptor.Extension may be null)
+        /// if they are declared in a file generated using a version of protoc that did not fully
+        /// support extensions in C#.
+        /// </summary>
+        public ExtensionCollection Extensions { get; }
+
+        /// <value>
+        /// An unmodifiable list of this message type's nested types.
+        /// </value>
+        public IList<MessageDescriptor> NestedTypes { get; }
+
+        /// <value>
+        /// An unmodifiable list of this message type's enum types.
+        /// </value>
+        public IList<EnumDescriptor> EnumTypes { get; }
+
+        /// <value>
+        /// An unmodifiable list of the "oneof" field collections in this message type.
+        /// All "real" oneofs (where <see cref="OneofDescriptor.IsSynthetic"/> returns false)
+        /// come before synthetic ones.
+        /// </value>
+        public IList<OneofDescriptor> Oneofs { get; }
+
+        /// <summary>
+        /// The number of real "oneof" descriptors in this message type. Every element in <see cref="Oneofs"/>
+        /// with an index less than this will have a <see cref="OneofDescriptor.IsSynthetic"/> property value
+        /// of <c>false</c>; every element with an index greater than or equal to this will have a
+        /// <see cref="OneofDescriptor.IsSynthetic"/> property value of <c>true</c>.
+        /// </summary>
+        public int RealOneofCount { get; }
+
+        /// <summary>
+        /// Finds a field by field name.
+        /// </summary>
+        /// <param name="name">The unqualified name of the field (e.g. "foo").</param>
+        /// <returns>The field's descriptor, or null if not found.</returns>
+        public FieldDescriptor FindFieldByName(String name) => File.DescriptorPool.FindSymbol<FieldDescriptor>(FullName + "." + name);
+
+        /// <summary>
+        /// Finds a field by field number.
+        /// </summary>
+        /// <param name="number">The field number within this message type.</param>
+        /// <returns>The field's descriptor, or null if not found.</returns>
+        public FieldDescriptor FindFieldByNumber(int number) => File.DescriptorPool.FindFieldByNumber(this, number);
+
+        /// <summary>
+        /// Finds a nested descriptor by name. The is valid for fields, nested
+        /// message types, oneofs and enums.
+        /// </summary>
+        /// <param name="name">The unqualified name of the descriptor, e.g. "Foo"</param>
+        /// <returns>The descriptor, or null if not found.</returns>
+        public T FindDescriptor<T>(string name)  where T : class, IDescriptor =>
+            File.DescriptorPool.FindSymbol<T>(FullName + "." + name);
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this message.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
+        public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>MessageOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public MessageOptions GetOptions() => Proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value message option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<MessageOptions, T> extension)
+        {
+            var value = Proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value message option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public Collections.RepeatedField<T> GetOption<T>(RepeatedExtension<MessageOptions, T> extension)
+        {
+            return Proto.Options.GetExtension(extension).Clone();
+        }
+
+        /// <summary>
+        /// Looks up and cross-links all fields and nested types.
+        /// </summary>
+        internal void CrossLink()
+        {
+            foreach (MessageDescriptor message in NestedTypes)
+            {
+                message.CrossLink();
+            }
+
+            foreach (FieldDescriptor field in fieldsInDeclarationOrder)
+            {
+                field.CrossLink();
+            }
+
+            foreach (OneofDescriptor oneof in Oneofs)
+            {
+                oneof.CrossLink();
+            }
+
+            Extensions.CrossLink();
+        }
+
+        /// <summary>
+        /// A collection to simplify retrieving the field accessor for a particular field.
+        /// </summary>
+        public sealed class FieldCollection
+        {
+            private readonly MessageDescriptor messageDescriptor;
+
+            internal FieldCollection(MessageDescriptor messageDescriptor)
+            {
+                this.messageDescriptor = messageDescriptor;
+            }
+
+            /// <value>
+            /// Returns the fields in the message as an immutable list, in the order in which they
+            /// are declared in the source .proto file.
+            /// </value>
+            public IList<FieldDescriptor> InDeclarationOrder() => messageDescriptor.fieldsInDeclarationOrder;
+
+            /// <value>
+            /// Returns the fields in the message as an immutable list, in ascending field number
+            /// order. Field numbers need not be contiguous, so there is no direct mapping from the
+            /// index in the list to the field number; to retrieve a field by field number, it is better
+            /// to use the <see cref="FieldCollection"/> indexer.
+            /// </value>
+            public IList<FieldDescriptor> InFieldNumberOrder() => messageDescriptor.fieldsInNumberOrder;
+
+            // TODO: consider making this public in the future. (Being conservative for now...)
+
+            /// <value>
+            /// Returns a read-only dictionary mapping the field names in this message as they're available
+            /// in the JSON representation to the field descriptors. For example, a field <c>foo_bar</c>
+            /// in the message would result two entries, one with a key <c>fooBar</c> and one with a key
+            /// <c>foo_bar</c>, both referring to the same field.
+            /// </value>
+            internal IDictionary<string, FieldDescriptor> ByJsonName() => messageDescriptor.jsonFieldMap;
+
+            /// <summary>
+            /// Retrieves the descriptor for the field with the given number.
+            /// </summary>
+            /// <param name="number">Number of the field to retrieve the descriptor for</param>
+            /// <returns>The accessor for the given field</returns>
+            /// <exception cref="KeyNotFoundException">The message descriptor does not contain a field
+            /// with the given number</exception>
+            public FieldDescriptor this[int number]
+            {
+                get
+                {
+                    var fieldDescriptor = messageDescriptor.FindFieldByNumber(number);
+                    if (fieldDescriptor == null)
+                    {
+                        throw new KeyNotFoundException("No such field number");
+                    }
+                    return fieldDescriptor;
+                }
+            }
+
+            /// <summary>
+            /// Retrieves the descriptor for the field with the given name.
+            /// </summary>
+            /// <param name="name">Name of the field to retrieve the descriptor for</param>
+            /// <returns>The descriptor for the given field</returns>
+            /// <exception cref="KeyNotFoundException">The message descriptor does not contain a field
+            /// with the given name</exception>
+            public FieldDescriptor this[string name]
+            {
+                get
+                {
+                    var fieldDescriptor = messageDescriptor.FindFieldByName(name);
+                    if (fieldDescriptor == null)
+                    {
+                        throw new KeyNotFoundException("No such field name");
+                    }
+                    return fieldDescriptor;
+                }
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/MethodDescriptor.cs b/Libs/Google.Protobuf/Reflection/MethodDescriptor.cs
new file mode 100644
index 0000000..9051744
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/MethodDescriptor.cs
@@ -0,0 +1,140 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Describes a single method in a service.
+    /// </summary>
+    public sealed class MethodDescriptor : DescriptorBase
+    {
+        private readonly MethodDescriptorProto proto;
+        private readonly ServiceDescriptor service;
+        private MessageDescriptor inputType;
+        private MessageDescriptor outputType;
+
+        /// <value>
+        /// The service this method belongs to.
+        /// </value>
+        public ServiceDescriptor Service { get { return service; } }
+
+        /// <value>
+        /// The method's input type.
+        /// </value>
+        public MessageDescriptor InputType { get { return inputType; } }
+
+        /// <value>
+        /// The method's input type.
+        /// </value>
+        public MessageDescriptor OutputType { get { return outputType; } }
+
+        /// <value>
+        /// Indicates if client streams multiple requests.
+        /// </value>
+        public bool IsClientStreaming { get { return proto.ClientStreaming; } }
+
+        /// <value>
+        /// Indicates if server streams multiple responses.
+        /// </value>
+        public bool IsServerStreaming { get { return proto.ServerStreaming; } }
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this method.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
+        public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>MethodOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public MethodOptions GetOptions() => Proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value method option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<MethodOptions, T> extension)
+        {
+            var value = Proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value method option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public RepeatedField<T> GetOption<T>(RepeatedExtension<MethodOptions, T> extension)
+        {
+            return Proto.Options.GetExtension(extension).Clone();
+        }
+
+        internal MethodDescriptor(MethodDescriptorProto proto, FileDescriptor file,
+                                  ServiceDescriptor parent, int index)
+            : base(file, parent.FullName + "." + proto.Name, index)
+        {
+            this.proto = proto;
+            service = parent;
+            file.DescriptorPool.AddSymbol(this);
+        }
+
+        internal MethodDescriptorProto Proto { get { return proto; } }
+
+        /// <summary>
+        /// The brief name of the descriptor's target.
+        /// </summary>
+        public override string Name { get { return proto.Name; } }
+
+        internal void CrossLink()
+        {
+            IDescriptor lookup = File.DescriptorPool.LookupSymbol(Proto.InputType, this);
+            if (!(lookup is MessageDescriptor))
+            {
+                throw new DescriptorValidationException(this, "\"" + Proto.InputType + "\" is not a message type.");
+            }
+            inputType = (MessageDescriptor) lookup;
+
+            lookup = File.DescriptorPool.LookupSymbol(Proto.OutputType, this);
+            if (!(lookup is MessageDescriptor))
+            {
+                throw new DescriptorValidationException(this, "\"" + Proto.OutputType + "\" is not a message type.");
+            }
+            outputType = (MessageDescriptor) lookup;
+        }
+    }
+}
+ 
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/OneofAccessor.cs b/Libs/Google.Protobuf/Reflection/OneofAccessor.cs
new file mode 100644
index 0000000..e188059
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/OneofAccessor.cs
@@ -0,0 +1,97 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Reflection;
+using LC.Google.Protobuf.Compatibility;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Reflection access for a oneof, allowing clear and "get case" actions.
+    /// </summary>
+    public sealed class OneofAccessor
+    {
+        private readonly Func<IMessage, int> caseDelegate;
+        private readonly Action<IMessage> clearDelegate;
+
+        private OneofAccessor(OneofDescriptor descriptor, Func<IMessage, int> caseDelegate, Action<IMessage> clearDelegate)
+        {
+            Descriptor = descriptor;
+            this.caseDelegate = caseDelegate;
+            this.clearDelegate = clearDelegate;
+        }
+
+        internal static OneofAccessor ForRegularOneof(
+            OneofDescriptor descriptor,
+            PropertyInfo caseProperty,
+            MethodInfo clearMethod) =>
+            new OneofAccessor(
+                descriptor,
+                ReflectionUtil.CreateFuncIMessageInt32(caseProperty.GetGetMethod()),
+                ReflectionUtil.CreateActionIMessage(clearMethod));
+
+        internal static OneofAccessor ForSyntheticOneof(OneofDescriptor descriptor)
+        {
+            // Note: descriptor.Fields will be null when this method is called, because we haven't
+            // cross-linked yet. But by the time the delegates are called by user code, all will be
+            // well. (That's why we capture the descriptor itself rather than a field.)
+            return new OneofAccessor(descriptor,
+                message => descriptor.Fields[0].Accessor.HasValue(message) ? descriptor.Fields[0].FieldNumber : 0,
+                message => descriptor.Fields[0].Accessor.Clear(message));
+        }
+
+        /// <summary>
+        /// Gets the descriptor for this oneof.
+        /// </summary>
+        /// <value>
+        /// The descriptor of the oneof.
+        /// </value>
+        public OneofDescriptor Descriptor { get; }
+
+        /// <summary>
+        /// Clears the oneof in the specified message.
+        /// </summary>
+        public void Clear(IMessage message) => clearDelegate(message);
+
+        /// <summary>
+        /// Indicates which field in the oneof is set for specified message
+        /// </summary>
+        public FieldDescriptor GetCaseFieldDescriptor(IMessage message)
+        {
+            int fieldNumber = caseDelegate(message);
+            return fieldNumber > 0
+                ? Descriptor.ContainingType.FindFieldByNumber(fieldNumber)
+                : null;
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/OneofDescriptor.cs b/Libs/Google.Protobuf/Reflection/OneofDescriptor.cs
new file mode 100644
index 0000000..d8c21df
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/OneofDescriptor.cs
@@ -0,0 +1,195 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using LC.Google.Protobuf.Collections;
+using LC.Google.Protobuf.Compatibility;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Describes a "oneof" field collection in a message type: a set of
+    /// fields of which at most one can be set in any particular message.
+    /// </summary>
+    public sealed class OneofDescriptor : DescriptorBase
+    {
+        private readonly OneofDescriptorProto proto;
+        private MessageDescriptor containingType;
+        private IList<FieldDescriptor> fields;
+        private readonly OneofAccessor accessor;
+
+        internal OneofDescriptor(OneofDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index, string clrName)
+            : base(file, file.ComputeFullName(parent, proto.Name), index)
+        {
+            this.proto = proto;
+            containingType = parent;
+            file.DescriptorPool.AddSymbol(this);
+
+            // It's useful to determine whether or not this is a synthetic oneof before cross-linking. That means
+            // diving into the proto directly rather than using FieldDescriptor, but that's okay.
+            var firstFieldInOneof = parent.Proto.Field.FirstOrDefault(fieldProto => fieldProto.HasOneofIndex && fieldProto.OneofIndex == index);
+            IsSynthetic = firstFieldInOneof?.Proto3Optional ?? false;
+
+            accessor = CreateAccessor(clrName);
+        }
+
+        /// <summary>
+        /// The brief name of the descriptor's target.
+        /// </summary>
+        public override string Name { get { return proto.Name; } }
+
+        /// <summary>
+        /// Gets the message type containing this oneof.
+        /// </summary>
+        /// <value>
+        /// The message type containing this oneof.
+        /// </value>
+        public MessageDescriptor ContainingType
+        {
+            get { return containingType; }
+        }
+
+        /// <summary>
+        /// Gets the fields within this oneof, in declaration order.
+        /// </summary>
+        /// <value>
+        /// The fields within this oneof, in declaration order.
+        /// </value>
+        public IList<FieldDescriptor> Fields { get { return fields; } }
+
+        /// <summary>
+        /// Returns <c>true</c> if this oneof is a synthetic oneof containing a proto3 optional field;
+        /// <c>false</c> otherwise.
+        /// </summary>
+        public bool IsSynthetic { get; }
+
+        /// <summary>
+        /// Gets an accessor for reflective access to the values associated with the oneof
+        /// in a particular message.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// In descriptors for generated code, the value returned by this property will always be non-null.
+        /// </para>
+        /// <para>
+        /// In dynamically loaded descriptors, the value returned by this property will current be null;
+        /// if and when dynamic messages are supported, it will return a suitable accessor to work with
+        /// them.
+        /// </para>
+        /// </remarks>
+        /// <value>
+        /// The accessor used for reflective access.
+        /// </value>
+        public OneofAccessor Accessor { get { return accessor; } }
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this oneof.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions method.")]
+        public CustomOptions CustomOptions => new CustomOptions(proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>OneofOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public OneofOptions GetOptions() => proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value oneof option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<OneofOptions, T> extension)
+        {
+            var value = proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value oneof option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public RepeatedField<T> GetOption<T>(RepeatedExtension<OneofOptions, T> extension)
+        {
+            return proto.Options.GetExtension(extension).Clone();
+        }
+
+        internal void CrossLink()
+        {
+            List<FieldDescriptor> fieldCollection = new List<FieldDescriptor>();
+            foreach (var field in ContainingType.Fields.InDeclarationOrder())
+            {
+                if (field.ContainingOneof == this)
+                {
+                    fieldCollection.Add(field);
+                }
+            }
+            fields = new ReadOnlyCollection<FieldDescriptor>(fieldCollection);
+        }
+
+        private OneofAccessor CreateAccessor(string clrName)
+        {
+            // We won't have a CLR name if this is from a dynamically-loaded FileDescriptor.
+            // TODO: Support dynamic messages.
+            if (clrName == null)
+            {
+                return null;
+            }
+            if (IsSynthetic)
+            {
+                return OneofAccessor.ForSyntheticOneof(this);
+            }
+            else
+            {
+                var caseProperty = containingType.ClrType.GetProperty(clrName + "Case");
+                if (caseProperty == null)
+                {
+                    throw new DescriptorValidationException(this, $"Property {clrName}Case not found in {containingType.ClrType}");
+                }
+                if (!caseProperty.CanRead)
+                {
+                    throw new ArgumentException($"Cannot read from property {clrName}Case in {containingType.ClrType}");
+                }
+                var clearMethod = containingType.ClrType.GetMethod("Clear" + clrName);
+                if (clearMethod == null)
+                {
+                    throw new DescriptorValidationException(this, $"Method Clear{clrName} not found in {containingType.ClrType}");
+                }
+                return OneofAccessor.ForRegularOneof(this, caseProperty, clearMethod);
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/OriginalNameAttribute.cs b/Libs/Google.Protobuf/Reflection/OriginalNameAttribute.cs
new file mode 100644
index 0000000..a5ea860
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/OriginalNameAttribute.cs
@@ -0,0 +1,65 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Specifies the original name (in the .proto file) of a named element,
+    /// such as an enum value.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field)]
+    public class OriginalNameAttribute : Attribute
+    {
+        /// <summary>
+        /// The name of the element in the .proto file.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// If the name is preferred in the .proto file.
+        /// </summary>
+        public bool PreferredAlias { get; set; }
+
+        /// <summary>
+        /// Constructs a new attribute instance for the given name.
+        /// </summary>
+        /// <param name="name">The name of the element in the .proto file.</param>
+        public OriginalNameAttribute(string name)
+        {
+            Name = ProtoPreconditions.CheckNotNull(name, nameof(name));
+            PreferredAlias = true;
+        }
+
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/PackageDescriptor.cs b/Libs/Google.Protobuf/Reflection/PackageDescriptor.cs
new file mode 100644
index 0000000..74847d3
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/PackageDescriptor.cs
@@ -0,0 +1,68 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Represents a package in the symbol table.  We use PackageDescriptors
+    /// just as placeholders so that someone cannot define, say, a message type
+    /// that has the same name as an existing package.
+    /// </summary>
+    internal sealed class PackageDescriptor : IDescriptor
+    {
+        private readonly string name;
+        private readonly string fullName;
+        private readonly FileDescriptor file;
+
+        internal PackageDescriptor(string name, string fullName, FileDescriptor file)
+        {
+            this.file = file;
+            this.fullName = fullName;
+            this.name = name;
+        }
+
+        public string Name
+        {
+            get { return name; }
+        }
+
+        public string FullName
+        {
+            get { return fullName; }
+        }
+
+        public FileDescriptor File
+        {
+            get { return file; }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/ReflectionUtil.cs b/Libs/Google.Protobuf/Reflection/ReflectionUtil.cs
new file mode 100644
index 0000000..620b421
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/ReflectionUtil.cs
@@ -0,0 +1,363 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Compatibility;
+using System;
+using System.Reflection;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// The methods in this class are somewhat evil, and should not be tampered with lightly.
+    /// Basically they allow the creation of relatively weakly typed delegates from MethodInfos
+    /// which are more strongly typed. They do this by creating an appropriate strongly typed
+    /// delegate from the MethodInfo, and then calling that within an anonymous method.
+    /// Mind-bending stuff (at least to your humble narrator) but the resulting delegates are
+    /// very fast compared with calling Invoke later on.
+    /// </summary>
+    internal static class ReflectionUtil
+    {
+        static ReflectionUtil()
+        {
+            ForceInitialize<string>(); // Handles all reference types
+            ForceInitialize<int>();
+            ForceInitialize<long>();
+            ForceInitialize<uint>();
+            ForceInitialize<ulong>();
+            ForceInitialize<float>();
+            ForceInitialize<double>();
+            ForceInitialize<bool>();
+            ForceInitialize<int?>();
+            ForceInitialize<long?>();
+            ForceInitialize<uint?>();
+            ForceInitialize<ulong?>();
+            ForceInitialize<float?>();
+            ForceInitialize<double?>();
+            ForceInitialize<bool?>();
+            ForceInitialize<SampleEnum>();
+            SampleEnumMethod();
+        }
+
+        internal static void ForceInitialize<T>() => new ReflectionHelper<IMessage, T>();
+
+        /// <summary>
+        /// Empty Type[] used when calling GetProperty to force property instead of indexer fetching.
+        /// </summary>
+        internal static readonly Type[] EmptyTypes = new Type[0];
+
+        /// <summary>
+        /// Creates a delegate which will cast the argument to the type that declares the method,
+        /// call the method on it, then convert the result to object.
+        /// </summary>
+        /// <param name="method">The method to create a delegate for, which must be declared in an IMessage
+        /// implementation.</param>
+        internal static Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method) =>
+            GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageObject(method);
+
+        /// <summary>
+        /// Creates a delegate which will cast the argument to the type that declares the method,
+        /// call the method on it, then convert the result to the specified type. The method is expected
+        /// to actually return an enum (because of where we're calling it - for oneof cases). Sometimes that
+        /// means we need some extra work to perform conversions.
+        /// </summary>
+        /// <param name="method">The method to create a delegate for, which must be declared in an IMessage
+        /// implementation.</param>
+        internal static Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method) =>
+            GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageInt32(method);
+
+        /// <summary>
+        /// Creates a delegate which will execute the given method after casting the first argument to
+        /// the type that declares the method, and the second argument to the first parameter type of the method.
+        /// </summary>
+        /// <param name="method">The method to create a delegate for, which must be declared in an IMessage
+        /// implementation.</param>
+        internal static Action<IMessage, object> CreateActionIMessageObject(MethodInfo method) =>
+            GetReflectionHelper(method.DeclaringType, method.GetParameters()[0].ParameterType).CreateActionIMessageObject(method);
+
+        /// <summary>
+        /// Creates a delegate which will execute the given method after casting the first argument to
+        /// type that declares the method.
+        /// </summary>
+        /// <param name="method">The method to create a delegate for, which must be declared in an IMessage
+        /// implementation.</param>
+        internal static Action<IMessage> CreateActionIMessage(MethodInfo method) =>
+            GetReflectionHelper(method.DeclaringType, typeof(object)).CreateActionIMessage(method);
+
+        internal static Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method) =>
+            GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageBool(method);
+
+        internal static Func<IMessage, bool> CreateIsInitializedCaller(Type msg) =>
+            ((IExtensionSetReflector)Activator.CreateInstance(typeof(ExtensionSetReflector<>).MakeGenericType(msg))).CreateIsInitializedCaller();
+
+        /// <summary>
+        /// Creates a delegate which will execute the given method after casting the first argument to
+        /// the type that declares the method, and the second argument to the first parameter type of the method.
+        /// </summary>
+        internal static IExtensionReflectionHelper CreateExtensionHelper(Extension extension) =>
+            (IExtensionReflectionHelper)Activator.CreateInstance(typeof(ExtensionReflectionHelper<,>).MakeGenericType(extension.TargetType, extension.GetType().GenericTypeArguments[1]), extension);
+
+        /// <summary>
+        /// Creates a reflection helper for the given type arguments. Currently these are created on demand
+        /// rather than cached; this will be "busy" when initially loading a message's descriptor, but after that
+        /// they can be garbage collected. We could cache them by type if that proves to be important, but creating
+        /// an object is pretty cheap.
+        /// </summary>
+        private static IReflectionHelper GetReflectionHelper(Type t1, Type t2) =>
+            (IReflectionHelper) Activator.CreateInstance(typeof(ReflectionHelper<,>).MakeGenericType(t1, t2));
+
+        // Non-generic interface allowing us to use an instance of ReflectionHelper<T1, T2> without statically
+        // knowing the types involved.
+        private interface IReflectionHelper
+        {
+            Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method);
+            Action<IMessage> CreateActionIMessage(MethodInfo method);
+            Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method);
+            Action<IMessage, object> CreateActionIMessageObject(MethodInfo method);
+            Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method);
+        }
+
+        internal interface IExtensionReflectionHelper
+        {
+            object GetExtension(IMessage message);
+            void SetExtension(IMessage message, object value);
+            bool HasExtension(IMessage message);
+            void ClearExtension(IMessage message);
+        }
+
+        private interface IExtensionSetReflector
+        {
+            Func<IMessage, bool> CreateIsInitializedCaller();
+        }
+
+        private class ReflectionHelper<T1, T2> : IReflectionHelper
+        {
+
+            public Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method)
+            {
+                // On pleasant runtimes, we can create a Func<int> from a method returning
+                // an enum based on an int. That's the fast path.
+                if (CanConvertEnumFuncToInt32Func)
+                {
+                    var del = (Func<T1, int>) method.CreateDelegate(typeof(Func<T1, int>));
+                    return message => del((T1) message);
+                }
+                else
+                {
+                    // On some runtimes (e.g. old Mono) the return type has to be exactly correct,
+                    // so we go via boxing. Reflection is already fairly inefficient, and this is
+                    // only used for one-of case checking, fortunately.
+                    var del = (Func<T1, T2>) method.CreateDelegate(typeof(Func<T1, T2>));
+                    return message => (int) (object) del((T1) message);
+                }
+            }
+
+            public Action<IMessage> CreateActionIMessage(MethodInfo method)
+            {
+                var del = (Action<T1>) method.CreateDelegate(typeof(Action<T1>));
+                return message => del((T1) message);
+            }
+
+            public Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method)
+            {
+                var del = (Func<T1, T2>) method.CreateDelegate(typeof(Func<T1, T2>));
+                return message => del((T1) message);
+            }
+
+            public Action<IMessage, object> CreateActionIMessageObject(MethodInfo method)
+            {
+                var del = (Action<T1, T2>) method.CreateDelegate(typeof(Action<T1, T2>));
+                return (message, arg) => del((T1) message, (T2) arg);
+            }
+
+            public Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method)
+            {
+                var del = (Func<T1, bool>)method.CreateDelegate(typeof(Func<T1, bool>));
+                return message => del((T1)message);
+            }
+        }
+
+        private class ExtensionReflectionHelper<T1, T3> : IExtensionReflectionHelper
+            where T1 : IExtendableMessage<T1>
+        {
+            private readonly Extension extension;
+
+            public ExtensionReflectionHelper(Extension extension)
+            {
+                this.extension = extension;
+            }
+
+            public object GetExtension(IMessage message)
+            {
+                if (!(message is T1))
+                {
+                    throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
+                }
+
+                T1 extensionMessage = (T1)message;
+
+                if (extension is Extension<T1, T3>)
+                {
+                    return extensionMessage.GetExtension(extension as Extension<T1, T3>);
+                }
+                else if (extension is RepeatedExtension<T1, T3>)
+                {
+                    return extensionMessage.GetOrInitializeExtension(extension as RepeatedExtension<T1, T3>);
+                }
+                else
+                {
+                    throw new InvalidCastException("The provided extension is not a valid extension identifier type");
+                }
+            }
+
+            public bool HasExtension(IMessage message)
+            {
+                if (!(message is T1))
+                {
+                    throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
+                }
+
+                T1 extensionMessage = (T1)message;
+
+                if (extension is Extension<T1, T3>)
+                {
+                    return extensionMessage.HasExtension(extension as Extension<T1, T3>);
+                }
+                else if (extension is RepeatedExtension<T1, T3>)
+                {
+                    throw new InvalidOperationException("HasValue is not implemented for repeated extensions");
+                }
+                else
+                {
+                    throw new InvalidCastException("The provided extension is not a valid extension identifier type");
+                }
+            }
+
+            public void SetExtension(IMessage message, object value)
+            {
+                if (!(message is T1))
+                {
+                    throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
+                }
+
+                T1 extensionMessage = (T1)message;
+
+                if (extension is Extension<T1, T3>)
+                {
+                    extensionMessage.SetExtension(extension as Extension<T1, T3>, (T3)value);
+                }
+                else if (extension is RepeatedExtension<T1, T3>)
+                {
+                    throw new InvalidOperationException("SetValue is not implemented for repeated extensions");
+                }
+                else
+                {
+                    throw new InvalidCastException("The provided extension is not a valid extension identifier type");
+                }
+            }
+
+            public void ClearExtension(IMessage message)
+            {
+                if (!(message is T1))
+                {
+                    throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
+                }
+
+                T1 extensionMessage = (T1)message;
+
+                if (extension is Extension<T1, T3>)
+                {
+                    extensionMessage.ClearExtension(extension as Extension<T1, T3>);
+                }
+                else if (extension is RepeatedExtension<T1, T3>)
+                {
+                    extensionMessage.GetExtension(extension as RepeatedExtension<T1, T3>).Clear();
+                }
+                else
+                {
+                    throw new InvalidCastException("The provided extension is not a valid extension identifier type");
+                }
+            }
+        }
+
+        private class ExtensionSetReflector<T1> : IExtensionSetReflector where T1 : IExtendableMessage<T1>
+        {
+            public Func<IMessage, bool> CreateIsInitializedCaller()
+            {
+                var prop = typeof(T1).GetTypeInfo().GetDeclaredProperty("_Extensions");
+#if NET35
+                var getFunc = (Func<T1, ExtensionSet<T1>>)prop.GetGetMethod(true).CreateDelegate(typeof(Func<T1, ExtensionSet<T1>>));
+#else
+                var getFunc = (Func<T1, ExtensionSet<T1>>)prop.GetMethod.CreateDelegate(typeof(Func<T1, ExtensionSet<T1>>));
+#endif
+                var initializedFunc = (Func<ExtensionSet<T1>, bool>)
+                    typeof(ExtensionSet<T1>)
+                        .GetTypeInfo()
+                        .GetDeclaredMethod("IsInitialized")
+                        .CreateDelegate(typeof(Func<ExtensionSet<T1>, bool>));
+                return (m) => {
+                    var set = getFunc((T1)m);
+                    return set == null || initializedFunc(set);
+                };
+            }
+        }
+
+        // Runtime compatibility checking code - see ReflectionHelper<T1, T2>.CreateFuncIMessageInt32 for
+        // details about why we're doing this.
+
+        // Deliberately not inside the generic type. We only want to check this once.
+        private static bool CanConvertEnumFuncToInt32Func { get; } = CheckCanConvertEnumFuncToInt32Func();
+
+        private static bool CheckCanConvertEnumFuncToInt32Func()
+        {
+            try
+            {
+                // Try to do the conversion using reflection, so we can see whether it's supported.
+                MethodInfo method = typeof(ReflectionUtil).GetMethod(nameof(SampleEnumMethod));
+                // If this passes, we're in a reasonable runtime.
+                method.CreateDelegate(typeof(Func<int>));
+                return true;
+            }
+            catch (ArgumentException)
+            {
+                return false;
+            }
+        }
+
+        public enum SampleEnum
+        {
+            X
+        }
+
+        // Public to make the reflection simpler.
+        public static SampleEnum SampleEnumMethod() => SampleEnum.X;
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/RepeatedFieldAccessor.cs b/Libs/Google.Protobuf/Reflection/RepeatedFieldAccessor.cs
new file mode 100644
index 0000000..bc1a24c
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/RepeatedFieldAccessor.cs
@@ -0,0 +1,65 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Reflection;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Accessor for repeated fields.
+    /// </summary>
+    internal sealed class RepeatedFieldAccessor : FieldAccessorBase
+    {
+        internal RepeatedFieldAccessor(PropertyInfo property, FieldDescriptor descriptor) : base(property, descriptor)
+        {
+        }
+
+        public override void Clear(IMessage message)
+        {
+            IList list = (IList) GetValue(message);
+            list.Clear();
+        }
+
+        public override bool HasValue(IMessage message)
+        {
+            throw new InvalidOperationException("HasValue is not implemented for repeated fields");
+        }
+
+        public override void SetValue(IMessage message, object value)
+        {
+            throw new InvalidOperationException("SetValue is not implemented for repeated fields");
+        }
+
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/ServiceDescriptor.cs b/Libs/Google.Protobuf/Reflection/ServiceDescriptor.cs
new file mode 100644
index 0000000..79e4edb
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/ServiceDescriptor.cs
@@ -0,0 +1,136 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Collections;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Describes a service type.
+    /// </summary>
+    public sealed class ServiceDescriptor : DescriptorBase
+    {
+        private readonly ServiceDescriptorProto proto;
+        private readonly IList<MethodDescriptor> methods;
+
+        internal ServiceDescriptor(ServiceDescriptorProto proto, FileDescriptor file, int index)
+            : base(file, file.ComputeFullName(null, proto.Name), index)
+        {
+            this.proto = proto;
+            methods = DescriptorUtil.ConvertAndMakeReadOnly(proto.Method,
+                                                            (method, i) => new MethodDescriptor(method, file, this, i));
+
+            file.DescriptorPool.AddSymbol(this);
+        }
+
+        /// <summary>
+        /// The brief name of the descriptor's target.
+        /// </summary>
+        public override string Name { get { return proto.Name; } }
+
+        internal override IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
+        {
+            switch (fieldNumber)
+            {
+                case ServiceDescriptorProto.MethodFieldNumber:
+                    return (IReadOnlyList<DescriptorBase>) methods;
+                default:
+                    return null;
+            }
+        }
+
+        internal ServiceDescriptorProto Proto { get { return proto; } }
+
+        /// <value>
+        /// An unmodifiable list of methods in this service.
+        /// </value>
+        public IList<MethodDescriptor> Methods
+        {
+            get { return methods; }
+        }
+
+        /// <summary>
+        /// Finds a method by name.
+        /// </summary>
+        /// <param name="name">The unqualified name of the method (e.g. "Foo").</param>
+        /// <returns>The method's descriptor, or null if not found.</returns>
+        public MethodDescriptor FindMethodByName(String name)
+        {
+            return File.DescriptorPool.FindSymbol<MethodDescriptor>(FullName + "." + name);
+        }
+
+        /// <summary>
+        /// The (possibly empty) set of custom options for this service.
+        /// </summary>
+        [Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
+        public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);
+
+        /// <summary>
+        /// The <c>ServiceOptions</c>, defined in <c>descriptor.proto</c>.
+        /// If the options message is not present (i.e. there are no options), <c>null</c> is returned.
+        /// Custom options can be retrieved as extensions of the returned message.
+        /// NOTE: A defensive copy is created each time this property is retrieved.
+        /// </summary>
+        public ServiceOptions GetOptions() => Proto.Options?.Clone();
+
+        /// <summary>
+        /// Gets a single value service option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public T GetOption<T>(Extension<ServiceOptions, T> extension)
+        {
+            var value = Proto.Options.GetExtension(extension);
+            return value is IDeepCloneable<T> ? (value as IDeepCloneable<T>).Clone() : value;
+        }
+
+        /// <summary>
+        /// Gets a repeated value service option for this descriptor
+        /// </summary>
+        [Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
+        public RepeatedField<T> GetOption<T>(RepeatedExtension<ServiceOptions, T> extension)
+        {
+            return Proto.Options.GetExtension(extension).Clone();
+        }
+
+        internal void CrossLink()
+        {
+            foreach (MethodDescriptor method in methods)
+            {
+                method.CrossLink();
+            }
+        }
+    }
+}
+ 
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/Reflection/SingleFieldAccessor.cs b/Libs/Google.Protobuf/Reflection/SingleFieldAccessor.cs
new file mode 100644
index 0000000..1fad54f
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/SingleFieldAccessor.cs
@@ -0,0 +1,124 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Reflection;
+using LC.Google.Protobuf.Compatibility;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// Accessor for single fields.
+    /// </summary>
+    internal sealed class SingleFieldAccessor : FieldAccessorBase
+    {
+        // All the work here is actually done in the constructor - it creates the appropriate delegates.
+        // There are various cases to consider, based on the property type (message, string/bytes, or "genuine" primitive)
+        // and proto2 vs proto3 for non-message types, as proto3 doesn't support "full" presence detection or default
+        // values.
+
+        private readonly Action<IMessage, object> setValueDelegate;
+        private readonly Action<IMessage> clearDelegate;
+        private readonly Func<IMessage, bool> hasDelegate;
+
+        internal SingleFieldAccessor(PropertyInfo property, FieldDescriptor descriptor) : base(property, descriptor)
+        {
+            if (!property.CanWrite)
+            {
+                throw new ArgumentException("Not all required properties/methods available");
+            }
+            setValueDelegate = ReflectionUtil.CreateActionIMessageObject(property.GetSetMethod());
+
+            // Note: this looks worrying in that we access the containing oneof, which isn't valid until cross-linking
+            // is complete... but field accessors aren't created until after cross-linking.
+            // The oneof itself won't be cross-linked yet, but that's okay: the oneof accessor is created
+            // earlier.
+
+            // Message fields always support presence, via null checks.
+            if (descriptor.FieldType == FieldType.Message)
+            {
+                hasDelegate = message => GetValue(message) != null;
+                clearDelegate = message => SetValue(message, null);
+            }
+            // Oneof fields always support presence, via case checks.
+            // Note that clearing the field is a no-op unless that specific field is the current "case".
+            else if (descriptor.RealContainingOneof != null)
+            {
+                var oneofAccessor = descriptor.RealContainingOneof.Accessor;
+                hasDelegate = message => oneofAccessor.GetCaseFieldDescriptor(message) == descriptor;
+                clearDelegate = message =>
+                {
+                    // Clear on a field only affects the oneof itself if the current case is the field we're accessing.
+                    if (oneofAccessor.GetCaseFieldDescriptor(message) == descriptor)
+                    {
+                        oneofAccessor.Clear(message);
+                    }
+                };
+            }
+            // Primitive fields always support presence in proto2, and support presence in proto3 for optional fields.
+            else if (descriptor.File.Syntax == Syntax.Proto2 || descriptor.Proto.Proto3Optional)
+            {
+                MethodInfo hasMethod = property.DeclaringType.GetRuntimeProperty("Has" + property.Name).GetMethod;
+                if (hasMethod == null)
+                {
+                    throw new ArgumentException("Not all required properties/methods are available");
+                }
+                hasDelegate = ReflectionUtil.CreateFuncIMessageBool(hasMethod);
+                MethodInfo clearMethod = property.DeclaringType.GetRuntimeMethod("Clear" + property.Name, ReflectionUtil.EmptyTypes);
+                if (clearMethod == null)
+                {
+                    throw new ArgumentException("Not all required properties/methods are available");
+                }
+                clearDelegate = ReflectionUtil.CreateActionIMessage(clearMethod);
+            }
+            // What's left?
+            // Primitive proto3 fields without the optional keyword, which aren't in oneofs.
+            else
+            {
+                hasDelegate = message => { throw new InvalidOperationException("Presence is not implemented for this field"); };
+
+                // While presence isn't supported, clearing still is; it's just setting to a default value.
+                var clrType = property.PropertyType;
+
+                object defaultValue =
+                    clrType == typeof(string) ? ""
+                    : clrType == typeof(ByteString) ? ByteString.Empty
+                    : Activator.CreateInstance(clrType);
+                clearDelegate = message => SetValue(message, defaultValue);
+            }
+        }
+
+        public override void Clear(IMessage message) => clearDelegate(message);
+        public override bool HasValue(IMessage message) => hasDelegate(message);
+        public override void SetValue(IMessage message, object value) => setValueDelegate(message, value);
+    }
+}
diff --git a/Libs/Google.Protobuf/Reflection/TypeRegistry.cs b/Libs/Google.Protobuf/Reflection/TypeRegistry.cs
new file mode 100644
index 0000000..0d3c556
--- /dev/null
+++ b/Libs/Google.Protobuf/Reflection/TypeRegistry.cs
@@ -0,0 +1,183 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+using System.Collections.Generic;
+using System.Linq;
+
+namespace LC.Google.Protobuf.Reflection
+{
+    /// <summary>
+    /// An immutable registry of types which can be looked up by their full name.
+    /// </summary>
+    public sealed class TypeRegistry
+    {
+        /// <summary>
+        /// An empty type registry, containing no types.
+        /// </summary>
+        public static TypeRegistry Empty { get; } = new TypeRegistry(new Dictionary<string, MessageDescriptor>());
+
+        private readonly Dictionary<string, MessageDescriptor> fullNameToMessageMap;
+
+        private TypeRegistry(Dictionary<string, MessageDescriptor> fullNameToMessageMap)
+        {
+            this.fullNameToMessageMap = fullNameToMessageMap;
+        }
+
+        /// <summary>
+        /// Attempts to find a message descriptor by its full name.
+        /// </summary>
+        /// <param name="fullName">The full name of the message, which is the dot-separated
+        /// combination of package, containing messages and message name</param>
+        /// <returns>The message descriptor corresponding to <paramref name="fullName"/> or null
+        /// if there is no such message descriptor.</returns>
+        public MessageDescriptor Find(string fullName)
+        {
+            MessageDescriptor ret;
+            // Ignore the return value as ret will end up with the right value either way.
+            fullNameToMessageMap.TryGetValue(fullName, out ret);
+            return ret;
+        }
+
+        /// <summary>
+        /// Creates a type registry from the specified set of file descriptors.
+        /// </summary>
+        /// <remarks>
+        /// This is a convenience overload for <see cref="FromFiles(IEnumerable{FileDescriptor})"/>
+        /// to allow calls such as <c>TypeRegistry.FromFiles(descriptor1, descriptor2)</c>.
+        /// </remarks>
+        /// <param name="fileDescriptors">The set of files to include in the registry. Must not contain null values.</param>
+        /// <returns>A type registry for the given files.</returns>
+        public static TypeRegistry FromFiles(params FileDescriptor[] fileDescriptors)
+        {
+            return FromFiles((IEnumerable<FileDescriptor>) fileDescriptors);
+        }
+
+        /// <summary>
+        /// Creates a type registry from the specified set of file descriptors.
+        /// </summary>
+        /// <remarks>
+        /// All message types within all the specified files are added to the registry, and
+        /// the dependencies of the specified files are also added, recursively.
+        /// </remarks>
+        /// <param name="fileDescriptors">The set of files to include in the registry. Must not contain null values.</param>
+        /// <returns>A type registry for the given files.</returns>
+        public static TypeRegistry FromFiles(IEnumerable<FileDescriptor> fileDescriptors)
+        {
+            ProtoPreconditions.CheckNotNull(fileDescriptors, nameof(fileDescriptors));
+            var builder = new Builder();
+            foreach (var file in fileDescriptors)
+            {
+                builder.AddFile(file);
+            }
+            return builder.Build();
+        }
+
+        /// <summary>
+        /// Creates a type registry from the file descriptor parents of the specified set of message descriptors.
+        /// </summary>
+        /// <remarks>
+        /// This is a convenience overload for <see cref="FromMessages(IEnumerable{MessageDescriptor})"/>
+        /// to allow calls such as <c>TypeRegistry.FromFiles(descriptor1, descriptor2)</c>.
+        /// </remarks>
+        /// <param name="messageDescriptors">The set of message descriptors to use to identify file descriptors to include in the registry.
+        /// Must not contain null values.</param>
+        /// <returns>A type registry for the given files.</returns>
+        public static TypeRegistry FromMessages(params MessageDescriptor[] messageDescriptors)
+        {
+            return FromMessages((IEnumerable<MessageDescriptor>) messageDescriptors);
+        }
+
+        /// <summary>
+        /// Creates a type registry from the file descriptor parents of the specified set of message descriptors.
+        /// </summary>
+        /// <remarks>
+        /// The specified message descriptors are only used to identify their file descriptors; the returned registry
+        /// contains all the types within the file descriptors which contain the specified message descriptors (and
+        /// the dependencies of those files), not just the specified messages.
+        /// </remarks>
+        /// <param name="messageDescriptors">The set of message descriptors to use to identify file descriptors to include in the registry.
+        /// Must not contain null values.</param>
+        /// <returns>A type registry for the given files.</returns>
+        public static TypeRegistry FromMessages(IEnumerable<MessageDescriptor> messageDescriptors)
+        {
+            ProtoPreconditions.CheckNotNull(messageDescriptors, nameof(messageDescriptors));
+            return FromFiles(messageDescriptors.Select(md => md.File));
+        }
+
+        /// <summary>
+        /// Builder class which isn't exposed, but acts as a convenient alternative to passing round two dictionaries in recursive calls.
+        /// </summary>
+        private class Builder
+        {
+            private readonly Dictionary<string, MessageDescriptor> types;
+            private readonly HashSet<string> fileDescriptorNames;
+
+            internal Builder()
+            {
+                types = new Dictionary<string, MessageDescriptor>();
+                fileDescriptorNames = new HashSet<string>();
+            }
+
+            internal void AddFile(FileDescriptor fileDescriptor)
+            {
+                if (!fileDescriptorNames.Add(fileDescriptor.Name))
+                {
+                    return;
+                }
+                foreach (var dependency in fileDescriptor.Dependencies)
+                {
+                    AddFile(dependency);
+                }
+                foreach (var message in fileDescriptor.MessageTypes)
+                {
+                    AddMessage(message);
+                }
+            }
+
+            private void AddMessage(MessageDescriptor messageDescriptor)
+            {
+                foreach (var nestedType in messageDescriptor.NestedTypes)
+                {
+                    AddMessage(nestedType);
+                }
+                // This will overwrite any previous entry. Given that each file should
+                // only be added once, this could be a problem such as package A.B with type C,
+                // and package A with type B.C... it's unclear what we should do in that case.
+                types[messageDescriptor.FullName] = messageDescriptor;
+            }
+
+            internal TypeRegistry Build()
+            {
+                return new TypeRegistry(types);
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/SegmentedBufferHelper.cs b/Libs/Google.Protobuf/SegmentedBufferHelper.cs
new file mode 100644
index 0000000..b6fe363
--- /dev/null
+++ b/Libs/Google.Protobuf/SegmentedBufferHelper.cs
@@ -0,0 +1,296 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Abstraction for reading from a stream / read only sequence.
+    /// Parsing from the buffer is a loop of reading from current buffer / refreshing the buffer once done.
+    /// </summary>
+    [SecuritySafeCritical]
+    internal struct SegmentedBufferHelper
+    {
+        private int? totalLength;
+        private ReadOnlySequence<byte>.Enumerator readOnlySequenceEnumerator;
+        private CodedInputStream codedInputStream;
+
+        /// <summary>
+        /// Initialize an instance with a coded input stream.
+        /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+        /// and we can write directly into it without copying.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Initialize(CodedInputStream codedInputStream, out SegmentedBufferHelper instance)
+        {
+            instance.totalLength = codedInputStream.InternalInputStream == null ? (int?)codedInputStream.InternalBuffer.Length : null;
+            instance.readOnlySequenceEnumerator = default;
+            instance.codedInputStream = codedInputStream;
+        }
+
+        /// <summary>
+        /// Initialize an instance with a read only sequence.
+        /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+        /// and we can write directly into it without copying.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Initialize(ReadOnlySequence<byte> sequence, out SegmentedBufferHelper instance, out ReadOnlySpan<byte> firstSpan)
+        {
+            instance.codedInputStream = null;
+            if (sequence.IsSingleSegment)
+            {
+                firstSpan = sequence.First.Span;
+                instance.totalLength = firstSpan.Length;
+                instance.readOnlySequenceEnumerator = default;
+            }
+            else
+            {
+                instance.readOnlySequenceEnumerator = sequence.GetEnumerator();
+                instance.totalLength = (int) sequence.Length;
+
+                // set firstSpan to the first segment
+                instance.readOnlySequenceEnumerator.MoveNext();
+                firstSpan = instance.readOnlySequenceEnumerator.Current.Span;
+            }
+        }
+        
+        public bool RefillBuffer(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, bool mustSucceed)
+        {
+            if (codedInputStream != null)
+            {
+                return RefillFromCodedInputStream(ref buffer, ref state, mustSucceed);
+            }
+            else
+            {
+                return RefillFromReadOnlySequence(ref buffer, ref state, mustSucceed);
+            }
+        }
+
+        public int? TotalLength => totalLength;
+
+        public CodedInputStream CodedInputStream => codedInputStream;
+
+        /// <summary>
+        /// Sets currentLimit to (current position) + byteLimit. This is called
+        /// when descending into a length-delimited embedded message. The previous
+        /// limit is returned.
+        /// </summary>
+        /// <returns>The old limit.</returns>
+        public static int PushLimit(ref ParserInternalState state, int byteLimit)
+        {
+            if (byteLimit < 0)
+            {
+                throw InvalidProtocolBufferException.NegativeSize();
+            }
+            byteLimit += state.totalBytesRetired + state.bufferPos;
+            int oldLimit = state.currentLimit;
+            if (byteLimit > oldLimit)
+            {
+                throw InvalidProtocolBufferException.TruncatedMessage();
+            }
+            state.currentLimit = byteLimit;
+
+            RecomputeBufferSizeAfterLimit(ref state);
+
+            return oldLimit;
+        }
+
+        /// <summary>
+        /// Discards the current limit, returning the previous limit.
+        /// </summary>
+        public static void PopLimit(ref ParserInternalState state, int oldLimit)
+        {
+            state.currentLimit = oldLimit;
+            RecomputeBufferSizeAfterLimit(ref state);
+        }
+
+        /// <summary>
+        /// Returns whether or not all the data before the limit has been read.
+        /// </summary>
+        /// <returns></returns>
+        public static bool IsReachedLimit(ref ParserInternalState state)
+        {
+            if (state.currentLimit == int.MaxValue)
+            {
+                return false;
+            }
+            int currentAbsolutePosition = state.totalBytesRetired + state.bufferPos;
+            return currentAbsolutePosition >= state.currentLimit;
+        }
+
+        /// <summary>
+        /// Returns true if the stream has reached the end of the input. This is the
+        /// case if either the end of the underlying input source has been reached or
+        /// the stream has reached a limit created using PushLimit.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsAtEnd(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
+        {
+            return state.bufferPos == state.bufferSize && !state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, false);
+        }
+
+        private bool RefillFromReadOnlySequence(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, bool mustSucceed)
+        {
+            CheckCurrentBufferIsEmpty(ref state);
+
+            if (state.totalBytesRetired + state.bufferSize == state.currentLimit)
+            {
+                // Oops, we hit a limit.
+                if (mustSucceed)
+                {
+                    throw InvalidProtocolBufferException.TruncatedMessage();
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            state.totalBytesRetired += state.bufferSize;
+
+            state.bufferPos = 0;
+            state.bufferSize = 0;
+            while (readOnlySequenceEnumerator.MoveNext())
+            {
+                buffer = readOnlySequenceEnumerator.Current.Span;
+                state.bufferSize = buffer.Length;
+                if (buffer.Length != 0)
+                {
+                    break;
+                }
+            }
+
+            if (state.bufferSize == 0)
+            {
+                if (mustSucceed)
+                {
+                    throw InvalidProtocolBufferException.TruncatedMessage();
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                RecomputeBufferSizeAfterLimit(ref state);
+                int totalBytesRead =
+                    state.totalBytesRetired + state.bufferSize + state.bufferSizeAfterLimit;
+                if (totalBytesRead < 0 || totalBytesRead > state.sizeLimit)
+                {
+                    throw InvalidProtocolBufferException.SizeLimitExceeded();
+                }
+                return true;
+            }
+        }
+
+        private bool RefillFromCodedInputStream(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, bool mustSucceed)
+        {
+            CheckCurrentBufferIsEmpty(ref state);
+
+            if (state.totalBytesRetired + state.bufferSize == state.currentLimit)
+            {
+                // Oops, we hit a limit.
+                if (mustSucceed)
+                {
+                    throw InvalidProtocolBufferException.TruncatedMessage();
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            Stream input = codedInputStream.InternalInputStream;
+
+            state.totalBytesRetired += state.bufferSize;
+
+            state.bufferPos = 0;
+            state.bufferSize = (input == null) ? 0 : input.Read(codedInputStream.InternalBuffer, 0, buffer.Length);
+            if (state.bufferSize < 0)
+            {
+                throw new InvalidOperationException("Stream.Read returned a negative count");
+            }
+            if (state.bufferSize == 0)
+            {
+                if (mustSucceed)
+                {
+                    throw InvalidProtocolBufferException.TruncatedMessage();
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                RecomputeBufferSizeAfterLimit(ref state);
+                int totalBytesRead =
+                    state.totalBytesRetired + state.bufferSize + state.bufferSizeAfterLimit;
+                if (totalBytesRead < 0 || totalBytesRead > state.sizeLimit)
+                {
+                    throw InvalidProtocolBufferException.SizeLimitExceeded();
+                }
+                return true;
+            }
+        }
+
+        private static void RecomputeBufferSizeAfterLimit(ref ParserInternalState state)
+        {
+            state.bufferSize += state.bufferSizeAfterLimit;
+            int bufferEnd = state.totalBytesRetired + state.bufferSize;
+            if (bufferEnd > state.currentLimit)
+            {
+                // Limit is in current buffer.
+                state.bufferSizeAfterLimit = bufferEnd - state.currentLimit;
+                state.bufferSize -= state.bufferSizeAfterLimit;
+            }
+            else
+            {
+                state.bufferSizeAfterLimit = 0;
+            }
+        }
+
+        private static void CheckCurrentBufferIsEmpty(ref ParserInternalState state)
+        {
+            if (state.bufferPos < state.bufferSize)
+            {
+                throw new InvalidOperationException("RefillBuffer() called when buffer wasn't empty.");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/UnknownField.cs b/Libs/Google.Protobuf/UnknownField.cs
new file mode 100644
index 0000000..6a386d4
--- /dev/null
+++ b/Libs/Google.Protobuf/UnknownField.cs
@@ -0,0 +1,290 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2017 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Represents a single field in an UnknownFieldSet.
+    ///
+    /// An UnknownField consists of four lists of values. The lists correspond
+    /// to the four "wire types" used in the protocol buffer binary format.
+    /// Normally, only one of the four lists will contain any values, since it
+    /// is impossible to define a valid message type that declares two different
+    /// types for the same field number. However, the code is designed to allow
+    /// for the case where the same unknown field number is encountered using
+    /// multiple different wire types.
+    ///
+    /// </summary>
+    internal sealed class UnknownField
+    {
+        private List<ulong> varintList;
+        private List<uint> fixed32List;
+        private List<ulong> fixed64List;
+        private List<ByteString> lengthDelimitedList;
+        private List<UnknownFieldSet> groupList;
+
+        /// <summary>
+        /// Creates a new UnknownField.
+        /// </summary>
+        public UnknownField()
+        {
+        }
+
+        /// <summary>
+        /// Checks if two unknown field are equal.
+        /// </summary>
+        public override bool Equals(object other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+            UnknownField otherField = other as UnknownField;
+            return otherField != null
+                   && Lists.Equals(varintList, otherField.varintList)
+                   && Lists.Equals(fixed32List, otherField.fixed32List)
+                   && Lists.Equals(fixed64List, otherField.fixed64List)
+                   && Lists.Equals(lengthDelimitedList, otherField.lengthDelimitedList)
+                   && Lists.Equals(groupList, otherField.groupList);
+        }
+
+        /// <summary>
+        /// Get the hash code of the unknown field.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            int hash = 43;
+            hash = hash * 47 + Lists.GetHashCode(varintList);
+            hash = hash * 47 + Lists.GetHashCode(fixed32List);
+            hash = hash * 47 + Lists.GetHashCode(fixed64List);
+            hash = hash * 47 + Lists.GetHashCode(lengthDelimitedList);
+            hash = hash * 47 + Lists.GetHashCode(groupList);
+            return hash;
+        }
+
+        /// <summary>
+        /// Serializes the field, including the field number, and writes it to
+        /// <paramref name="output"/>
+        /// </summary>
+        /// <param name="fieldNumber">The unknown field number.</param>
+        /// <param name="output">The write context to write to.</param>
+        internal void WriteTo(int fieldNumber, ref WriteContext output)
+        {
+            if (varintList != null)
+            {
+                foreach (ulong value in varintList)
+                {
+                    output.WriteTag(fieldNumber, WireFormat.WireType.Varint);
+                    output.WriteUInt64(value);
+                }
+            }
+            if (fixed32List != null)
+            {
+                foreach (uint value in fixed32List)
+                {
+                    output.WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
+                    output.WriteFixed32(value);
+                }
+            }
+            if (fixed64List != null)
+            {
+                foreach (ulong value in fixed64List)
+                {
+                    output.WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
+                    output.WriteFixed64(value);
+                }
+            }
+            if (lengthDelimitedList != null)
+            {
+                foreach (ByteString value in lengthDelimitedList)
+                {
+                    output.WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
+                    output.WriteBytes(value);
+                }
+            }
+            if (groupList != null)
+            {
+                foreach (UnknownFieldSet value in groupList)
+                {
+                    output.WriteTag(fieldNumber, WireFormat.WireType.StartGroup);
+                    value.WriteTo(ref output);
+                    output.WriteTag(fieldNumber, WireFormat.WireType.EndGroup);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Computes the number of bytes required to encode this field, including field
+        /// number.
+        /// </summary>
+        internal int GetSerializedSize(int fieldNumber)
+        {
+            int result = 0;
+            if (varintList != null)
+            {
+                result += CodedOutputStream.ComputeTagSize(fieldNumber) * varintList.Count;
+                foreach (ulong value in varintList)
+                {
+                    result += CodedOutputStream.ComputeUInt64Size(value);
+                }
+            }
+            if (fixed32List != null)
+            {
+                result += CodedOutputStream.ComputeTagSize(fieldNumber) * fixed32List.Count;
+                result += CodedOutputStream.ComputeFixed32Size(1) * fixed32List.Count;
+            }
+            if (fixed64List != null)
+            {
+                result += CodedOutputStream.ComputeTagSize(fieldNumber) * fixed64List.Count;
+                result += CodedOutputStream.ComputeFixed64Size(1) * fixed64List.Count;
+            }
+            if (lengthDelimitedList != null)
+            {
+                result += CodedOutputStream.ComputeTagSize(fieldNumber) * lengthDelimitedList.Count;
+                foreach (ByteString value in lengthDelimitedList)
+                {
+                    result += CodedOutputStream.ComputeBytesSize(value);
+                }
+            }
+            if (groupList != null)
+            {
+                result += CodedOutputStream.ComputeTagSize(fieldNumber) * 2 * groupList.Count;
+                foreach (UnknownFieldSet value in groupList)
+                {
+                    result += value.CalculateSize();
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Merge the values in <paramref name="other" /> into this field.  For each list
+        /// of values, <paramref name="other"/>'s values are append to the ones in this
+        /// field.
+        /// </summary>
+        internal UnknownField MergeFrom(UnknownField other)
+        {
+            varintList = AddAll(varintList, other.varintList);
+            fixed32List = AddAll(fixed32List, other.fixed32List);
+            fixed64List = AddAll(fixed64List, other.fixed64List);
+            lengthDelimitedList = AddAll(lengthDelimitedList, other.lengthDelimitedList);
+            groupList = AddAll(groupList, other.groupList);
+            return this;
+        }
+
+        /// <summary>
+        /// Returns a new list containing all of the given specified values from
+        /// both the <paramref name="current"/> and <paramref name="extras"/> lists.
+        /// If <paramref name="current" /> is null and <paramref name="extras"/> is null or empty,
+        /// null is returned. Otherwise, either a new list is created (if <paramref name="current" />
+        /// is null) or the elements of <paramref name="extras"/> are added to <paramref name="current" />.
+        /// </summary>
+        private static List<T> AddAll<T>(List<T> current, IList<T> extras)
+        {
+            if (extras == null || extras.Count == 0)
+            {
+                return current;
+            }
+            if (current == null)
+            {
+                current = new List<T>(extras);
+            }
+            else
+            {
+                current.AddRange(extras);
+            }
+            return current;
+        }
+
+        /// <summary>
+        /// Adds a varint value.
+        /// </summary>
+        internal UnknownField AddVarint(ulong value)
+        {
+            varintList = Add(varintList, value);
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a fixed32 value.
+        /// </summary>
+        internal UnknownField AddFixed32(uint value)
+        {
+            fixed32List = Add(fixed32List, value);
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a fixed64 value.
+        /// </summary>
+        internal UnknownField AddFixed64(ulong value)
+        {
+            fixed64List = Add(fixed64List, value);
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a length-delimited value.
+        /// </summary>
+        internal UnknownField AddLengthDelimited(ByteString value)
+        {
+            lengthDelimitedList = Add(lengthDelimitedList, value);
+            return this;
+        }
+
+        internal UnknownField AddGroup(UnknownFieldSet value)
+        {
+            groupList = Add(groupList, value);
+            return this;
+        }
+
+        /// <summary>
+        /// Adds <paramref name="value"/> to the <paramref name="list"/>, creating
+        /// a new list if <paramref name="list"/> is null. The list is returned - either
+        /// the original reference or the new list.
+        /// </summary>
+        private static List<T> Add<T>(List<T> list, T value)
+        {
+            if (list == null)
+            {
+                list = new List<T>();
+            }
+            list.Add(value);
+            return list;
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/UnknownFieldSet.cs b/Libs/Google.Protobuf/UnknownFieldSet.cs
new file mode 100644
index 0000000..039d396
--- /dev/null
+++ b/Libs/Google.Protobuf/UnknownFieldSet.cs
@@ -0,0 +1,393 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security;
+using LC.Google.Protobuf.Reflection;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Used to keep track of fields which were seen when parsing a protocol message
+    /// but whose field numbers or types are unrecognized. This most frequently
+    /// occurs when new fields are added to a message type and then messages containing
+    /// those fields are read by old software that was built before the new types were
+    /// added.
+    ///
+    /// Most users will never need to use this class directly.
+    /// </summary>
+    public sealed partial class UnknownFieldSet
+    {
+        private readonly IDictionary<int, UnknownField> fields;
+
+        /// <summary>
+        /// Creates a new UnknownFieldSet.
+        /// </summary>
+        internal UnknownFieldSet()
+        {
+            this.fields = new Dictionary<int, UnknownField>();
+        }
+
+        /// <summary>
+        /// Checks whether or not the given field number is present in the set.
+        /// </summary>
+        internal bool HasField(int field)
+        {
+            return fields.ContainsKey(field);
+        }
+
+        /// <summary>
+        /// Serializes the set and writes it to <paramref name="output"/>.
+        /// </summary>
+        public void WriteTo(CodedOutputStream output)
+        {
+            WriteContext.Initialize(output, out WriteContext ctx);
+            try
+            {
+                WriteTo(ref ctx);
+            }
+            finally
+            {
+                ctx.CopyStateTo(output);
+            }
+        }
+
+        /// <summary>
+        /// Serializes the set and writes it to <paramref name="ctx"/>.
+        /// </summary>
+        [SecuritySafeCritical]
+        public void WriteTo(ref WriteContext ctx)
+        {
+            foreach (KeyValuePair<int, UnknownField> entry in fields)
+            {
+                entry.Value.WriteTo(entry.Key, ref ctx);
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of bytes required to encode this set.
+        /// </summary>
+        public int CalculateSize()
+        {
+            int result = 0;
+            foreach (KeyValuePair<int, UnknownField> entry in fields)
+            {
+                result += entry.Value.GetSerializedSize(entry.Key);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Checks if two unknown field sets are equal.
+        /// </summary>
+        public override bool Equals(object other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+            UnknownFieldSet otherSet = other as UnknownFieldSet;
+            IDictionary<int, UnknownField> otherFields = otherSet.fields;
+            if (fields.Count  != otherFields.Count)
+            {
+                return false;
+            }
+            foreach (KeyValuePair<int, UnknownField> leftEntry in fields)
+            {
+                UnknownField rightValue;
+                if (!otherFields.TryGetValue(leftEntry.Key, out rightValue))
+                {
+                    return false;
+                }
+                if (!leftEntry.Value.Equals(rightValue))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the unknown field set's hash code.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            int ret = 1;
+            foreach (KeyValuePair<int, UnknownField> field in fields)
+            {
+                // Use ^ here to make the field order irrelevant.
+                int hash = field.Key.GetHashCode() ^ field.Value.GetHashCode();
+                ret ^= hash;
+            }
+            return ret;
+        }
+
+        // Optimization:  We keep around the last field that was
+        // modified so that we can efficiently add to it multiple times in a
+        // row (important when parsing an unknown repeated field).
+        private int lastFieldNumber;
+        private UnknownField lastField;
+
+        private UnknownField GetOrAddField(int number)
+        {
+            if (lastField != null && number == lastFieldNumber)
+            {
+                return lastField;
+            }
+            if (number == 0)
+            {
+                return null;
+            }
+
+            UnknownField existing;
+            if (fields.TryGetValue(number, out existing))
+            {
+                return existing;
+            }
+            lastField = new UnknownField();
+            AddOrReplaceField(number, lastField);
+            lastFieldNumber = number;
+            return lastField;
+        }
+
+        /// <summary>
+        /// Adds a field to the set. If a field with the same number already exists, it
+        /// is replaced.
+        /// </summary>
+        internal UnknownFieldSet AddOrReplaceField(int number, UnknownField field)
+        {
+            if (number == 0)
+            {
+                throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number.");
+            }
+            fields[number] = field;
+            return this;
+        }
+        
+        /// <summary>
+        /// Parse a single field from <paramref name="ctx"/> and merge it
+        /// into this set.
+        /// </summary>
+        /// <param name="ctx">The parse context from which to read the field</param>
+        /// <returns>false if the tag is an "end group" tag, true otherwise</returns>
+        private bool MergeFieldFrom(ref ParseContext ctx)
+        {
+            uint tag = ctx.LastTag;
+            int number = WireFormat.GetTagFieldNumber(tag);
+            switch (WireFormat.GetTagWireType(tag))
+            {
+                case WireFormat.WireType.Varint:
+                    {
+                        ulong uint64 = ctx.ReadUInt64();
+                        GetOrAddField(number).AddVarint(uint64);
+                        return true;
+                    }
+                case WireFormat.WireType.Fixed32:
+                    {
+                        uint uint32 = ctx.ReadFixed32();
+                        GetOrAddField(number).AddFixed32(uint32);
+                        return true;
+                    }
+                case WireFormat.WireType.Fixed64:
+                    {
+                        ulong uint64 = ctx.ReadFixed64();
+                        GetOrAddField(number).AddFixed64(uint64);
+                        return true;
+                    }
+                case WireFormat.WireType.LengthDelimited:
+                    {
+                        ByteString bytes = ctx.ReadBytes();
+                        GetOrAddField(number).AddLengthDelimited(bytes);
+                        return true;
+                    }
+                case WireFormat.WireType.StartGroup:
+                    {
+                        UnknownFieldSet set = new UnknownFieldSet();
+                        ParsingPrimitivesMessages.ReadGroup(ref ctx, number, set);
+                        GetOrAddField(number).AddGroup(set);
+                        return true;
+                    }
+                case WireFormat.WireType.EndGroup:
+                    {
+                        return false;
+                    }
+                default:
+                    throw InvalidProtocolBufferException.InvalidWireType();
+            }
+        }
+
+        internal void MergeGroupFrom(ref ParseContext ctx)
+        {
+            while (true)
+            {
+                uint tag = ctx.ReadTag();
+                if (tag == 0)
+                {
+                    break;
+                }
+                if (!MergeFieldFrom(ref ctx))
+                {
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Create a new UnknownFieldSet if unknownFields is null.
+        /// Parse a single field from <paramref name="input"/> and merge it
+        /// into unknownFields. If <paramref name="input"/> is configured to discard unknown fields,
+        /// <paramref name="unknownFields"/> will be returned as-is and the field will be skipped.
+        /// </summary>
+        /// <param name="unknownFields">The UnknownFieldSet which need to be merged</param>
+        /// <param name="input">The coded input stream containing the field</param>
+        /// <returns>The merged UnknownFieldSet</returns>
+        public static UnknownFieldSet MergeFieldFrom(UnknownFieldSet unknownFields,
+                                                     CodedInputStream input)
+        {
+            ParseContext.Initialize(input, out ParseContext ctx);
+            try
+            {
+                return MergeFieldFrom(unknownFields, ref ctx);
+            }
+            finally
+            {
+                ctx.CopyStateTo(input);
+            }
+        }
+
+        /// <summary>
+        /// Create a new UnknownFieldSet if unknownFields is null.
+        /// Parse a single field from <paramref name="ctx"/> and merge it
+        /// into unknownFields. If <paramref name="ctx"/> is configured to discard unknown fields,
+        /// <paramref name="unknownFields"/> will be returned as-is and the field will be skipped.
+        /// </summary>
+        /// <param name="unknownFields">The UnknownFieldSet which need to be merged</param>
+        /// <param name="ctx">The parse context from which to read the field</param>
+        /// <returns>The merged UnknownFieldSet</returns>
+        [SecuritySafeCritical]
+        public static UnknownFieldSet MergeFieldFrom(UnknownFieldSet unknownFields,
+                                                     ref ParseContext ctx)
+        {
+            if (ctx.DiscardUnknownFields)
+            {
+                ParsingPrimitivesMessages.SkipLastField(ref ctx.buffer, ref ctx.state);
+                return unknownFields;
+            }
+            if (unknownFields == null)
+            {
+                unknownFields = new UnknownFieldSet();
+            }
+            if (!unknownFields.MergeFieldFrom(ref ctx))
+            {
+                throw new InvalidProtocolBufferException("Merge an unknown field of end-group tag, indicating that the corresponding start-group was missing."); // match the old code-gen
+            }
+            return unknownFields;
+        }
+
+        /// <summary>
+        /// Merges the fields from <paramref name="other"/> into this set.
+        /// If a field number exists in both sets, the values in <paramref name="other"/>
+        /// will be appended to the values in this set.
+        /// </summary>
+        private UnknownFieldSet MergeFrom(UnknownFieldSet other)
+        {
+            if (other != null)
+            {
+                foreach (KeyValuePair<int, UnknownField> entry in other.fields)
+                {
+                    MergeField(entry.Key, entry.Value);
+                }
+            }
+            return this;
+        }
+
+        /// <summary>
+        /// Created a new UnknownFieldSet to <paramref name="unknownFields"/> if
+        /// needed and merges the fields from <paramref name="other"/> into the first set.
+        /// If a field number exists in both sets, the values in <paramref name="other"/>
+        /// will be appended to the values in this set.
+        /// </summary>
+        public static UnknownFieldSet MergeFrom(UnknownFieldSet unknownFields,
+                                                UnknownFieldSet other)
+        {
+            if (other == null)
+            {
+                return unknownFields;
+            }
+            if (unknownFields == null)
+            {
+                unknownFields = new UnknownFieldSet();
+            }
+            unknownFields.MergeFrom(other);
+            return unknownFields;
+        }
+
+
+        /// <summary>
+        /// Adds a field to the unknown field set. If a field with the same
+        /// number already exists, the two are merged.
+        /// </summary>
+        private UnknownFieldSet MergeField(int number, UnknownField field)
+        {
+            if (number == 0)
+            {
+                throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number.");
+            }
+            if (HasField(number))
+            {
+                GetOrAddField(number).MergeFrom(field);
+            }
+            else
+            {
+                AddOrReplaceField(number, field);
+            }
+            return this;
+        }
+
+        /// <summary>
+        /// Clone an unknown field set from <paramref name="other"/>.
+        /// </summary>
+        public static UnknownFieldSet Clone(UnknownFieldSet other)
+        {
+            if (other == null)
+            {
+                return null;
+            }
+            UnknownFieldSet unknownFields = new UnknownFieldSet();
+            unknownFields.MergeFrom(other);
+            return unknownFields;
+        }
+    }
+}
+
diff --git a/Libs/Google.Protobuf/UnsafeByteOperations.cs b/Libs/Google.Protobuf/UnsafeByteOperations.cs
new file mode 100644
index 0000000..42cc138
--- /dev/null
+++ b/Libs/Google.Protobuf/UnsafeByteOperations.cs
@@ -0,0 +1,81 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Provides a number of unsafe byte operations to be used by advanced applications with high performance
+    /// requirements. These methods are referred to as "unsafe" due to the fact that they potentially expose
+    /// the backing buffer of a <see cref="ByteString"/> to the application.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The methods in this class should only be called if it is guaranteed that the buffer backing the
+    /// <see cref="ByteString"/> will never change! Mutation of a <see cref="ByteString"/> can lead to unexpected
+    /// and undesirable consequences in your application, and will likely be difficult to debug. Proceed with caution!
+    /// </para>
+    /// <para>
+    /// This can have a number of significant side affects that have spooky-action-at-a-distance-like behavior. In
+    /// particular, if the bytes value changes out from under a Protocol Buffer:
+    /// </para>
+    /// <list type="bullet">
+    /// <item>
+    /// <description>serialization may throw</description>
+    /// </item>
+    /// <item>
+    /// <description>serialization may succeed but the wrong bytes may be written out</description>
+    /// </item>
+    /// <item>
+    /// <description>objects that are normally immutable (such as ByteString) are no longer immutable</description>
+    /// </item>
+    /// <item>
+    /// <description>hashCode may be incorrect</description>
+    /// </item>
+    /// </list>
+    /// </remarks>
+    [SecuritySafeCritical]
+    public static class UnsafeByteOperations
+    {
+        /// <summary>
+        /// Constructs a new <see cref="ByteString" /> from the given bytes. The bytes are not copied,
+        /// and must not be modified while the <see cref="ByteString" /> is in use.
+        /// This API is experimental and subject to change.
+        /// </summary>
+        public static ByteString UnsafeWrap(ReadOnlyMemory<byte> bytes)
+        {
+            return ByteString.AttachBytes(bytes);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Any.cs b/Libs/Google.Protobuf/WellKnownTypes/Any.cs
new file mode 100644
index 0000000..c4d0b7d
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Any.cs
@@ -0,0 +1,369 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/any.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/any.proto</summary>
+  public static partial class AnyReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/any.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static AnyReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Chlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvEg9nb29nbGUucHJvdG9idWYi",
+            "JgoDQW55EhAKCHR5cGVfdXJsGAEgASgJEg0KBXZhbHVlGAIgASgMQnYKE2Nv",
+            "bS5nb29nbGUucHJvdG9idWZCCEFueVByb3RvUAFaLGdvb2dsZS5nb2xhbmcu",
+            "b3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2FueXBiogIDR1BCqgIeR29vZ2xl",
+            "LlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Any), global::LC.Google.Protobuf.WellKnownTypes.Any.Parser, new[]{ "TypeUrl", "Value" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// `Any` contains an arbitrary serialized protocol buffer message along with a
+  /// URL that describes the type of the serialized message.
+  ///
+  /// Protobuf library provides support to pack/unpack Any values in the form
+  /// of utility functions or additional generated methods of the Any type.
+  ///
+  /// Example 1: Pack and unpack a message in C++.
+  ///
+  ///     Foo foo = ...;
+  ///     Any any;
+  ///     any.PackFrom(foo);
+  ///     ...
+  ///     if (any.UnpackTo(&amp;foo)) {
+  ///       ...
+  ///     }
+  ///
+  /// Example 2: Pack and unpack a message in Java.
+  ///
+  ///     Foo foo = ...;
+  ///     Any any = Any.pack(foo);
+  ///     ...
+  ///     if (any.is(Foo.class)) {
+  ///       foo = any.unpack(Foo.class);
+  ///     }
+  ///
+  ///  Example 3: Pack and unpack a message in Python.
+  ///
+  ///     foo = Foo(...)
+  ///     any = Any()
+  ///     any.Pack(foo)
+  ///     ...
+  ///     if any.Is(Foo.DESCRIPTOR):
+  ///       any.Unpack(foo)
+  ///       ...
+  ///
+  ///  Example 4: Pack and unpack a message in Go
+  ///
+  ///      foo := &amp;pb.Foo{...}
+  ///      any, err := anypb.New(foo)
+  ///      if err != nil {
+  ///        ...
+  ///      }
+  ///      ...
+  ///      foo := &amp;pb.Foo{}
+  ///      if err := any.UnmarshalTo(foo); err != nil {
+  ///        ...
+  ///      }
+  ///
+  /// The pack methods provided by protobuf library will by default use
+  /// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+  /// methods only use the fully qualified type name after the last '/'
+  /// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+  /// name "y.z".
+  ///
+  /// JSON
+  /// ====
+  /// The JSON representation of an `Any` value uses the regular
+  /// representation of the deserialized, embedded message, with an
+  /// additional field `@type` which contains the type URL. Example:
+  ///
+  ///     package google.profile;
+  ///     message Person {
+  ///       string first_name = 1;
+  ///       string last_name = 2;
+  ///     }
+  ///
+  ///     {
+  ///       "@type": "type.googleapis.com/google.profile.Person",
+  ///       "firstName": &lt;string>,
+  ///       "lastName": &lt;string>
+  ///     }
+  ///
+  /// If the embedded message type is well-known and has a custom JSON
+  /// representation, that representation will be embedded adding a field
+  /// `value` which holds the custom JSON in addition to the `@type`
+  /// field. Example (for message [google.protobuf.Duration][]):
+  ///
+  ///     {
+  ///       "@type": "type.googleapis.com/google.protobuf.Duration",
+  ///       "value": "1.212s"
+  ///     }
+  /// </summary>
+  public sealed partial class Any : pb::IMessage<Any>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Any> _parser = new pb::MessageParser<Any>(() => new Any());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Any> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.AnyReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Any() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Any(Any other) : this() {
+      typeUrl_ = other.typeUrl_;
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Any Clone() {
+      return new Any(this);
+    }
+
+    /// <summary>Field number for the "type_url" field.</summary>
+    public const int TypeUrlFieldNumber = 1;
+    private string typeUrl_ = "";
+    /// <summary>
+    /// A URL/resource name that uniquely identifies the type of the serialized
+    /// protocol buffer message. This string must contain at least
+    /// one "/" character. The last segment of the URL's path must represent
+    /// the fully qualified name of the type (as in
+    /// `path/google.protobuf.Duration`). The name should be in a canonical form
+    /// (e.g., leading "." is not accepted).
+    ///
+    /// In practice, teams usually precompile into the binary all types that they
+    /// expect it to use in the context of Any. However, for URLs which use the
+    /// scheme `http`, `https`, or no scheme, one can optionally set up a type
+    /// server that maps type URLs to message definitions as follows:
+    ///
+    /// * If no scheme is provided, `https` is assumed.
+    /// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+    ///   value in binary format, or produce an error.
+    /// * Applications are allowed to cache lookup results based on the
+    ///   URL, or have them precompiled into a binary to avoid any
+    ///   lookup. Therefore, binary compatibility needs to be preserved
+    ///   on changes to types. (Use versioned type names to manage
+    ///   breaking changes.)
+    ///
+    /// Note: this functionality is not currently available in the official
+    /// protobuf release, and it is not used for type URLs beginning with
+    /// type.googleapis.com.
+    ///
+    /// Schemes other than `http`, `https` (or the empty scheme) might be
+    /// used with implementation specific semantics.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string TypeUrl {
+      get { return typeUrl_; }
+      set {
+        typeUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 2;
+    private pb::ByteString value_ = pb::ByteString.Empty;
+    /// <summary>
+    /// Must be a valid serialized protocol buffer of the above specified type.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pb::ByteString Value {
+      get { return value_; }
+      set {
+        value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Any);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Any other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (TypeUrl != other.TypeUrl) return false;
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (TypeUrl.Length != 0) hash ^= TypeUrl.GetHashCode();
+      if (Value.Length != 0) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (TypeUrl.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(TypeUrl);
+      }
+      if (Value.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteBytes(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (TypeUrl.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(TypeUrl);
+      }
+      if (Value.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteBytes(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (TypeUrl.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(TypeUrl);
+      }
+      if (Value.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeBytesSize(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Any other) {
+      if (other == null) {
+        return;
+      }
+      if (other.TypeUrl.Length != 0) {
+        TypeUrl = other.TypeUrl;
+      }
+      if (other.Value.Length != 0) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            TypeUrl = input.ReadString();
+            break;
+          }
+          case 18: {
+            Value = input.ReadBytes();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            TypeUrl = input.ReadString();
+            break;
+          }
+          case 18: {
+            Value = input.ReadBytes();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/AnyPartial.cs b/Libs/Google.Protobuf/WellKnownTypes/AnyPartial.cs
new file mode 100644
index 0000000..cfd6760
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/AnyPartial.cs
@@ -0,0 +1,147 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using LC.Google.Protobuf.Reflection;
+
+namespace LC.Google.Protobuf.WellKnownTypes
+{
+    public partial class Any
+    {
+        private const string DefaultPrefix = "type.googleapis.com";
+
+        // This could be moved to MessageDescriptor if we wanted to, but keeping it here means
+        // all the Any-specific code is in the same place.
+        private static string GetTypeUrl(MessageDescriptor descriptor, string prefix) =>
+            prefix.EndsWith("/") ? prefix + descriptor.FullName : prefix + "/" + descriptor.FullName;
+
+        /// <summary>
+        /// Retrieves the type name for a type URL, matching the <see cref="DescriptorBase.FullName"/>
+        /// of the packed message type.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This is always just the last part of the URL, after the final slash. No validation of
+        /// anything before the trailing slash is performed. If the type URL does not include a slash,
+        /// an empty string is returned rather than an exception being thrown; this won't match any types,
+        /// and the calling code is probably in a better position to give a meaningful error.
+        /// </para>
+        /// <para>
+        /// There is no handling of fragments or queries  at the moment.
+        /// </para>
+        /// </remarks>
+        /// <param name="typeUrl">The URL to extract the type name from</param>
+        /// <returns>The type name</returns>
+        public static string GetTypeName(string typeUrl)
+        {
+            ProtoPreconditions.CheckNotNull(typeUrl, nameof(typeUrl));
+            int lastSlash = typeUrl.LastIndexOf('/');
+            return lastSlash == -1 ? "" : typeUrl.Substring(lastSlash + 1);
+        }
+
+        /// <summary>
+        /// Returns a bool indictating whether this Any message is of the target message type
+        /// </summary>
+        /// <param name="descriptor">The descriptor of the message type</param>
+        /// <returns><c>true</c> if the type name matches the descriptor's full name or <c>false</c> otherwise</returns>
+        public bool Is(MessageDescriptor descriptor)
+        {
+            ProtoPreconditions.CheckNotNull(descriptor, nameof(descriptor));
+            return GetTypeName(TypeUrl) == descriptor.FullName;
+        }
+
+        /// <summary>
+        /// Unpacks the content of this Any message into the target message type,
+        /// which must match the type URL within this Any message.
+        /// </summary>
+        /// <typeparam name="T">The type of message to unpack the content into.</typeparam>
+        /// <returns>The unpacked message.</returns>
+        /// <exception cref="InvalidProtocolBufferException">The target message type doesn't match the type URL in this message</exception>
+        public T Unpack<T>() where T : IMessage, new()
+        {
+            // Note: this doesn't perform as well is it might. We could take a MessageParser<T> in an alternative overload,
+            // which would be expected to perform slightly better... although the difference is likely to be negligible.
+            T target = new T();
+            if (GetTypeName(TypeUrl) != target.Descriptor.FullName)
+            {
+                throw new InvalidProtocolBufferException(
+                    $"Full type name for {target.Descriptor.Name} is {target.Descriptor.FullName}; Any message's type url is {TypeUrl}");
+            }
+            target.MergeFrom(Value);
+            return target;
+        }
+
+        /// <summary>
+        /// Attempts to unpack the content of this Any message into the target message type,
+        /// if it matches the type URL within this Any message.
+        /// </summary>
+        /// <typeparam name="T">The type of message to attempt to unpack the content into.</typeparam>
+        /// <returns><c>true</c> if the message was successfully unpacked; <c>false</c> if the type name didn't match</returns>
+        public bool TryUnpack<T>(out T result) where T : IMessage, new()
+        {
+            // Note: deliberately avoid writing anything to result until the end, in case it's being
+            // monitored by other threads. (That would be a bug in the calling code, but let's not make it worse.)
+            T target = new T();
+            if (GetTypeName(TypeUrl) != target.Descriptor.FullName)
+            {
+                result = default(T); // Can't use null as there's no class constraint, but this always *will* be null in real usage.
+                return false;
+            }
+            target.MergeFrom(Value);
+            result = target;
+            return true;
+        }
+
+        /// <summary>
+        /// Packs the specified message into an Any message using a type URL prefix of "type.googleapis.com".
+        /// </summary>
+        /// <param name="message">The message to pack.</param>
+        /// <returns>An Any message with the content and type URL of <paramref name="message"/>.</returns>
+        public static Any Pack(IMessage message) => Pack(message, DefaultPrefix);
+
+        /// <summary>
+        /// Packs the specified message into an Any message using the specified type URL prefix.
+        /// </summary>
+        /// <param name="message">The message to pack.</param>
+        /// <param name="typeUrlPrefix">The prefix for the type URL.</param>
+        /// <returns>An Any message with the content and type URL of <paramref name="message"/>.</returns>
+        public static Any Pack(IMessage message, string typeUrlPrefix)
+        {
+            ProtoPreconditions.CheckNotNull(message, nameof(message));
+            ProtoPreconditions.CheckNotNull(typeUrlPrefix, nameof(typeUrlPrefix));
+            return new Any
+            {
+                TypeUrl = GetTypeUrl(message.Descriptor, typeUrlPrefix),
+                Value = message.ToByteString()
+            };
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Api.cs b/Libs/Google.Protobuf/WellKnownTypes/Api.cs
new file mode 100644
index 0000000..176d509
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Api.cs
@@ -0,0 +1,1172 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/api.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/api.proto</summary>
+  public static partial class ApiReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/api.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static ApiReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Chlnb29nbGUvcHJvdG9idWYvYXBpLnByb3RvEg9nb29nbGUucHJvdG9idWYa",
+            "JGdvb2dsZS9wcm90b2J1Zi9zb3VyY2VfY29udGV4dC5wcm90bxoaZ29vZ2xl",
+            "L3Byb3RvYnVmL3R5cGUucHJvdG8igQIKA0FwaRIMCgRuYW1lGAEgASgJEigK",
+            "B21ldGhvZHMYAiADKAsyFy5nb29nbGUucHJvdG9idWYuTWV0aG9kEigKB29w",
+            "dGlvbnMYAyADKAsyFy5nb29nbGUucHJvdG9idWYuT3B0aW9uEg8KB3ZlcnNp",
+            "b24YBCABKAkSNgoOc291cmNlX2NvbnRleHQYBSABKAsyHi5nb29nbGUucHJv",
+            "dG9idWYuU291cmNlQ29udGV4dBImCgZtaXhpbnMYBiADKAsyFi5nb29nbGUu",
+            "cHJvdG9idWYuTWl4aW4SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3Rv",
+            "YnVmLlN5bnRheCLVAQoGTWV0aG9kEgwKBG5hbWUYASABKAkSGAoQcmVxdWVz",
+            "dF90eXBlX3VybBgCIAEoCRIZChFyZXF1ZXN0X3N0cmVhbWluZxgDIAEoCBIZ",
+            "ChFyZXNwb25zZV90eXBlX3VybBgEIAEoCRIaChJyZXNwb25zZV9zdHJlYW1p",
+            "bmcYBSABKAgSKAoHb3B0aW9ucxgGIAMoCzIXLmdvb2dsZS5wcm90b2J1Zi5P",
+            "cHRpb24SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3RvYnVmLlN5bnRh",
+            "eCIjCgVNaXhpbhIMCgRuYW1lGAEgASgJEgwKBHJvb3QYAiABKAlCdgoTY29t",
+            "Lmdvb2dsZS5wcm90b2J1ZkIIQXBpUHJvdG9QAVosZ29vZ2xlLmdvbGFuZy5v",
+            "cmcvcHJvdG9idWYvdHlwZXMva25vd24vYXBpcGKiAgNHUEKqAh5Hb29nbGUu",
+            "UHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::LC.Google.Protobuf.WellKnownTypes.SourceContextReflection.Descriptor, global::LC.Google.Protobuf.WellKnownTypes.TypeReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Api), global::LC.Google.Protobuf.WellKnownTypes.Api.Parser, new[]{ "Name", "Methods", "Options", "Version", "SourceContext", "Mixins", "Syntax" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Method), global::LC.Google.Protobuf.WellKnownTypes.Method.Parser, new[]{ "Name", "RequestTypeUrl", "RequestStreaming", "ResponseTypeUrl", "ResponseStreaming", "Options", "Syntax" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Mixin), global::LC.Google.Protobuf.WellKnownTypes.Mixin.Parser, new[]{ "Name", "Root" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// Api is a light-weight descriptor for an API Interface.
+  ///
+  /// Interfaces are also described as "protocol buffer services" in some contexts,
+  /// such as by the "service" keyword in a .proto file, but they are different
+  /// from API Services, which represent a concrete implementation of an interface
+  /// as opposed to simply a description of methods and bindings. They are also
+  /// sometimes simply referred to as "APIs" in other contexts, such as the name of
+  /// this message itself. See https://cloud.google.com/apis/design/glossary for
+  /// detailed terminology.
+  /// </summary>
+  public sealed partial class Api : pb::IMessage<Api>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Api> _parser = new pb::MessageParser<Api>(() => new Api());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Api> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.ApiReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Api() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Api(Api other) : this() {
+      name_ = other.name_;
+      methods_ = other.methods_.Clone();
+      options_ = other.options_.Clone();
+      version_ = other.version_;
+      sourceContext_ = other.sourceContext_ != null ? other.sourceContext_.Clone() : null;
+      mixins_ = other.mixins_.Clone();
+      syntax_ = other.syntax_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Api Clone() {
+      return new Api(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// The fully qualified name of this interface, including package name
+    /// followed by the interface's simple name.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "methods" field.</summary>
+    public const int MethodsFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Method> _repeated_methods_codec
+        = pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.WellKnownTypes.Method.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Method> methods_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Method>();
+    /// <summary>
+    /// The methods of this interface, in unspecified order.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Method> Methods {
+      get { return methods_; }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 3;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Option> _repeated_options_codec
+        = pb::FieldCodec.ForMessage(26, global::LC.Google.Protobuf.WellKnownTypes.Option.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> options_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option>();
+    /// <summary>
+    /// Any metadata attached to the interface.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> Options {
+      get { return options_; }
+    }
+
+    /// <summary>Field number for the "version" field.</summary>
+    public const int VersionFieldNumber = 4;
+    private string version_ = "";
+    /// <summary>
+    /// A version string for this interface. If specified, must have the form
+    /// `major-version.minor-version`, as in `1.10`. If the minor version is
+    /// omitted, it defaults to zero. If the entire version field is empty, the
+    /// major version is derived from the package name, as outlined below. If the
+    /// field is not empty, the version in the package name will be verified to be
+    /// consistent with what is provided here.
+    ///
+    /// The versioning schema uses [semantic
+    /// versioning](http://semver.org) where the major version number
+    /// indicates a breaking change and the minor version an additive,
+    /// non-breaking change. Both version numbers are signals to users
+    /// what to expect from different versions, and should be carefully
+    /// chosen based on the product plan.
+    ///
+    /// The major version is also reflected in the package name of the
+    /// interface, which must end in `v&lt;major-version>`, as in
+    /// `google.feature.v1`. For major versions 0 and 1, the suffix can
+    /// be omitted. Zero major versions must only be used for
+    /// experimental, non-GA interfaces.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Version {
+      get { return version_; }
+      set {
+        version_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "source_context" field.</summary>
+    public const int SourceContextFieldNumber = 5;
+    private global::LC.Google.Protobuf.WellKnownTypes.SourceContext sourceContext_;
+    /// <summary>
+    /// Source context for the protocol buffer service represented by this
+    /// message.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.SourceContext SourceContext {
+      get { return sourceContext_; }
+      set {
+        sourceContext_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "mixins" field.</summary>
+    public const int MixinsFieldNumber = 6;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Mixin> _repeated_mixins_codec
+        = pb::FieldCodec.ForMessage(50, global::LC.Google.Protobuf.WellKnownTypes.Mixin.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Mixin> mixins_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Mixin>();
+    /// <summary>
+    /// Included interfaces. See [Mixin][].
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Mixin> Mixins {
+      get { return mixins_; }
+    }
+
+    /// <summary>Field number for the "syntax" field.</summary>
+    public const int SyntaxFieldNumber = 7;
+    private global::LC.Google.Protobuf.WellKnownTypes.Syntax syntax_ = global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2;
+    /// <summary>
+    /// The source syntax of the service.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Syntax Syntax {
+      get { return syntax_; }
+      set {
+        syntax_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Api);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Api other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if(!methods_.Equals(other.methods_)) return false;
+      if(!options_.Equals(other.options_)) return false;
+      if (Version != other.Version) return false;
+      if (!object.Equals(SourceContext, other.SourceContext)) return false;
+      if(!mixins_.Equals(other.mixins_)) return false;
+      if (Syntax != other.Syntax) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      hash ^= methods_.GetHashCode();
+      hash ^= options_.GetHashCode();
+      if (Version.Length != 0) hash ^= Version.GetHashCode();
+      if (sourceContext_ != null) hash ^= SourceContext.GetHashCode();
+      hash ^= mixins_.GetHashCode();
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) hash ^= Syntax.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      methods_.WriteTo(output, _repeated_methods_codec);
+      options_.WriteTo(output, _repeated_options_codec);
+      if (Version.Length != 0) {
+        output.WriteRawTag(34);
+        output.WriteString(Version);
+      }
+      if (sourceContext_ != null) {
+        output.WriteRawTag(42);
+        output.WriteMessage(SourceContext);
+      }
+      mixins_.WriteTo(output, _repeated_mixins_codec);
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(56);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      methods_.WriteTo(ref output, _repeated_methods_codec);
+      options_.WriteTo(ref output, _repeated_options_codec);
+      if (Version.Length != 0) {
+        output.WriteRawTag(34);
+        output.WriteString(Version);
+      }
+      if (sourceContext_ != null) {
+        output.WriteRawTag(42);
+        output.WriteMessage(SourceContext);
+      }
+      mixins_.WriteTo(ref output, _repeated_mixins_codec);
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(56);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      size += methods_.CalculateSize(_repeated_methods_codec);
+      size += options_.CalculateSize(_repeated_options_codec);
+      if (Version.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Version);
+      }
+      if (sourceContext_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(SourceContext);
+      }
+      size += mixins_.CalculateSize(_repeated_mixins_codec);
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Api other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      methods_.Add(other.methods_);
+      options_.Add(other.options_);
+      if (other.Version.Length != 0) {
+        Version = other.Version;
+      }
+      if (other.sourceContext_ != null) {
+        if (sourceContext_ == null) {
+          SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+        }
+        SourceContext.MergeFrom(other.SourceContext);
+      }
+      mixins_.Add(other.mixins_);
+      if (other.Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        Syntax = other.Syntax;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            methods_.AddEntriesFrom(input, _repeated_methods_codec);
+            break;
+          }
+          case 26: {
+            options_.AddEntriesFrom(input, _repeated_options_codec);
+            break;
+          }
+          case 34: {
+            Version = input.ReadString();
+            break;
+          }
+          case 42: {
+            if (sourceContext_ == null) {
+              SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+            }
+            input.ReadMessage(SourceContext);
+            break;
+          }
+          case 50: {
+            mixins_.AddEntriesFrom(input, _repeated_mixins_codec);
+            break;
+          }
+          case 56: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            methods_.AddEntriesFrom(ref input, _repeated_methods_codec);
+            break;
+          }
+          case 26: {
+            options_.AddEntriesFrom(ref input, _repeated_options_codec);
+            break;
+          }
+          case 34: {
+            Version = input.ReadString();
+            break;
+          }
+          case 42: {
+            if (sourceContext_ == null) {
+              SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+            }
+            input.ReadMessage(SourceContext);
+            break;
+          }
+          case 50: {
+            mixins_.AddEntriesFrom(ref input, _repeated_mixins_codec);
+            break;
+          }
+          case 56: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Method represents a method of an API interface.
+  /// </summary>
+  public sealed partial class Method : pb::IMessage<Method>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Method> _parser = new pb::MessageParser<Method>(() => new Method());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Method> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.ApiReflection.Descriptor.MessageTypes[1]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Method() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Method(Method other) : this() {
+      name_ = other.name_;
+      requestTypeUrl_ = other.requestTypeUrl_;
+      requestStreaming_ = other.requestStreaming_;
+      responseTypeUrl_ = other.responseTypeUrl_;
+      responseStreaming_ = other.responseStreaming_;
+      options_ = other.options_.Clone();
+      syntax_ = other.syntax_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Method Clone() {
+      return new Method(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// The simple name of this method.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "request_type_url" field.</summary>
+    public const int RequestTypeUrlFieldNumber = 2;
+    private string requestTypeUrl_ = "";
+    /// <summary>
+    /// A URL of the input message type.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string RequestTypeUrl {
+      get { return requestTypeUrl_; }
+      set {
+        requestTypeUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "request_streaming" field.</summary>
+    public const int RequestStreamingFieldNumber = 3;
+    private bool requestStreaming_;
+    /// <summary>
+    /// If true, the request is streamed.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool RequestStreaming {
+      get { return requestStreaming_; }
+      set {
+        requestStreaming_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "response_type_url" field.</summary>
+    public const int ResponseTypeUrlFieldNumber = 4;
+    private string responseTypeUrl_ = "";
+    /// <summary>
+    /// The URL of the output message type.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string ResponseTypeUrl {
+      get { return responseTypeUrl_; }
+      set {
+        responseTypeUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "response_streaming" field.</summary>
+    public const int ResponseStreamingFieldNumber = 5;
+    private bool responseStreaming_;
+    /// <summary>
+    /// If true, the response is streamed.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool ResponseStreaming {
+      get { return responseStreaming_; }
+      set {
+        responseStreaming_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 6;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Option> _repeated_options_codec
+        = pb::FieldCodec.ForMessage(50, global::LC.Google.Protobuf.WellKnownTypes.Option.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> options_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option>();
+    /// <summary>
+    /// Any metadata attached to the method.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> Options {
+      get { return options_; }
+    }
+
+    /// <summary>Field number for the "syntax" field.</summary>
+    public const int SyntaxFieldNumber = 7;
+    private global::LC.Google.Protobuf.WellKnownTypes.Syntax syntax_ = global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2;
+    /// <summary>
+    /// The source syntax of this method.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Syntax Syntax {
+      get { return syntax_; }
+      set {
+        syntax_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Method);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Method other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (RequestTypeUrl != other.RequestTypeUrl) return false;
+      if (RequestStreaming != other.RequestStreaming) return false;
+      if (ResponseTypeUrl != other.ResponseTypeUrl) return false;
+      if (ResponseStreaming != other.ResponseStreaming) return false;
+      if(!options_.Equals(other.options_)) return false;
+      if (Syntax != other.Syntax) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      if (RequestTypeUrl.Length != 0) hash ^= RequestTypeUrl.GetHashCode();
+      if (RequestStreaming != false) hash ^= RequestStreaming.GetHashCode();
+      if (ResponseTypeUrl.Length != 0) hash ^= ResponseTypeUrl.GetHashCode();
+      if (ResponseStreaming != false) hash ^= ResponseStreaming.GetHashCode();
+      hash ^= options_.GetHashCode();
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) hash ^= Syntax.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (RequestTypeUrl.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteString(RequestTypeUrl);
+      }
+      if (RequestStreaming != false) {
+        output.WriteRawTag(24);
+        output.WriteBool(RequestStreaming);
+      }
+      if (ResponseTypeUrl.Length != 0) {
+        output.WriteRawTag(34);
+        output.WriteString(ResponseTypeUrl);
+      }
+      if (ResponseStreaming != false) {
+        output.WriteRawTag(40);
+        output.WriteBool(ResponseStreaming);
+      }
+      options_.WriteTo(output, _repeated_options_codec);
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(56);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (RequestTypeUrl.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteString(RequestTypeUrl);
+      }
+      if (RequestStreaming != false) {
+        output.WriteRawTag(24);
+        output.WriteBool(RequestStreaming);
+      }
+      if (ResponseTypeUrl.Length != 0) {
+        output.WriteRawTag(34);
+        output.WriteString(ResponseTypeUrl);
+      }
+      if (ResponseStreaming != false) {
+        output.WriteRawTag(40);
+        output.WriteBool(ResponseStreaming);
+      }
+      options_.WriteTo(ref output, _repeated_options_codec);
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(56);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (RequestTypeUrl.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestTypeUrl);
+      }
+      if (RequestStreaming != false) {
+        size += 1 + 1;
+      }
+      if (ResponseTypeUrl.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(ResponseTypeUrl);
+      }
+      if (ResponseStreaming != false) {
+        size += 1 + 1;
+      }
+      size += options_.CalculateSize(_repeated_options_codec);
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Method other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      if (other.RequestTypeUrl.Length != 0) {
+        RequestTypeUrl = other.RequestTypeUrl;
+      }
+      if (other.RequestStreaming != false) {
+        RequestStreaming = other.RequestStreaming;
+      }
+      if (other.ResponseTypeUrl.Length != 0) {
+        ResponseTypeUrl = other.ResponseTypeUrl;
+      }
+      if (other.ResponseStreaming != false) {
+        ResponseStreaming = other.ResponseStreaming;
+      }
+      options_.Add(other.options_);
+      if (other.Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        Syntax = other.Syntax;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            RequestTypeUrl = input.ReadString();
+            break;
+          }
+          case 24: {
+            RequestStreaming = input.ReadBool();
+            break;
+          }
+          case 34: {
+            ResponseTypeUrl = input.ReadString();
+            break;
+          }
+          case 40: {
+            ResponseStreaming = input.ReadBool();
+            break;
+          }
+          case 50: {
+            options_.AddEntriesFrom(input, _repeated_options_codec);
+            break;
+          }
+          case 56: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            RequestTypeUrl = input.ReadString();
+            break;
+          }
+          case 24: {
+            RequestStreaming = input.ReadBool();
+            break;
+          }
+          case 34: {
+            ResponseTypeUrl = input.ReadString();
+            break;
+          }
+          case 40: {
+            ResponseStreaming = input.ReadBool();
+            break;
+          }
+          case 50: {
+            options_.AddEntriesFrom(ref input, _repeated_options_codec);
+            break;
+          }
+          case 56: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Declares an API Interface to be included in this interface. The including
+  /// interface must redeclare all the methods from the included interface, but
+  /// documentation and options are inherited as follows:
+  ///
+  /// - If after comment and whitespace stripping, the documentation
+  ///   string of the redeclared method is empty, it will be inherited
+  ///   from the original method.
+  ///
+  /// - Each annotation belonging to the service config (http,
+  ///   visibility) which is not set in the redeclared method will be
+  ///   inherited.
+  ///
+  /// - If an http annotation is inherited, the path pattern will be
+  ///   modified as follows. Any version prefix will be replaced by the
+  ///   version of the including interface plus the [root][] path if
+  ///   specified.
+  ///
+  /// Example of a simple mixin:
+  ///
+  ///     package google.acl.v1;
+  ///     service AccessControl {
+  ///       // Get the underlying ACL object.
+  ///       rpc GetAcl(GetAclRequest) returns (Acl) {
+  ///         option (google.api.http).get = "/v1/{resource=**}:getAcl";
+  ///       }
+  ///     }
+  ///
+  ///     package google.storage.v2;
+  ///     service Storage {
+  ///       rpc GetAcl(GetAclRequest) returns (Acl);
+  ///
+  ///       // Get a data record.
+  ///       rpc GetData(GetDataRequest) returns (Data) {
+  ///         option (google.api.http).get = "/v2/{resource=**}";
+  ///       }
+  ///     }
+  ///
+  /// Example of a mixin configuration:
+  ///
+  ///     apis:
+  ///     - name: google.storage.v2.Storage
+  ///       mixins:
+  ///       - name: google.acl.v1.AccessControl
+  ///
+  /// The mixin construct implies that all methods in `AccessControl` are
+  /// also declared with same name and request/response types in
+  /// `Storage`. A documentation generator or annotation processor will
+  /// see the effective `Storage.GetAcl` method after inheriting
+  /// documentation and annotations as follows:
+  ///
+  ///     service Storage {
+  ///       // Get the underlying ACL object.
+  ///       rpc GetAcl(GetAclRequest) returns (Acl) {
+  ///         option (google.api.http).get = "/v2/{resource=**}:getAcl";
+  ///       }
+  ///       ...
+  ///     }
+  ///
+  /// Note how the version in the path pattern changed from `v1` to `v2`.
+  ///
+  /// If the `root` field in the mixin is specified, it should be a
+  /// relative path under which inherited HTTP paths are placed. Example:
+  ///
+  ///     apis:
+  ///     - name: google.storage.v2.Storage
+  ///       mixins:
+  ///       - name: google.acl.v1.AccessControl
+  ///         root: acls
+  ///
+  /// This implies the following inherited HTTP annotation:
+  ///
+  ///     service Storage {
+  ///       // Get the underlying ACL object.
+  ///       rpc GetAcl(GetAclRequest) returns (Acl) {
+  ///         option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
+  ///       }
+  ///       ...
+  ///     }
+  /// </summary>
+  public sealed partial class Mixin : pb::IMessage<Mixin>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Mixin> _parser = new pb::MessageParser<Mixin>(() => new Mixin());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Mixin> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.ApiReflection.Descriptor.MessageTypes[2]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Mixin() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Mixin(Mixin other) : this() {
+      name_ = other.name_;
+      root_ = other.root_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Mixin Clone() {
+      return new Mixin(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// The fully qualified name of the interface which is included.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "root" field.</summary>
+    public const int RootFieldNumber = 2;
+    private string root_ = "";
+    /// <summary>
+    /// If non-empty specifies a path under which inherited HTTP paths
+    /// are rooted.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Root {
+      get { return root_; }
+      set {
+        root_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Mixin);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Mixin other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (Root != other.Root) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      if (Root.Length != 0) hash ^= Root.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (Root.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteString(Root);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (Root.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteString(Root);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (Root.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Root);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Mixin other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      if (other.Root.Length != 0) {
+        Root = other.Root;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            Root = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            Root = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Duration.cs b/Libs/Google.Protobuf/WellKnownTypes/Duration.cs
new file mode 100644
index 0000000..4df6c97
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Duration.cs
@@ -0,0 +1,328 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/duration.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/duration.proto</summary>
+  public static partial class DurationReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/duration.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static DurationReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Ch5nb29nbGUvcHJvdG9idWYvZHVyYXRpb24ucHJvdG8SD2dvb2dsZS5wcm90",
+            "b2J1ZiIqCghEdXJhdGlvbhIPCgdzZWNvbmRzGAEgASgDEg0KBW5hbm9zGAIg",
+            "ASgFQoMBChNjb20uZ29vZ2xlLnByb3RvYnVmQg1EdXJhdGlvblByb3RvUAFa",
+            "MWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2R1cmF0",
+            "aW9ucGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlw",
+            "ZXNiBnByb3RvMw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Duration), global::LC.Google.Protobuf.WellKnownTypes.Duration.Parser, new[]{ "Seconds", "Nanos" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// A Duration represents a signed, fixed-length span of time represented
+  /// as a count of seconds and fractions of seconds at nanosecond
+  /// resolution. It is independent of any calendar and concepts like "day"
+  /// or "month". It is related to Timestamp in that the difference between
+  /// two Timestamp values is a Duration and it can be added or subtracted
+  /// from a Timestamp. Range is approximately +-10,000 years.
+  ///
+  /// # Examples
+  ///
+  /// Example 1: Compute Duration from two Timestamps in pseudo code.
+  ///
+  ///     Timestamp start = ...;
+  ///     Timestamp end = ...;
+  ///     Duration duration = ...;
+  ///
+  ///     duration.seconds = end.seconds - start.seconds;
+  ///     duration.nanos = end.nanos - start.nanos;
+  ///
+  ///     if (duration.seconds &lt; 0 &amp;&amp; duration.nanos > 0) {
+  ///       duration.seconds += 1;
+  ///       duration.nanos -= 1000000000;
+  ///     } else if (duration.seconds > 0 &amp;&amp; duration.nanos &lt; 0) {
+  ///       duration.seconds -= 1;
+  ///       duration.nanos += 1000000000;
+  ///     }
+  ///
+  /// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+  ///
+  ///     Timestamp start = ...;
+  ///     Duration duration = ...;
+  ///     Timestamp end = ...;
+  ///
+  ///     end.seconds = start.seconds + duration.seconds;
+  ///     end.nanos = start.nanos + duration.nanos;
+  ///
+  ///     if (end.nanos &lt; 0) {
+  ///       end.seconds -= 1;
+  ///       end.nanos += 1000000000;
+  ///     } else if (end.nanos >= 1000000000) {
+  ///       end.seconds += 1;
+  ///       end.nanos -= 1000000000;
+  ///     }
+  ///
+  /// Example 3: Compute Duration from datetime.timedelta in Python.
+  ///
+  ///     td = datetime.timedelta(days=3, minutes=10)
+  ///     duration = Duration()
+  ///     duration.FromTimedelta(td)
+  ///
+  /// # JSON Mapping
+  ///
+  /// In JSON format, the Duration type is encoded as a string rather than an
+  /// object, where the string ends in the suffix "s" (indicating seconds) and
+  /// is preceded by the number of seconds, with nanoseconds expressed as
+  /// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+  /// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+  /// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+  /// microsecond should be expressed in JSON format as "3.000001s".
+  /// </summary>
+  public sealed partial class Duration : pb::IMessage<Duration>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Duration> _parser = new pb::MessageParser<Duration>(() => new Duration());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Duration> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Duration() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Duration(Duration other) : this() {
+      seconds_ = other.seconds_;
+      nanos_ = other.nanos_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Duration Clone() {
+      return new Duration(this);
+    }
+
+    /// <summary>Field number for the "seconds" field.</summary>
+    public const int SecondsFieldNumber = 1;
+    private long seconds_;
+    /// <summary>
+    /// Signed seconds of the span of time. Must be from -315,576,000,000
+    /// to +315,576,000,000 inclusive. Note: these bounds are computed from:
+    /// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public long Seconds {
+      get { return seconds_; }
+      set {
+        seconds_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "nanos" field.</summary>
+    public const int NanosFieldNumber = 2;
+    private int nanos_;
+    /// <summary>
+    /// Signed fractions of a second at nanosecond resolution of the span
+    /// of time. Durations less than one second are represented with a 0
+    /// `seconds` field and a positive or negative `nanos` field. For durations
+    /// of one second or more, a non-zero value for the `nanos` field must be
+    /// of the same sign as the `seconds` field. Must be from -999,999,999
+    /// to +999,999,999 inclusive.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int Nanos {
+      get { return nanos_; }
+      set {
+        nanos_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Duration);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Duration other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Seconds != other.Seconds) return false;
+      if (Nanos != other.Nanos) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Seconds != 0L) hash ^= Seconds.GetHashCode();
+      if (Nanos != 0) hash ^= Nanos.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Seconds != 0L) {
+        output.WriteRawTag(8);
+        output.WriteInt64(Seconds);
+      }
+      if (Nanos != 0) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Nanos);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Seconds != 0L) {
+        output.WriteRawTag(8);
+        output.WriteInt64(Seconds);
+      }
+      if (Nanos != 0) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Nanos);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Seconds != 0L) {
+        size += 1 + pb::CodedOutputStream.ComputeInt64Size(Seconds);
+      }
+      if (Nanos != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Nanos);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Duration other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Seconds != 0L) {
+        Seconds = other.Seconds;
+      }
+      if (other.Nanos != 0) {
+        Nanos = other.Nanos;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Seconds = input.ReadInt64();
+            break;
+          }
+          case 16: {
+            Nanos = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Seconds = input.ReadInt64();
+            break;
+          }
+          case 16: {
+            Nanos = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/DurationPartial.cs b/Libs/Google.Protobuf/WellKnownTypes/DurationPartial.cs
new file mode 100644
index 0000000..4c031ea
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/DurationPartial.cs
@@ -0,0 +1,270 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace LC.Google.Protobuf.WellKnownTypes
+{
+    // Manually-written partial class for the Duration well-known type,
+    // providing a conversion to TimeSpan and convenience operators.
+    public partial class Duration : ICustomDiagnosticMessage
+    {
+        /// <summary>
+        /// The number of nanoseconds in a second.
+        /// </summary>
+        public const int NanosecondsPerSecond = 1000000000;
+        /// <summary>
+        /// The number of nanoseconds in a BCL tick (as used by <see cref="TimeSpan"/> and <see cref="DateTime"/>).
+        /// </summary>
+        public const int NanosecondsPerTick = 100;
+
+        /// <summary>
+        /// The maximum permitted number of seconds.
+        /// </summary>
+        public const long MaxSeconds = 315576000000L;
+
+        /// <summary>
+        /// The minimum permitted number of seconds.
+        /// </summary>
+        public const long MinSeconds = -315576000000L;
+
+        internal const int MaxNanoseconds = NanosecondsPerSecond - 1;
+        internal const int MinNanoseconds = -NanosecondsPerSecond + 1;
+
+        internal static bool IsNormalized(long seconds, int nanoseconds)
+        {
+            // Simple boundaries
+            if (seconds < MinSeconds || seconds > MaxSeconds ||
+                nanoseconds < MinNanoseconds || nanoseconds > MaxNanoseconds)
+            {
+                return false;
+            }
+            // We only have a problem is one is strictly negative and the other is
+            // strictly positive.
+            return Math.Sign(seconds) * Math.Sign(nanoseconds) != -1;
+        }
+
+        /// <summary>
+        /// Converts this <see cref="Duration"/> to a <see cref="TimeSpan"/>.
+        /// </summary>
+        /// <remarks>If the duration is not a precise number of ticks, it is truncated towards 0.</remarks>
+        /// <returns>The value of this duration, as a <c>TimeSpan</c>.</returns>
+        /// <exception cref="InvalidOperationException">This value isn't a valid normalized duration, as
+        /// described in the documentation.</exception>
+        public TimeSpan ToTimeSpan()
+        {
+            checked
+            {
+                if (!IsNormalized(Seconds, Nanos))
+                {
+                    throw new InvalidOperationException("Duration was not a valid normalized duration");
+                }
+                long ticks = Seconds * TimeSpan.TicksPerSecond + Nanos / NanosecondsPerTick;
+                return TimeSpan.FromTicks(ticks);
+            }
+        }
+
+        /// <summary>
+        /// Converts the given <see cref="TimeSpan"/> to a <see cref="Duration"/>.
+        /// </summary>
+        /// <param name="timeSpan">The <c>TimeSpan</c> to convert.</param>
+        /// <returns>The value of the given <c>TimeSpan</c>, as a <c>Duration</c>.</returns>
+        public static Duration FromTimeSpan(TimeSpan timeSpan)
+        {
+            checked
+            {
+                long ticks = timeSpan.Ticks;
+                long seconds = ticks / TimeSpan.TicksPerSecond;
+                int nanos = (int) (ticks % TimeSpan.TicksPerSecond) * NanosecondsPerTick;
+                return new Duration { Seconds = seconds, Nanos = nanos };
+            }
+        }
+
+        /// <summary>
+        /// Returns the result of negating the duration. For example, the negation of 5 minutes is -5 minutes.
+        /// </summary>
+        /// <param name="value">The duration to negate. Must not be null.</param>
+        /// <returns>The negated value of this duration.</returns>
+        public static Duration operator -(Duration value)
+        {
+            ProtoPreconditions.CheckNotNull(value, "value");
+            checked
+            {
+                return Normalize(-value.Seconds, -value.Nanos);
+            }
+        }
+
+        /// <summary>
+        /// Adds the two specified <see cref="Duration"/> values together.
+        /// </summary>
+        /// <param name="lhs">The first value to add. Must not be null.</param>
+        /// <param name="rhs">The second value to add. Must not be null.</param>
+        /// <returns></returns>
+        public static Duration operator +(Duration lhs, Duration rhs)
+        {
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
+            checked
+            {
+                return Normalize(lhs.Seconds + rhs.Seconds, lhs.Nanos + rhs.Nanos);
+            }
+        }
+
+        /// <summary>
+        /// Subtracts one <see cref="Duration"/> from another.
+        /// </summary>
+        /// <param name="lhs">The duration to subtract from. Must not be null.</param>
+        /// <param name="rhs">The duration to subtract. Must not be null.</param>
+        /// <returns>The difference between the two specified durations.</returns>
+        public static Duration operator -(Duration lhs, Duration rhs)
+        {
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
+            checked
+            {
+                return Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos);
+            }
+        }
+
+        /// <summary>
+        /// Creates a duration with the normalized values from the given number of seconds and
+        /// nanoseconds, conforming with the description in the proto file.
+        /// </summary>
+        internal static Duration Normalize(long seconds, int nanoseconds)
+        {
+            // Ensure that nanoseconds is in the range (-1,000,000,000, +1,000,000,000)
+            int extraSeconds = nanoseconds / NanosecondsPerSecond;
+            seconds += extraSeconds;
+            nanoseconds -= extraSeconds * NanosecondsPerSecond;
+
+            // Now make sure that Sign(seconds) == Sign(nanoseconds) if Sign(seconds) != 0.
+            if (seconds < 0 && nanoseconds > 0)
+            {
+                seconds += 1;
+                nanoseconds -= NanosecondsPerSecond;
+            }
+            else if (seconds > 0 && nanoseconds < 0)
+            {
+                seconds -= 1;
+                nanoseconds += NanosecondsPerSecond;
+            }
+            return new Duration { Seconds = seconds, Nanos = nanoseconds };
+        }
+
+        /// <summary>
+        /// Converts a duration specified in seconds/nanoseconds to a string.
+        /// </summary>
+        /// <remarks>
+        /// If the value is a normalized duration in the range described in <c>duration.proto</c>,
+        /// <paramref name="diagnosticOnly"/> is ignored. Otherwise, if the parameter is <c>true</c>,
+        /// a JSON object with a warning is returned; if it is <c>false</c>, an <see cref="InvalidOperationException"/> is thrown.
+        /// </remarks>
+        /// <param name="seconds">Seconds portion of the duration.</param>
+        /// <param name="nanoseconds">Nanoseconds portion of the duration.</param>
+        /// <param name="diagnosticOnly">Determines the handling of non-normalized values</param>
+        /// <exception cref="InvalidOperationException">The represented duration is invalid, and <paramref name="diagnosticOnly"/> is <c>false</c>.</exception>
+        internal static string ToJson(long seconds, int nanoseconds, bool diagnosticOnly)
+        {
+            if (IsNormalized(seconds, nanoseconds))
+            {
+                var builder = new StringBuilder();
+                builder.Append('"');
+                // The seconds part will normally provide the minus sign if we need it, but not if it's 0...
+                if (seconds == 0 && nanoseconds < 0)
+                {
+                    builder.Append('-');
+                }
+
+                builder.Append(seconds.ToString("d", CultureInfo.InvariantCulture));
+                AppendNanoseconds(builder, Math.Abs(nanoseconds));
+                builder.Append("s\"");
+                return builder.ToString();
+            }
+            if (diagnosticOnly)
+            {
+                // Note: the double braces here are escaping for braces in format strings.
+                return string.Format(CultureInfo.InvariantCulture,
+                    "{{ \"@warning\": \"Invalid Duration\", \"seconds\": \"{0}\", \"nanos\": {1} }}",
+                    seconds,
+                    nanoseconds);
+            }
+            else
+            {
+                throw new InvalidOperationException("Non-normalized duration value");
+            }
+        }
+
+        /// <summary>
+        /// Returns a string representation of this <see cref="Duration"/> for diagnostic purposes.
+        /// </summary>
+        /// <remarks>
+        /// Normally the returned value will be a JSON string value (including leading and trailing quotes) but
+        /// when the value is non-normalized or out of range, a JSON object representation will be returned
+        /// instead, including a warning. This is to avoid exceptions being thrown when trying to
+        /// diagnose problems - the regular JSON formatter will still throw an exception for non-normalized
+        /// values.
+        /// </remarks>
+        /// <returns>A string representation of this value.</returns>
+        public string ToDiagnosticString()
+        {
+            return ToJson(Seconds, Nanos, true);
+        }
+
+        /// <summary>
+        /// Appends a number of nanoseconds to a StringBuilder. Either 0 digits are added (in which
+        /// case no "." is appended), or 3 6 or 9 digits. This is internal for use in Timestamp as well
+        /// as Duration.
+        /// </summary>
+        internal static void AppendNanoseconds(StringBuilder builder, int nanos)
+        {
+            if (nanos != 0)
+            {
+                builder.Append('.');
+                // Output to 3, 6 or 9 digits.
+                if (nanos % 1000000 == 0)
+                {
+                    builder.Append((nanos / 1000000).ToString("d3", CultureInfo.InvariantCulture));
+                }
+                else if (nanos % 1000 == 0)
+                {
+                    builder.Append((nanos / 1000).ToString("d6", CultureInfo.InvariantCulture));
+                }
+                else
+                {
+                    builder.Append(nanos.ToString("d9", CultureInfo.InvariantCulture));
+                }
+            }
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Empty.cs b/Libs/Google.Protobuf/WellKnownTypes/Empty.cs
new file mode 100644
index 0000000..cbcbe5e
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Empty.cs
@@ -0,0 +1,193 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/empty.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/empty.proto</summary>
+  public static partial class EmptyReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/empty.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static EmptyReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Chtnb29nbGUvcHJvdG9idWYvZW1wdHkucHJvdG8SD2dvb2dsZS5wcm90b2J1",
+            "ZiIHCgVFbXB0eUJ9ChNjb20uZ29vZ2xlLnByb3RvYnVmQgpFbXB0eVByb3Rv",
+            "UAFaLmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2Vt",
+            "cHR5cGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlw",
+            "ZXNiBnByb3RvMw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Empty), global::LC.Google.Protobuf.WellKnownTypes.Empty.Parser, null, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// A generic empty message that you can re-use to avoid defining duplicated
+  /// empty messages in your APIs. A typical example is to use it as the request
+  /// or the response type of an API method. For instance:
+  ///
+  ///     service Foo {
+  ///       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+  ///     }
+  ///
+  /// The JSON representation for `Empty` is empty JSON object `{}`.
+  /// </summary>
+  public sealed partial class Empty : pb::IMessage<Empty>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Empty> _parser = new pb::MessageParser<Empty>(() => new Empty());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Empty> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Empty() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Empty(Empty other) : this() {
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Empty Clone() {
+      return new Empty(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Empty);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Empty other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Empty other) {
+      if (other == null) {
+        return;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/FieldMask.cs b/Libs/Google.Protobuf/WellKnownTypes/FieldMask.cs
new file mode 100644
index 0000000..56b3a33
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/FieldMask.cs
@@ -0,0 +1,410 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/field_mask.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/field_mask.proto</summary>
+  public static partial class FieldMaskReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/field_mask.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static FieldMaskReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFzay5wcm90bxIPZ29vZ2xlLnBy",
+            "b3RvYnVmIhoKCUZpZWxkTWFzaxINCgVwYXRocxgBIAMoCUKFAQoTY29tLmdv",
+            "b2dsZS5wcm90b2J1ZkIORmllbGRNYXNrUHJvdG9QAVoyZ29vZ2xlLmdvbGFu",
+            "Zy5vcmcvcHJvdG9idWYvdHlwZXMva25vd24vZmllbGRtYXNrcGL4AQGiAgNH",
+            "UEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.FieldMask), global::LC.Google.Protobuf.WellKnownTypes.FieldMask.Parser, new[]{ "Paths" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// `FieldMask` represents a set of symbolic field paths, for example:
+  ///
+  ///     paths: "f.a"
+  ///     paths: "f.b.d"
+  ///
+  /// Here `f` represents a field in some root message, `a` and `b`
+  /// fields in the message found in `f`, and `d` a field found in the
+  /// message in `f.b`.
+  ///
+  /// Field masks are used to specify a subset of fields that should be
+  /// returned by a get operation or modified by an update operation.
+  /// Field masks also have a custom JSON encoding (see below).
+  ///
+  /// # Field Masks in Projections
+  ///
+  /// When used in the context of a projection, a response message or
+  /// sub-message is filtered by the API to only contain those fields as
+  /// specified in the mask. For example, if the mask in the previous
+  /// example is applied to a response message as follows:
+  ///
+  ///     f {
+  ///       a : 22
+  ///       b {
+  ///         d : 1
+  ///         x : 2
+  ///       }
+  ///       y : 13
+  ///     }
+  ///     z: 8
+  ///
+  /// The result will not contain specific values for fields x,y and z
+  /// (their value will be set to the default, and omitted in proto text
+  /// output):
+  ///
+  ///     f {
+  ///       a : 22
+  ///       b {
+  ///         d : 1
+  ///       }
+  ///     }
+  ///
+  /// A repeated field is not allowed except at the last position of a
+  /// paths string.
+  ///
+  /// If a FieldMask object is not present in a get operation, the
+  /// operation applies to all fields (as if a FieldMask of all fields
+  /// had been specified).
+  ///
+  /// Note that a field mask does not necessarily apply to the
+  /// top-level response message. In case of a REST get operation, the
+  /// field mask applies directly to the response, but in case of a REST
+  /// list operation, the mask instead applies to each individual message
+  /// in the returned resource list. In case of a REST custom method,
+  /// other definitions may be used. Where the mask applies will be
+  /// clearly documented together with its declaration in the API.  In
+  /// any case, the effect on the returned resource/resources is required
+  /// behavior for APIs.
+  ///
+  /// # Field Masks in Update Operations
+  ///
+  /// A field mask in update operations specifies which fields of the
+  /// targeted resource are going to be updated. The API is required
+  /// to only change the values of the fields as specified in the mask
+  /// and leave the others untouched. If a resource is passed in to
+  /// describe the updated values, the API ignores the values of all
+  /// fields not covered by the mask.
+  ///
+  /// If a repeated field is specified for an update operation, new values will
+  /// be appended to the existing repeated field in the target resource. Note that
+  /// a repeated field is only allowed in the last position of a `paths` string.
+  ///
+  /// If a sub-message is specified in the last position of the field mask for an
+  /// update operation, then new value will be merged into the existing sub-message
+  /// in the target resource.
+  ///
+  /// For example, given the target message:
+  ///
+  ///     f {
+  ///       b {
+  ///         d: 1
+  ///         x: 2
+  ///       }
+  ///       c: [1]
+  ///     }
+  ///
+  /// And an update message:
+  ///
+  ///     f {
+  ///       b {
+  ///         d: 10
+  ///       }
+  ///       c: [2]
+  ///     }
+  ///
+  /// then if the field mask is:
+  ///
+  ///  paths: ["f.b", "f.c"]
+  ///
+  /// then the result will be:
+  ///
+  ///     f {
+  ///       b {
+  ///         d: 10
+  ///         x: 2
+  ///       }
+  ///       c: [1, 2]
+  ///     }
+  ///
+  /// An implementation may provide options to override this default behavior for
+  /// repeated and message fields.
+  ///
+  /// In order to reset a field's value to the default, the field must
+  /// be in the mask and set to the default value in the provided resource.
+  /// Hence, in order to reset all fields of a resource, provide a default
+  /// instance of the resource and set all fields in the mask, or do
+  /// not provide a mask as described below.
+  ///
+  /// If a field mask is not present on update, the operation applies to
+  /// all fields (as if a field mask of all fields has been specified).
+  /// Note that in the presence of schema evolution, this may mean that
+  /// fields the client does not know and has therefore not filled into
+  /// the request will be reset to their default. If this is unwanted
+  /// behavior, a specific service may require a client to always specify
+  /// a field mask, producing an error if not.
+  ///
+  /// As with get operations, the location of the resource which
+  /// describes the updated values in the request message depends on the
+  /// operation kind. In any case, the effect of the field mask is
+  /// required to be honored by the API.
+  ///
+  /// ## Considerations for HTTP REST
+  ///
+  /// The HTTP kind of an update operation which uses a field mask must
+  /// be set to PATCH instead of PUT in order to satisfy HTTP semantics
+  /// (PUT must only be used for full updates).
+  ///
+  /// # JSON Encoding of Field Masks
+  ///
+  /// In JSON, a field mask is encoded as a single string where paths are
+  /// separated by a comma. Fields name in each path are converted
+  /// to/from lower-camel naming conventions.
+  ///
+  /// As an example, consider the following message declarations:
+  ///
+  ///     message Profile {
+  ///       User user = 1;
+  ///       Photo photo = 2;
+  ///     }
+  ///     message User {
+  ///       string display_name = 1;
+  ///       string address = 2;
+  ///     }
+  ///
+  /// In proto a field mask for `Profile` may look as such:
+  ///
+  ///     mask {
+  ///       paths: "user.display_name"
+  ///       paths: "photo"
+  ///     }
+  ///
+  /// In JSON, the same mask is represented as below:
+  ///
+  ///     {
+  ///       mask: "user.displayName,photo"
+  ///     }
+  ///
+  /// # Field Masks and Oneof Fields
+  ///
+  /// Field masks treat fields in oneofs just as regular fields. Consider the
+  /// following message:
+  ///
+  ///     message SampleMessage {
+  ///       oneof test_oneof {
+  ///         string name = 4;
+  ///         SubMessage sub_message = 9;
+  ///       }
+  ///     }
+  ///
+  /// The field mask can be:
+  ///
+  ///     mask {
+  ///       paths: "name"
+  ///     }
+  ///
+  /// Or:
+  ///
+  ///     mask {
+  ///       paths: "sub_message"
+  ///     }
+  ///
+  /// Note that oneof type names ("test_oneof" in this case) cannot be used in
+  /// paths.
+  ///
+  /// ## Field Mask Verification
+  ///
+  /// The implementation of any API method which has a FieldMask type field in the
+  /// request should verify the included field paths, and return an
+  /// `INVALID_ARGUMENT` error if any path is unmappable.
+  /// </summary>
+  public sealed partial class FieldMask : pb::IMessage<FieldMask>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FieldMask> _parser = new pb::MessageParser<FieldMask>(() => new FieldMask());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<FieldMask> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldMask() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldMask(FieldMask other) : this() {
+      paths_ = other.paths_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FieldMask Clone() {
+      return new FieldMask(this);
+    }
+
+    /// <summary>Field number for the "paths" field.</summary>
+    public const int PathsFieldNumber = 1;
+    private static readonly pb::FieldCodec<string> _repeated_paths_codec
+        = pb::FieldCodec.ForString(10);
+    private readonly pbc::RepeatedField<string> paths_ = new pbc::RepeatedField<string>();
+    /// <summary>
+    /// The set of field mask paths.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<string> Paths {
+      get { return paths_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as FieldMask);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(FieldMask other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!paths_.Equals(other.paths_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= paths_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      paths_.WriteTo(output, _repeated_paths_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      paths_.WriteTo(ref output, _repeated_paths_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += paths_.CalculateSize(_repeated_paths_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(FieldMask other) {
+      if (other == null) {
+        return;
+      }
+      paths_.Add(other.paths_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            paths_.AddEntriesFrom(input, _repeated_paths_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            paths_.AddEntriesFrom(ref input, _repeated_paths_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/FieldMaskPartial.cs b/Libs/Google.Protobuf/WellKnownTypes/FieldMaskPartial.cs
new file mode 100644
index 0000000..fdc4dd8
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/FieldMaskPartial.cs
@@ -0,0 +1,370 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2016 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using LC.Google.Protobuf.Reflection;
+
+namespace LC.Google.Protobuf.WellKnownTypes
+{
+    // Manually-written partial class for the FieldMask well-known type.
+    public partial class FieldMask : ICustomDiagnosticMessage
+    {
+        private const char FIELD_PATH_SEPARATOR = ',';
+        private const char FIELD_SEPARATOR_REGEX = '.';
+
+        /// <summary>
+        /// Converts a field mask specified by paths to a string.
+        /// </summary>
+        /// <remarks>
+        /// If the value is a normalized duration in the range described in <c>field_mask.proto</c>,
+        /// <paramref name="diagnosticOnly"/> is ignored. Otherwise, if the parameter is <c>true</c>,
+        /// a JSON object with a warning is returned; if it is <c>false</c>, an <see cref="InvalidOperationException"/> is thrown.
+        /// </remarks>
+        /// <param name="paths">Paths in the field mask</param>
+        /// <param name="diagnosticOnly">Determines the handling of non-normalized values</param>
+        /// <exception cref="InvalidOperationException">The represented field mask is invalid, and <paramref name="diagnosticOnly"/> is <c>false</c>.</exception>
+        internal static string ToJson(IList<string> paths, bool diagnosticOnly)
+        {
+            var firstInvalid = paths.FirstOrDefault(p => !IsPathValid(p));
+            if (firstInvalid == null)
+            {
+                var writer = new StringWriter();
+#if NET35
+                var query = paths.Select(JsonFormatter.ToJsonName);
+                JsonFormatter.WriteString(writer, string.Join(",", query.ToArray()));
+#else
+                JsonFormatter.WriteString(writer, string.Join(",", paths.Select(JsonFormatter.ToJsonName)));
+#endif
+                return writer.ToString();
+            }
+            else
+            {
+                if (diagnosticOnly)
+                {
+                    var writer = new StringWriter();
+                    writer.Write("{ \"@warning\": \"Invalid FieldMask\", \"paths\": ");
+                    JsonFormatter.Default.WriteList(writer, (IList)paths);
+                    writer.Write(" }");
+                    return writer.ToString();
+                }
+                else
+                {
+                    throw new InvalidOperationException($"Invalid field mask to be converted to JSON: {firstInvalid}");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a string representation of this <see cref="FieldMask"/> for diagnostic purposes.
+        /// </summary>
+        /// <remarks>
+        /// Normally the returned value will be a JSON string value (including leading and trailing quotes) but
+        /// when the value is non-normalized or out of range, a JSON object representation will be returned
+        /// instead, including a warning. This is to avoid exceptions being thrown when trying to
+        /// diagnose problems - the regular JSON formatter will still throw an exception for non-normalized
+        /// values.
+        /// </remarks>
+        /// <returns>A string representation of this value.</returns>
+        public string ToDiagnosticString()
+        {
+            return ToJson(Paths, true);
+        }
+
+        /// <summary>
+        /// Parses from a string to a FieldMask.
+        /// </summary>
+        public static FieldMask FromString(string value)
+        {
+            return FromStringEnumerable<Empty>(new List<string>(value.Split(FIELD_PATH_SEPARATOR)));
+        }
+
+        /// <summary>
+        /// Parses from a string to a FieldMask and validates all field paths.
+        /// </summary>
+        /// <typeparam name="T">The type to validate the field paths against.</typeparam>
+        public static FieldMask FromString<T>(string value) where T : IMessage
+        {
+            return FromStringEnumerable<T>(new List<string>(value.Split(FIELD_PATH_SEPARATOR)));
+        }
+
+        /// <summary>
+        /// Constructs a FieldMask for a list of field paths in a certain type.
+        /// </summary>
+        /// <typeparam name="T">The type to validate the field paths against.</typeparam>
+        public static FieldMask FromStringEnumerable<T>(IEnumerable<string> paths) where T : IMessage
+        {
+            var mask = new FieldMask();
+            foreach (var path in paths)
+            {
+                if (path.Length == 0)
+                {
+                    // Ignore empty field paths.
+                    continue;
+                }
+
+                if (typeof(T) != typeof(Empty)
+                    && !IsValid<T>(path))
+                {
+                    throw new InvalidProtocolBufferException(path + " is not a valid path for " + typeof(T));
+                }
+
+                mask.Paths.Add(path);
+            }
+
+            return mask;
+        }
+
+        /// <summary>
+        /// Constructs a FieldMask from the passed field numbers.
+        /// </summary>
+        /// <typeparam name="T">The type to validate the field paths against.</typeparam>
+        public static FieldMask FromFieldNumbers<T>(params int[] fieldNumbers) where T : IMessage
+        {
+            return FromFieldNumbers<T>((IEnumerable<int>)fieldNumbers);
+        }
+
+        /// <summary>
+        /// Constructs a FieldMask from the passed field numbers.
+        /// </summary>
+        /// <typeparam name="T">The type to validate the field paths against.</typeparam>
+        public static FieldMask FromFieldNumbers<T>(IEnumerable<int> fieldNumbers) where T : IMessage
+        {
+            var descriptor = Activator.CreateInstance<T>().Descriptor;
+
+            var mask = new FieldMask();
+            foreach (var fieldNumber in fieldNumbers)
+            {
+                var field = descriptor.FindFieldByNumber(fieldNumber);
+                if (field == null)
+                {
+                    throw new ArgumentNullException($"{fieldNumber} is not a valid field number for {descriptor.Name}");
+                }
+
+                mask.Paths.Add(field.Name);
+            }
+
+            return mask;
+        }
+
+        /// <summary>
+        /// Checks whether the given path is valid for a field mask.
+        /// </summary>
+        /// <returns>true if the path is valid; false otherwise</returns>
+        private static bool IsPathValid(string input)
+        {
+            for (int i = 0; i < input.Length; i++)
+            {
+                char c = input[i];
+                if (c >= 'A' && c <= 'Z')
+                {
+                    return false;
+                }
+                if (c == '_' && i < input.Length - 1)
+                {
+                    char next = input[i + 1];
+                    if (next < 'a' || next > 'z')
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Checks whether paths in a given fields mask are valid.
+        /// </summary>
+        /// <typeparam name="T">The type to validate the field paths against.</typeparam>
+        public static bool IsValid<T>(FieldMask fieldMask) where T : IMessage
+        {
+            var descriptor = Activator.CreateInstance<T>().Descriptor;
+
+            return IsValid(descriptor, fieldMask);
+        }
+
+        /// <summary>
+        /// Checks whether paths in a given fields mask are valid.
+        /// </summary>
+        public static bool IsValid(MessageDescriptor descriptor, FieldMask fieldMask)
+        {
+            foreach (var path in fieldMask.Paths)
+            {
+                if (!IsValid(descriptor, path))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Checks whether a given field path is valid.
+        /// </summary>
+        /// <typeparam name="T">The type to validate the field paths against.</typeparam>
+        public static bool IsValid<T>(string path) where T : IMessage
+        {
+            var descriptor = Activator.CreateInstance<T>().Descriptor;
+
+            return IsValid(descriptor, path);
+        }
+
+        /// <summary>
+        /// Checks whether paths in a given fields mask are valid.
+        /// </summary>
+        public static bool IsValid(MessageDescriptor descriptor, string path)
+        {
+            var parts = path.Split(FIELD_SEPARATOR_REGEX);
+            if (parts.Length == 0)
+            {
+                return false;
+            }
+
+            foreach (var name in parts)
+            {
+                var field = descriptor?.FindFieldByName(name);
+                if (field == null)
+                {
+                    return false;
+                }
+
+                if (!field.IsRepeated
+                    && field.FieldType == FieldType.Message)
+                {
+                    descriptor = field.MessageType;
+                }
+                else
+                {
+                    descriptor = null;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Converts this FieldMask to its canonical form. In the canonical form of a
+        /// FieldMask, all field paths are sorted alphabetically and redundant field
+        /// paths are removed.
+        /// </summary>
+        public FieldMask Normalize()
+        {
+            return new FieldMaskTree(this).ToFieldMask();
+        }
+
+        /// <summary>
+        /// Creates a union of two or more FieldMasks.
+        /// </summary>
+        public FieldMask Union(params FieldMask[] otherMasks)
+        {
+            var maskTree = new FieldMaskTree(this);
+            foreach (var mask in otherMasks)
+            {
+                maskTree.MergeFromFieldMask(mask);
+            }
+
+            return maskTree.ToFieldMask();
+        }
+
+        /// <summary>
+        /// Calculates the intersection of two FieldMasks.
+        /// </summary>
+        public FieldMask Intersection(FieldMask additionalMask)
+        {
+            var tree = new FieldMaskTree(this);
+            var result = new FieldMaskTree();
+            foreach (var path in additionalMask.Paths)
+            {
+                tree.IntersectFieldPath(path, result);
+            }
+
+            return result.ToFieldMask();
+        }
+
+        /// <summary>
+        /// Merges fields specified by this FieldMask from one message to another with the
+        /// specified merge options.
+        /// </summary>
+        public void Merge(IMessage source, IMessage destination, MergeOptions options)
+        {
+            new FieldMaskTree(this).Merge(source, destination, options);
+        }
+
+        /// <summary>
+        /// Merges fields specified by this FieldMask from one message to another.
+        /// </summary>
+        public void Merge(IMessage source, IMessage destination)
+        {
+            Merge(source, destination, new MergeOptions());
+        }
+
+        /// <summary>
+        /// Options to customize merging behavior.
+        /// </summary>
+        public sealed class MergeOptions
+        {
+            /// <summary>
+            /// Whether to replace message fields(i.e., discard existing content in
+            /// destination message fields) when merging.
+            /// Default behavior is to merge the source message field into the
+            /// destination message field.
+            /// </summary>
+            public bool ReplaceMessageFields { get; set; } = false;
+
+            /// <summary>
+            /// Whether to replace repeated fields (i.e., discard existing content in
+            /// destination repeated fields) when merging.
+            /// Default behavior is to append elements from source repeated field to the
+            /// destination repeated field.
+            /// </summary>
+            public bool ReplaceRepeatedFields { get; set; } = false;
+
+            /// <summary>
+            /// Whether to replace primitive (non-repeated and non-message) fields in
+            /// destination message fields with the source primitive fields (i.e., if the
+            /// field is set in the source, the value is copied to the
+            /// destination; if the field is unset in the source, the field is cleared
+            /// from the destination) when merging.
+            ///
+            /// Default behavior is to always set the value of the source primitive
+            /// field to the destination primitive field, and if the source field is
+            /// unset, the default value of the source field is copied to the
+            /// destination.
+            /// </summary>
+            public bool ReplacePrimitiveFields { get; set; } = false;
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/WellKnownTypes/SourceContext.cs b/Libs/Google.Protobuf/WellKnownTypes/SourceContext.cs
new file mode 100644
index 0000000..48debca
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/SourceContext.cs
@@ -0,0 +1,227 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/source_context.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/source_context.proto</summary>
+  public static partial class SourceContextReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/source_context.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static SourceContextReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CiRnb29nbGUvcHJvdG9idWYvc291cmNlX2NvbnRleHQucHJvdG8SD2dvb2ds",
+            "ZS5wcm90b2J1ZiIiCg1Tb3VyY2VDb250ZXh0EhEKCWZpbGVfbmFtZRgBIAEo",
+            "CUKKAQoTY29tLmdvb2dsZS5wcm90b2J1ZkISU291cmNlQ29udGV4dFByb3Rv",
+            "UAFaNmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3Nv",
+            "dXJjZWNvbnRleHRwYqICA0dQQqoCHkdvb2dsZS5Qcm90b2J1Zi5XZWxsS25v",
+            "d25UeXBlc2IGcHJvdG8z"));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.SourceContext), global::LC.Google.Protobuf.WellKnownTypes.SourceContext.Parser, new[]{ "FileName" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// `SourceContext` represents information about the source of a
+  /// protobuf element, like the file in which it is defined.
+  /// </summary>
+  public sealed partial class SourceContext : pb::IMessage<SourceContext>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<SourceContext> _parser = new pb::MessageParser<SourceContext>(() => new SourceContext());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<SourceContext> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.SourceContextReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public SourceContext() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public SourceContext(SourceContext other) : this() {
+      fileName_ = other.fileName_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public SourceContext Clone() {
+      return new SourceContext(this);
+    }
+
+    /// <summary>Field number for the "file_name" field.</summary>
+    public const int FileNameFieldNumber = 1;
+    private string fileName_ = "";
+    /// <summary>
+    /// The path-qualified name of the .proto file that contained the associated
+    /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string FileName {
+      get { return fileName_; }
+      set {
+        fileName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as SourceContext);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(SourceContext other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (FileName != other.FileName) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (FileName.Length != 0) hash ^= FileName.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (FileName.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(FileName);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (FileName.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(FileName);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (FileName.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(FileName);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(SourceContext other) {
+      if (other == null) {
+        return;
+      }
+      if (other.FileName.Length != 0) {
+        FileName = other.FileName;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            FileName = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            FileName = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Struct.cs b/Libs/Google.Protobuf/WellKnownTypes/Struct.cs
new file mode 100644
index 0000000..c4e09c2
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Struct.cs
@@ -0,0 +1,866 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/struct.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/struct.proto</summary>
+  public static partial class StructReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/struct.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static StructReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Chxnb29nbGUvcHJvdG9idWYvc3RydWN0LnByb3RvEg9nb29nbGUucHJvdG9i",
+            "dWYihAEKBlN0cnVjdBIzCgZmaWVsZHMYASADKAsyIy5nb29nbGUucHJvdG9i",
+            "dWYuU3RydWN0LkZpZWxkc0VudHJ5GkUKC0ZpZWxkc0VudHJ5EgsKA2tleRgB",
+            "IAEoCRIlCgV2YWx1ZRgCIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZToC",
+            "OAEi6gEKBVZhbHVlEjAKCm51bGxfdmFsdWUYASABKA4yGi5nb29nbGUucHJv",
+            "dG9idWYuTnVsbFZhbHVlSAASFgoMbnVtYmVyX3ZhbHVlGAIgASgBSAASFgoM",
+            "c3RyaW5nX3ZhbHVlGAMgASgJSAASFAoKYm9vbF92YWx1ZRgEIAEoCEgAEi8K",
+            "DHN0cnVjdF92YWx1ZRgFIAEoCzIXLmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RI",
+            "ABIwCgpsaXN0X3ZhbHVlGAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLkxpc3RW",
+            "YWx1ZUgAQgYKBGtpbmQiMwoJTGlzdFZhbHVlEiYKBnZhbHVlcxgBIAMoCzIW",
+            "Lmdvb2dsZS5wcm90b2J1Zi5WYWx1ZSobCglOdWxsVmFsdWUSDgoKTlVMTF9W",
+            "QUxVRRAAQn8KE2NvbS5nb29nbGUucHJvdG9idWZCC1N0cnVjdFByb3RvUAFa",
+            "L2dvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3N0cnVj",
+            "dHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVz",
+            "YgZwcm90bzM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LC.Google.Protobuf.WellKnownTypes.NullValue), }, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Struct), global::LC.Google.Protobuf.WellKnownTypes.Struct.Parser, new[]{ "Fields" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Value), global::LC.Google.Protobuf.WellKnownTypes.Value.Parser, new[]{ "NullValue", "NumberValue", "StringValue", "BoolValue", "StructValue", "ListValue" }, new[]{ "Kind" }, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.ListValue), global::LC.Google.Protobuf.WellKnownTypes.ListValue.Parser, new[]{ "Values" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Enums
+  /// <summary>
+  /// `NullValue` is a singleton enumeration to represent the null value for the
+  /// `Value` type union.
+  ///
+  ///  The JSON representation for `NullValue` is JSON `null`.
+  /// </summary>
+  public enum NullValue {
+    /// <summary>
+    /// Null value.
+    /// </summary>
+    [pbr::OriginalName("NULL_VALUE")] NullValue = 0,
+  }
+
+  #endregion
+
+  #region Messages
+  /// <summary>
+  /// `Struct` represents a structured data value, consisting of fields
+  /// which map to dynamically typed values. In some languages, `Struct`
+  /// might be supported by a native representation. For example, in
+  /// scripting languages like JS a struct is represented as an
+  /// object. The details of that representation are described together
+  /// with the proto support for the language.
+  ///
+  /// The JSON representation for `Struct` is JSON object.
+  /// </summary>
+  public sealed partial class Struct : pb::IMessage<Struct>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Struct> _parser = new pb::MessageParser<Struct>(() => new Struct());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Struct> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.StructReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Struct() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Struct(Struct other) : this() {
+      fields_ = other.fields_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Struct Clone() {
+      return new Struct(this);
+    }
+
+    /// <summary>Field number for the "fields" field.</summary>
+    public const int FieldsFieldNumber = 1;
+    private static readonly pbc::MapField<string, global::LC.Google.Protobuf.WellKnownTypes.Value>.Codec _map_fields_codec
+        = new pbc::MapField<string, global::LC.Google.Protobuf.WellKnownTypes.Value>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.WellKnownTypes.Value.Parser), 10);
+    private readonly pbc::MapField<string, global::LC.Google.Protobuf.WellKnownTypes.Value> fields_ = new pbc::MapField<string, global::LC.Google.Protobuf.WellKnownTypes.Value>();
+    /// <summary>
+    /// Unordered map of dynamically typed values.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::MapField<string, global::LC.Google.Protobuf.WellKnownTypes.Value> Fields {
+      get { return fields_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Struct);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Struct other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (!Fields.Equals(other.Fields)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= Fields.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      fields_.WriteTo(output, _map_fields_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      fields_.WriteTo(ref output, _map_fields_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += fields_.CalculateSize(_map_fields_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Struct other) {
+      if (other == null) {
+        return;
+      }
+      fields_.Add(other.fields_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            fields_.AddEntriesFrom(input, _map_fields_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            fields_.AddEntriesFrom(ref input, _map_fields_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// `Value` represents a dynamically typed value which can be either
+  /// null, a number, a string, a boolean, a recursive struct value, or a
+  /// list of values. A producer of value is expected to set one of that
+  /// variants, absence of any variant indicates an error.
+  ///
+  /// The JSON representation for `Value` is JSON value.
+  /// </summary>
+  public sealed partial class Value : pb::IMessage<Value>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Value> _parser = new pb::MessageParser<Value>(() => new Value());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Value> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.StructReflection.Descriptor.MessageTypes[1]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Value() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Value(Value other) : this() {
+      switch (other.KindCase) {
+        case KindOneofCase.NullValue:
+          NullValue = other.NullValue;
+          break;
+        case KindOneofCase.NumberValue:
+          NumberValue = other.NumberValue;
+          break;
+        case KindOneofCase.StringValue:
+          StringValue = other.StringValue;
+          break;
+        case KindOneofCase.BoolValue:
+          BoolValue = other.BoolValue;
+          break;
+        case KindOneofCase.StructValue:
+          StructValue = other.StructValue.Clone();
+          break;
+        case KindOneofCase.ListValue:
+          ListValue = other.ListValue.Clone();
+          break;
+      }
+
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Value Clone() {
+      return new Value(this);
+    }
+
+    /// <summary>Field number for the "null_value" field.</summary>
+    public const int NullValueFieldNumber = 1;
+    /// <summary>
+    /// Represents a null value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.NullValue NullValue {
+      get { return kindCase_ == KindOneofCase.NullValue ? (global::LC.Google.Protobuf.WellKnownTypes.NullValue) kind_ : global::LC.Google.Protobuf.WellKnownTypes.NullValue.NullValue; }
+      set {
+        kind_ = value;
+        kindCase_ = KindOneofCase.NullValue;
+      }
+    }
+
+    /// <summary>Field number for the "number_value" field.</summary>
+    public const int NumberValueFieldNumber = 2;
+    /// <summary>
+    /// Represents a double value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public double NumberValue {
+      get { return kindCase_ == KindOneofCase.NumberValue ? (double) kind_ : 0D; }
+      set {
+        kind_ = value;
+        kindCase_ = KindOneofCase.NumberValue;
+      }
+    }
+
+    /// <summary>Field number for the "string_value" field.</summary>
+    public const int StringValueFieldNumber = 3;
+    /// <summary>
+    /// Represents a string value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string StringValue {
+      get { return kindCase_ == KindOneofCase.StringValue ? (string) kind_ : ""; }
+      set {
+        kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+        kindCase_ = KindOneofCase.StringValue;
+      }
+    }
+
+    /// <summary>Field number for the "bool_value" field.</summary>
+    public const int BoolValueFieldNumber = 4;
+    /// <summary>
+    /// Represents a boolean value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool BoolValue {
+      get { return kindCase_ == KindOneofCase.BoolValue ? (bool) kind_ : false; }
+      set {
+        kind_ = value;
+        kindCase_ = KindOneofCase.BoolValue;
+      }
+    }
+
+    /// <summary>Field number for the "struct_value" field.</summary>
+    public const int StructValueFieldNumber = 5;
+    /// <summary>
+    /// Represents a structured value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Struct StructValue {
+      get { return kindCase_ == KindOneofCase.StructValue ? (global::LC.Google.Protobuf.WellKnownTypes.Struct) kind_ : null; }
+      set {
+        kind_ = value;
+        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.StructValue;
+      }
+    }
+
+    /// <summary>Field number for the "list_value" field.</summary>
+    public const int ListValueFieldNumber = 6;
+    /// <summary>
+    /// Represents a repeated `Value`.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.ListValue ListValue {
+      get { return kindCase_ == KindOneofCase.ListValue ? (global::LC.Google.Protobuf.WellKnownTypes.ListValue) kind_ : null; }
+      set {
+        kind_ = value;
+        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.ListValue;
+      }
+    }
+
+    private object kind_;
+    /// <summary>Enum of possible cases for the "kind" oneof.</summary>
+    public enum KindOneofCase {
+      None = 0,
+      NullValue = 1,
+      NumberValue = 2,
+      StringValue = 3,
+      BoolValue = 4,
+      StructValue = 5,
+      ListValue = 6,
+    }
+    private KindOneofCase kindCase_ = KindOneofCase.None;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public KindOneofCase KindCase {
+      get { return kindCase_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void ClearKind() {
+      kindCase_ = KindOneofCase.None;
+      kind_ = null;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Value);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Value other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (NullValue != other.NullValue) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(NumberValue, other.NumberValue)) return false;
+      if (StringValue != other.StringValue) return false;
+      if (BoolValue != other.BoolValue) return false;
+      if (!object.Equals(StructValue, other.StructValue)) return false;
+      if (!object.Equals(ListValue, other.ListValue)) return false;
+      if (KindCase != other.KindCase) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (kindCase_ == KindOneofCase.NullValue) hash ^= NullValue.GetHashCode();
+      if (kindCase_ == KindOneofCase.NumberValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(NumberValue);
+      if (kindCase_ == KindOneofCase.StringValue) hash ^= StringValue.GetHashCode();
+      if (kindCase_ == KindOneofCase.BoolValue) hash ^= BoolValue.GetHashCode();
+      if (kindCase_ == KindOneofCase.StructValue) hash ^= StructValue.GetHashCode();
+      if (kindCase_ == KindOneofCase.ListValue) hash ^= ListValue.GetHashCode();
+      hash ^= (int) kindCase_;
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (kindCase_ == KindOneofCase.NullValue) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) NullValue);
+      }
+      if (kindCase_ == KindOneofCase.NumberValue) {
+        output.WriteRawTag(17);
+        output.WriteDouble(NumberValue);
+      }
+      if (kindCase_ == KindOneofCase.StringValue) {
+        output.WriteRawTag(26);
+        output.WriteString(StringValue);
+      }
+      if (kindCase_ == KindOneofCase.BoolValue) {
+        output.WriteRawTag(32);
+        output.WriteBool(BoolValue);
+      }
+      if (kindCase_ == KindOneofCase.StructValue) {
+        output.WriteRawTag(42);
+        output.WriteMessage(StructValue);
+      }
+      if (kindCase_ == KindOneofCase.ListValue) {
+        output.WriteRawTag(50);
+        output.WriteMessage(ListValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (kindCase_ == KindOneofCase.NullValue) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) NullValue);
+      }
+      if (kindCase_ == KindOneofCase.NumberValue) {
+        output.WriteRawTag(17);
+        output.WriteDouble(NumberValue);
+      }
+      if (kindCase_ == KindOneofCase.StringValue) {
+        output.WriteRawTag(26);
+        output.WriteString(StringValue);
+      }
+      if (kindCase_ == KindOneofCase.BoolValue) {
+        output.WriteRawTag(32);
+        output.WriteBool(BoolValue);
+      }
+      if (kindCase_ == KindOneofCase.StructValue) {
+        output.WriteRawTag(42);
+        output.WriteMessage(StructValue);
+      }
+      if (kindCase_ == KindOneofCase.ListValue) {
+        output.WriteRawTag(50);
+        output.WriteMessage(ListValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (kindCase_ == KindOneofCase.NullValue) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) NullValue);
+      }
+      if (kindCase_ == KindOneofCase.NumberValue) {
+        size += 1 + 8;
+      }
+      if (kindCase_ == KindOneofCase.StringValue) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(StringValue);
+      }
+      if (kindCase_ == KindOneofCase.BoolValue) {
+        size += 1 + 1;
+      }
+      if (kindCase_ == KindOneofCase.StructValue) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(StructValue);
+      }
+      if (kindCase_ == KindOneofCase.ListValue) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(ListValue);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Value other) {
+      if (other == null) {
+        return;
+      }
+      switch (other.KindCase) {
+        case KindOneofCase.NullValue:
+          NullValue = other.NullValue;
+          break;
+        case KindOneofCase.NumberValue:
+          NumberValue = other.NumberValue;
+          break;
+        case KindOneofCase.StringValue:
+          StringValue = other.StringValue;
+          break;
+        case KindOneofCase.BoolValue:
+          BoolValue = other.BoolValue;
+          break;
+        case KindOneofCase.StructValue:
+          if (StructValue == null) {
+            StructValue = new global::LC.Google.Protobuf.WellKnownTypes.Struct();
+          }
+          StructValue.MergeFrom(other.StructValue);
+          break;
+        case KindOneofCase.ListValue:
+          if (ListValue == null) {
+            ListValue = new global::LC.Google.Protobuf.WellKnownTypes.ListValue();
+          }
+          ListValue.MergeFrom(other.ListValue);
+          break;
+      }
+
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            kind_ = input.ReadEnum();
+            kindCase_ = KindOneofCase.NullValue;
+            break;
+          }
+          case 17: {
+            NumberValue = input.ReadDouble();
+            break;
+          }
+          case 26: {
+            StringValue = input.ReadString();
+            break;
+          }
+          case 32: {
+            BoolValue = input.ReadBool();
+            break;
+          }
+          case 42: {
+            global::LC.Google.Protobuf.WellKnownTypes.Struct subBuilder = new global::LC.Google.Protobuf.WellKnownTypes.Struct();
+            if (kindCase_ == KindOneofCase.StructValue) {
+              subBuilder.MergeFrom(StructValue);
+            }
+            input.ReadMessage(subBuilder);
+            StructValue = subBuilder;
+            break;
+          }
+          case 50: {
+            global::LC.Google.Protobuf.WellKnownTypes.ListValue subBuilder = new global::LC.Google.Protobuf.WellKnownTypes.ListValue();
+            if (kindCase_ == KindOneofCase.ListValue) {
+              subBuilder.MergeFrom(ListValue);
+            }
+            input.ReadMessage(subBuilder);
+            ListValue = subBuilder;
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            kind_ = input.ReadEnum();
+            kindCase_ = KindOneofCase.NullValue;
+            break;
+          }
+          case 17: {
+            NumberValue = input.ReadDouble();
+            break;
+          }
+          case 26: {
+            StringValue = input.ReadString();
+            break;
+          }
+          case 32: {
+            BoolValue = input.ReadBool();
+            break;
+          }
+          case 42: {
+            global::LC.Google.Protobuf.WellKnownTypes.Struct subBuilder = new global::LC.Google.Protobuf.WellKnownTypes.Struct();
+            if (kindCase_ == KindOneofCase.StructValue) {
+              subBuilder.MergeFrom(StructValue);
+            }
+            input.ReadMessage(subBuilder);
+            StructValue = subBuilder;
+            break;
+          }
+          case 50: {
+            global::LC.Google.Protobuf.WellKnownTypes.ListValue subBuilder = new global::LC.Google.Protobuf.WellKnownTypes.ListValue();
+            if (kindCase_ == KindOneofCase.ListValue) {
+              subBuilder.MergeFrom(ListValue);
+            }
+            input.ReadMessage(subBuilder);
+            ListValue = subBuilder;
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// `ListValue` is a wrapper around a repeated field of values.
+  ///
+  /// The JSON representation for `ListValue` is JSON array.
+  /// </summary>
+  public sealed partial class ListValue : pb::IMessage<ListValue>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<ListValue> _parser = new pb::MessageParser<ListValue>(() => new ListValue());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<ListValue> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.StructReflection.Descriptor.MessageTypes[2]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ListValue() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ListValue(ListValue other) : this() {
+      values_ = other.values_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ListValue Clone() {
+      return new ListValue(this);
+    }
+
+    /// <summary>Field number for the "values" field.</summary>
+    public const int ValuesFieldNumber = 1;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Value> _repeated_values_codec
+        = pb::FieldCodec.ForMessage(10, global::LC.Google.Protobuf.WellKnownTypes.Value.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Value> values_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Value>();
+    /// <summary>
+    /// Repeated field of dynamically typed values.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Value> Values {
+      get { return values_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as ListValue);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(ListValue other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if(!values_.Equals(other.values_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      hash ^= values_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      values_.WriteTo(output, _repeated_values_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      values_.WriteTo(ref output, _repeated_values_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      size += values_.CalculateSize(_repeated_values_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(ListValue other) {
+      if (other == null) {
+        return;
+      }
+      values_.Add(other.values_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            values_.AddEntriesFrom(input, _repeated_values_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            values_.AddEntriesFrom(ref input, _repeated_values_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/TimeExtensions.cs b/Libs/Google.Protobuf/WellKnownTypes/TimeExtensions.cs
new file mode 100644
index 0000000..2111dcf
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/TimeExtensions.cs
@@ -0,0 +1,76 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+namespace LC.Google.Protobuf.WellKnownTypes
+{
+    /// <summary>
+    /// Extension methods on BCL time-related types, converting to protobuf types.
+    /// </summary>
+    public static class TimeExtensions
+    {
+        /// <summary>
+        /// Converts the given <see cref="DateTime"/> to a <see cref="Timestamp"/>.
+        /// </summary>
+        /// <param name="dateTime">The date and time to convert to a timestamp.</param>
+        /// <exception cref="ArgumentException">The <paramref name="dateTime"/> value has a <see cref="DateTime.Kind"/>other than <c>Utc</c>.</exception>
+        /// <returns>The converted timestamp.</returns>
+        public static Timestamp ToTimestamp(this DateTime dateTime)
+        {
+            return Timestamp.FromDateTime(dateTime);
+        }
+
+        /// <summary>
+        /// Converts the given <see cref="DateTimeOffset"/> to a <see cref="Timestamp"/>
+        /// </summary>
+        /// <remarks>The offset is taken into consideration when converting the value (so the same instant in time
+        /// is represented) but is not a separate part of the resulting value. In other words, there is no
+        /// roundtrip operation to retrieve the original <c>DateTimeOffset</c>.</remarks>
+        /// <param name="dateTimeOffset">The date and time (with UTC offset) to convert to a timestamp.</param>
+        /// <returns>The converted timestamp.</returns>
+        public static Timestamp ToTimestamp(this DateTimeOffset dateTimeOffset)
+        {
+            return Timestamp.FromDateTimeOffset(dateTimeOffset);
+        }
+
+        /// <summary>
+        /// Converts the given <see cref="TimeSpan"/> to a <see cref="Duration"/>.
+        /// </summary>
+        /// <param name="timeSpan">The time span to convert.</param>
+        /// <returns>The converted duration.</returns>
+        public static Duration ToDuration(this TimeSpan timeSpan)
+        {
+            return Duration.FromTimeSpan(timeSpan);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Timestamp.cs b/Libs/Google.Protobuf/WellKnownTypes/Timestamp.cs
new file mode 100644
index 0000000..f2974ea
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Timestamp.cs
@@ -0,0 +1,357 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/timestamp.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/timestamp.proto</summary>
+  public static partial class TimestampReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/timestamp.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static TimestampReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Ch9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnByb3RvEg9nb29nbGUucHJv",
+            "dG9idWYiKwoJVGltZXN0YW1wEg8KB3NlY29uZHMYASABKAMSDQoFbmFub3MY",
+            "AiABKAVChQEKE2NvbS5nb29nbGUucHJvdG9idWZCDlRpbWVzdGFtcFByb3Rv",
+            "UAFaMmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3Rp",
+            "bWVzdGFtcHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93",
+            "blR5cGVzYgZwcm90bzM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Timestamp), global::LC.Google.Protobuf.WellKnownTypes.Timestamp.Parser, new[]{ "Seconds", "Nanos" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// A Timestamp represents a point in time independent of any time zone or local
+  /// calendar, encoded as a count of seconds and fractions of seconds at
+  /// nanosecond resolution. The count is relative to an epoch at UTC midnight on
+  /// January 1, 1970, in the proleptic Gregorian calendar which extends the
+  /// Gregorian calendar backwards to year one.
+  ///
+  /// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+  /// second table is needed for interpretation, using a [24-hour linear
+  /// smear](https://developers.google.com/time/smear).
+  ///
+  /// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+  /// restricting to that range, we ensure that we can convert to and from [RFC
+  /// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+  ///
+  /// # Examples
+  ///
+  /// Example 1: Compute Timestamp from POSIX `time()`.
+  ///
+  ///     Timestamp timestamp;
+  ///     timestamp.set_seconds(time(NULL));
+  ///     timestamp.set_nanos(0);
+  ///
+  /// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+  ///
+  ///     struct timeval tv;
+  ///     gettimeofday(&amp;tv, NULL);
+  ///
+  ///     Timestamp timestamp;
+  ///     timestamp.set_seconds(tv.tv_sec);
+  ///     timestamp.set_nanos(tv.tv_usec * 1000);
+  ///
+  /// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+  ///
+  ///     FILETIME ft;
+  ///     GetSystemTimeAsFileTime(&amp;ft);
+  ///     UINT64 ticks = (((UINT64)ft.dwHighDateTime) &lt;&lt; 32) | ft.dwLowDateTime;
+  ///
+  ///     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+  ///     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+  ///     Timestamp timestamp;
+  ///     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+  ///     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+  ///
+  /// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+  ///
+  ///     long millis = System.currentTimeMillis();
+  ///
+  ///     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+  ///         .setNanos((int) ((millis % 1000) * 1000000)).build();
+  ///
+  /// Example 5: Compute Timestamp from Java `Instant.now()`.
+  ///
+  ///     Instant now = Instant.now();
+  ///
+  ///     Timestamp timestamp =
+  ///         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+  ///             .setNanos(now.getNano()).build();
+  ///
+  /// Example 6: Compute Timestamp from current time in Python.
+  ///
+  ///     timestamp = Timestamp()
+  ///     timestamp.GetCurrentTime()
+  ///
+  /// # JSON Mapping
+  ///
+  /// In JSON format, the Timestamp type is encoded as a string in the
+  /// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+  /// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+  /// where {year} is always expressed using four digits while {month}, {day},
+  /// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+  /// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+  /// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+  /// is required. A proto3 JSON serializer should always use UTC (as indicated by
+  /// "Z") when printing the Timestamp type and a proto3 JSON parser should be
+  /// able to accept both UTC and other timezones (as indicated by an offset).
+  ///
+  /// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+  /// 01:30 UTC on January 15, 2017.
+  ///
+  /// In JavaScript, one can convert a Date object to this format using the
+  /// standard
+  /// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+  /// method. In Python, a standard `datetime.datetime` object can be converted
+  /// to this format using
+  /// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+  /// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+  /// the Joda Time's [`ISODateTimeFormat.dateTime()`](
+  /// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+  /// ) to obtain a formatter capable of generating timestamps in this format.
+  /// </summary>
+  public sealed partial class Timestamp : pb::IMessage<Timestamp>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Timestamp> _parser = new pb::MessageParser<Timestamp>(() => new Timestamp());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Timestamp> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Timestamp() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Timestamp(Timestamp other) : this() {
+      seconds_ = other.seconds_;
+      nanos_ = other.nanos_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Timestamp Clone() {
+      return new Timestamp(this);
+    }
+
+    /// <summary>Field number for the "seconds" field.</summary>
+    public const int SecondsFieldNumber = 1;
+    private long seconds_;
+    /// <summary>
+    /// Represents seconds of UTC time since Unix epoch
+    /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+    /// 9999-12-31T23:59:59Z inclusive.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public long Seconds {
+      get { return seconds_; }
+      set {
+        seconds_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "nanos" field.</summary>
+    public const int NanosFieldNumber = 2;
+    private int nanos_;
+    /// <summary>
+    /// Non-negative fractions of a second at nanosecond resolution. Negative
+    /// second values with fractions must still have non-negative nanos values
+    /// that count forward in time. Must be from 0 to 999,999,999
+    /// inclusive.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int Nanos {
+      get { return nanos_; }
+      set {
+        nanos_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Timestamp);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Timestamp other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Seconds != other.Seconds) return false;
+      if (Nanos != other.Nanos) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Seconds != 0L) hash ^= Seconds.GetHashCode();
+      if (Nanos != 0) hash ^= Nanos.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Seconds != 0L) {
+        output.WriteRawTag(8);
+        output.WriteInt64(Seconds);
+      }
+      if (Nanos != 0) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Nanos);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Seconds != 0L) {
+        output.WriteRawTag(8);
+        output.WriteInt64(Seconds);
+      }
+      if (Nanos != 0) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Nanos);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Seconds != 0L) {
+        size += 1 + pb::CodedOutputStream.ComputeInt64Size(Seconds);
+      }
+      if (Nanos != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Nanos);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Timestamp other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Seconds != 0L) {
+        Seconds = other.Seconds;
+      }
+      if (other.Nanos != 0) {
+        Nanos = other.Nanos;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Seconds = input.ReadInt64();
+            break;
+          }
+          case 16: {
+            Nanos = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Seconds = input.ReadInt64();
+            break;
+          }
+          case 16: {
+            Nanos = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/TimestampPartial.cs b/Libs/Google.Protobuf/WellKnownTypes/TimestampPartial.cs
new file mode 100644
index 0000000..0bca44c
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/TimestampPartial.cs
@@ -0,0 +1,344 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace LC.Google.Protobuf.WellKnownTypes
+{
+    public partial class Timestamp : ICustomDiagnosticMessage, IComparable<Timestamp>
+    {
+        private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        // Constants determined programmatically, but then hard-coded so they can be constant expressions.
+        private const long BclSecondsAtUnixEpoch = 62135596800;
+        internal const long UnixSecondsAtBclMaxValue = 253402300799;
+        internal const long UnixSecondsAtBclMinValue = -BclSecondsAtUnixEpoch;
+        internal const int MaxNanos = Duration.NanosecondsPerSecond - 1;
+
+        private static bool IsNormalized(long seconds, int nanoseconds) =>
+            nanoseconds >= 0 &&
+            nanoseconds <= MaxNanos &&
+            seconds >= UnixSecondsAtBclMinValue &&
+            seconds <= UnixSecondsAtBclMaxValue;
+
+        /// <summary>
+        /// Returns the difference between one <see cref="Timestamp"/> and another, as a <see cref="Duration"/>.
+        /// </summary>
+        /// <param name="lhs">The timestamp to subtract from. Must not be null.</param>
+        /// <param name="rhs">The timestamp to subtract. Must not be null.</param>
+        /// <returns>The difference between the two specified timestamps.</returns>
+        public static Duration operator -(Timestamp lhs, Timestamp rhs)
+        {
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
+            checked
+            {
+                return Duration.Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos);
+            }
+        }
+
+        /// <summary>
+        /// Adds a <see cref="Duration"/> to a <see cref="Timestamp"/>, to obtain another <c>Timestamp</c>.
+        /// </summary>
+        /// <param name="lhs">The timestamp to add the duration to. Must not be null.</param>
+        /// <param name="rhs">The duration to add. Must not be null.</param>
+        /// <returns>The result of adding the duration to the timestamp.</returns>
+        public static Timestamp operator +(Timestamp lhs, Duration rhs)
+        {
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
+            checked
+            {
+                return Normalize(lhs.Seconds + rhs.Seconds, lhs.Nanos + rhs.Nanos);
+            }
+        }
+
+        /// <summary>
+        /// Subtracts a <see cref="Duration"/> from a <see cref="Timestamp"/>, to obtain another <c>Timestamp</c>.
+        /// </summary>
+        /// <param name="lhs">The timestamp to subtract the duration from. Must not be null.</param>
+        /// <param name="rhs">The duration to subtract.</param>
+        /// <returns>The result of subtracting the duration from the timestamp.</returns>
+        public static Timestamp operator -(Timestamp lhs, Duration rhs)
+        {
+            ProtoPreconditions.CheckNotNull(lhs, "lhs");
+            ProtoPreconditions.CheckNotNull(rhs, "rhs");
+            checked
+            {
+                return Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos);
+            }
+        }
+
+        /// <summary>
+        /// Converts this timestamp into a <see cref="DateTime"/>.
+        /// </summary>
+        /// <remarks>
+        /// The resulting <c>DateTime</c> will always have a <c>Kind</c> of <c>Utc</c>.
+        /// If the timestamp is not a precise number of ticks, it will be truncated towards the start
+        /// of time. For example, a timestamp with a <see cref="Nanos"/> value of 99 will result in a
+        /// <see cref="DateTime"/> value precisely on a second.
+        /// </remarks>
+        /// <returns>This timestamp as a <c>DateTime</c>.</returns>
+        /// <exception cref="InvalidOperationException">The timestamp contains invalid values; either it is
+        /// incorrectly normalized or is outside the valid range.</exception>
+        public DateTime ToDateTime()
+        {
+            if (!IsNormalized(Seconds, Nanos))
+            {
+                throw new InvalidOperationException(@"Timestamp contains invalid values: Seconds={Seconds}; Nanos={Nanos}");
+            }
+            return UnixEpoch.AddSeconds(Seconds).AddTicks(Nanos / Duration.NanosecondsPerTick);
+        }
+
+        /// <summary>
+        /// Converts this timestamp into a <see cref="DateTimeOffset"/>.
+        /// </summary>
+        /// <remarks>
+        /// The resulting <c>DateTimeOffset</c> will always have an <c>Offset</c> of zero.
+        /// If the timestamp is not a precise number of ticks, it will be truncated towards the start
+        /// of time. For example, a timestamp with a <see cref="Nanos"/> value of 99 will result in a
+        /// <see cref="DateTimeOffset"/> value precisely on a second.
+        /// </remarks>
+        /// <returns>This timestamp as a <c>DateTimeOffset</c>.</returns>
+        /// <exception cref="InvalidOperationException">The timestamp contains invalid values; either it is
+        /// incorrectly normalized or is outside the valid range.</exception>
+        public DateTimeOffset ToDateTimeOffset()
+        {
+            return new DateTimeOffset(ToDateTime(), TimeSpan.Zero);
+        }
+
+        /// <summary>
+        /// Converts the specified <see cref="DateTime"/> to a <see cref="Timestamp"/>.
+        /// </summary>
+        /// <param name="dateTime"></param>
+        /// <exception cref="ArgumentException">The <c>Kind</c> of <paramref name="dateTime"/> is not <c>DateTimeKind.Utc</c>.</exception>
+        /// <returns>The converted timestamp.</returns>
+        public static Timestamp FromDateTime(DateTime dateTime)
+        {
+            if (dateTime.Kind != DateTimeKind.Utc)
+            {
+                throw new ArgumentException("Conversion from DateTime to Timestamp requires the DateTime kind to be Utc", "dateTime");
+            }
+            // Do the arithmetic using DateTime.Ticks, which is always non-negative, making things simpler.
+            long secondsSinceBclEpoch = dateTime.Ticks / TimeSpan.TicksPerSecond;
+            int nanoseconds = (int)  (dateTime.Ticks % TimeSpan.TicksPerSecond) * Duration.NanosecondsPerTick;
+            return new Timestamp { Seconds = secondsSinceBclEpoch - BclSecondsAtUnixEpoch, Nanos = nanoseconds };
+        }
+
+        /// <summary>
+        /// Converts the given <see cref="DateTimeOffset"/> to a <see cref="Timestamp"/>
+        /// </summary>
+        /// <remarks>The offset is taken into consideration when converting the value (so the same instant in time
+        /// is represented) but is not a separate part of the resulting value. In other words, there is no
+        /// roundtrip operation to retrieve the original <c>DateTimeOffset</c>.</remarks>
+        /// <param name="dateTimeOffset">The date and time (with UTC offset) to convert to a timestamp.</param>
+        /// <returns>The converted timestamp.</returns>
+        public static Timestamp FromDateTimeOffset(DateTimeOffset dateTimeOffset)
+        {
+            // We don't need to worry about this having negative ticks: DateTimeOffset is constrained to handle
+            // values whose *UTC* value is in the range of DateTime.
+            return FromDateTime(dateTimeOffset.UtcDateTime);
+        }
+
+        internal static Timestamp Normalize(long seconds, int nanoseconds)
+        {
+            int extraSeconds = nanoseconds / Duration.NanosecondsPerSecond;
+            seconds += extraSeconds;
+            nanoseconds -= extraSeconds * Duration.NanosecondsPerSecond;
+
+            if (nanoseconds < 0)
+            {
+                nanoseconds += Duration.NanosecondsPerSecond;
+                seconds--;
+            }
+            return new Timestamp { Seconds = seconds, Nanos = nanoseconds };
+        }
+
+        /// <summary>
+        /// Converts a timestamp specified in seconds/nanoseconds to a string.
+        /// </summary>
+        /// <remarks>
+        /// If the value is a normalized duration in the range described in <c>timestamp.proto</c>,
+        /// <paramref name="diagnosticOnly"/> is ignored. Otherwise, if the parameter is <c>true</c>,
+        /// a JSON object with a warning is returned; if it is <c>false</c>, an <see cref="InvalidOperationException"/> is thrown.
+        /// </remarks>
+        /// <param name="seconds">Seconds portion of the duration.</param>
+        /// <param name="nanoseconds">Nanoseconds portion of the duration.</param>
+        /// <param name="diagnosticOnly">Determines the handling of non-normalized values</param>
+        /// <exception cref="InvalidOperationException">The represented duration is invalid, and <paramref name="diagnosticOnly"/> is <c>false</c>.</exception>
+        internal static string ToJson(long seconds, int nanoseconds, bool diagnosticOnly)
+        {
+            if (IsNormalized(seconds, nanoseconds))
+            {
+                // Use .NET's formatting for the value down to the second, including an opening double quote (as it's a string value)
+                DateTime dateTime = UnixEpoch.AddSeconds(seconds);
+                var builder = new StringBuilder();
+                builder.Append('"');
+                builder.Append(dateTime.ToString("yyyy'-'MM'-'dd'T'HH:mm:ss", CultureInfo.InvariantCulture));
+                Duration.AppendNanoseconds(builder, nanoseconds);
+                builder.Append("Z\"");
+                return builder.ToString();
+            }
+            if (diagnosticOnly)
+            {
+                return string.Format(CultureInfo.InvariantCulture,
+                    "{{ \"@warning\": \"Invalid Timestamp\", \"seconds\": \"{0}\", \"nanos\": {1} }}",
+                    seconds,
+                    nanoseconds);
+            }
+            else
+            {
+                throw new InvalidOperationException("Non-normalized timestamp value");
+            }
+        }
+
+        /// <summary>
+        /// Given another timestamp, returns 0 if the timestamps are equivalent, -1 if this timestamp precedes the other, and 1 otherwise
+        /// </summary>
+        /// <remarks>
+        /// Make sure the timestamps are normalized. Comparing non-normalized timestamps is not specified and may give unexpected results.
+        /// </remarks>
+        /// <param name="other">Timestamp to compare</param>
+        /// <returns>an integer indicating whether this timestamp precedes or follows the other</returns>
+        public int CompareTo(Timestamp other)
+        {
+            return other == null ? 1
+                : Seconds < other.Seconds ? -1
+                : Seconds > other.Seconds ? 1
+                : Nanos < other.Nanos ? -1
+                : Nanos > other.Nanos ? 1
+                : 0;
+        }
+
+        /// <summary>
+        /// Compares two timestamps and returns whether the first is less than (chronologically precedes) the second
+        /// </summary>
+        /// <remarks>
+        /// Make sure the timestamps are normalized. Comparing non-normalized timestamps is not specified and may give unexpected results.
+        /// </remarks>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <returns>true if a precedes b</returns>
+        public static bool operator <(Timestamp a, Timestamp b)
+        {
+            return a.CompareTo(b) < 0;
+        }
+
+        /// <summary>
+        /// Compares two timestamps and returns whether the first is greater than (chronologically follows) the second
+        /// </summary>
+        /// <remarks>
+        /// Make sure the timestamps are normalized. Comparing non-normalized timestamps is not specified and may give unexpected results.
+        /// </remarks>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <returns>true if a follows b</returns>
+        public static bool operator >(Timestamp a, Timestamp b)
+        {
+            return a.CompareTo(b) > 0;
+        }
+
+        /// <summary>
+        /// Compares two timestamps and returns whether the first is less than (chronologically precedes) the second
+        /// </summary>
+        /// <remarks>
+        /// Make sure the timestamps are normalized. Comparing non-normalized timestamps is not specified and may give unexpected results.
+        /// </remarks>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <returns>true if a precedes b</returns>
+        public static bool operator <=(Timestamp a, Timestamp b)
+        {
+            return a.CompareTo(b) <= 0;
+        }
+
+        /// <summary>
+        /// Compares two timestamps and returns whether the first is greater than (chronologically follows) the second
+        /// </summary>
+        /// <remarks>
+        /// Make sure the timestamps are normalized. Comparing non-normalized timestamps is not specified and may give unexpected results.
+        /// </remarks>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <returns>true if a follows b</returns>
+        public static bool operator >=(Timestamp a, Timestamp b)
+        {
+            return a.CompareTo(b) >= 0;
+        }
+
+
+        /// <summary>
+        /// Returns whether two timestamps are equivalent
+        /// </summary>
+        /// <remarks>
+        /// Make sure the timestamps are normalized. Comparing non-normalized timestamps is not specified and may give unexpected results.
+        /// </remarks>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <returns>true if the two timestamps refer to the same nanosecond</returns>
+        public static bool operator ==(Timestamp a, Timestamp b)
+        {
+            return ReferenceEquals(a, b) || (ReferenceEquals(a, null) ? (ReferenceEquals(b, null) ? true : false) : a.Equals(b));
+        }
+
+        /// <summary>
+        /// Returns whether two timestamps differ
+        /// </summary>
+        /// <remarks>
+        /// Make sure the timestamps are normalized. Comparing non-normalized timestamps is not specified and may give unexpected results.
+        /// </remarks>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <returns>true if the two timestamps differ</returns>
+        public static bool operator !=(Timestamp a, Timestamp b)
+        {
+            return !(a == b);
+        }
+
+        /// <summary>
+        /// Returns a string representation of this <see cref="Timestamp"/> for diagnostic purposes.
+        /// </summary>
+        /// <remarks>
+        /// Normally the returned value will be a JSON string value (including leading and trailing quotes) but
+        /// when the value is non-normalized or out of range, a JSON object representation will be returned
+        /// instead, including a warning. This is to avoid exceptions being thrown when trying to
+        /// diagnose problems - the regular JSON formatter will still throw an exception for non-normalized
+        /// values.
+        /// </remarks>
+        /// <returns>A string representation of this value.</returns>
+        public string ToDiagnosticString()
+        {
+            return ToJson(Seconds, Nanos, true);
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Type.cs b/Libs/Google.Protobuf/WellKnownTypes/Type.cs
new file mode 100644
index 0000000..13f758c
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Type.cs
@@ -0,0 +1,1877 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/type.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/type.proto</summary>
+  public static partial class TypeReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/type.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static TypeReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Chpnb29nbGUvcHJvdG9idWYvdHlwZS5wcm90bxIPZ29vZ2xlLnByb3RvYnVm",
+            "Ghlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvGiRnb29nbGUvcHJvdG9idWYv",
+            "c291cmNlX2NvbnRleHQucHJvdG8i1wEKBFR5cGUSDAoEbmFtZRgBIAEoCRIm",
+            "CgZmaWVsZHMYAiADKAsyFi5nb29nbGUucHJvdG9idWYuRmllbGQSDgoGb25l",
+            "b2ZzGAMgAygJEigKB29wdGlvbnMYBCADKAsyFy5nb29nbGUucHJvdG9idWYu",
+            "T3B0aW9uEjYKDnNvdXJjZV9jb250ZXh0GAUgASgLMh4uZ29vZ2xlLnByb3Rv",
+            "YnVmLlNvdXJjZUNvbnRleHQSJwoGc3ludGF4GAYgASgOMhcuZ29vZ2xlLnBy",
+            "b3RvYnVmLlN5bnRheCLVBQoFRmllbGQSKQoEa2luZBgBIAEoDjIbLmdvb2ds",
+            "ZS5wcm90b2J1Zi5GaWVsZC5LaW5kEjcKC2NhcmRpbmFsaXR5GAIgASgOMiIu",
+            "Z29vZ2xlLnByb3RvYnVmLkZpZWxkLkNhcmRpbmFsaXR5Eg4KBm51bWJlchgD",
+            "IAEoBRIMCgRuYW1lGAQgASgJEhAKCHR5cGVfdXJsGAYgASgJEhMKC29uZW9m",
+            "X2luZGV4GAcgASgFEg4KBnBhY2tlZBgIIAEoCBIoCgdvcHRpb25zGAkgAygL",
+            "MhcuZ29vZ2xlLnByb3RvYnVmLk9wdGlvbhIRCglqc29uX25hbWUYCiABKAkS",
+            "FQoNZGVmYXVsdF92YWx1ZRgLIAEoCSLIAgoES2luZBIQCgxUWVBFX1VOS05P",
+            "V04QABIPCgtUWVBFX0RPVUJMRRABEg4KClRZUEVfRkxPQVQQAhIOCgpUWVBF",
+            "X0lOVDY0EAMSDwoLVFlQRV9VSU5UNjQQBBIOCgpUWVBFX0lOVDMyEAUSEAoM",
+            "VFlQRV9GSVhFRDY0EAYSEAoMVFlQRV9GSVhFRDMyEAcSDQoJVFlQRV9CT09M",
+            "EAgSDwoLVFlQRV9TVFJJTkcQCRIOCgpUWVBFX0dST1VQEAoSEAoMVFlQRV9N",
+            "RVNTQUdFEAsSDgoKVFlQRV9CWVRFUxAMEg8KC1RZUEVfVUlOVDMyEA0SDQoJ",
+            "VFlQRV9FTlVNEA4SEQoNVFlQRV9TRklYRUQzMhAPEhEKDVRZUEVfU0ZJWEVE",
+            "NjQQEBIPCgtUWVBFX1NJTlQzMhAREg8KC1RZUEVfU0lOVDY0EBIidAoLQ2Fy",
+            "ZGluYWxpdHkSFwoTQ0FSRElOQUxJVFlfVU5LTk9XThAAEhgKFENBUkRJTkFM",
+            "SVRZX09QVElPTkFMEAESGAoUQ0FSRElOQUxJVFlfUkVRVUlSRUQQAhIYChRD",
+            "QVJESU5BTElUWV9SRVBFQVRFRBADIs4BCgRFbnVtEgwKBG5hbWUYASABKAkS",
+            "LQoJZW51bXZhbHVlGAIgAygLMhouZ29vZ2xlLnByb3RvYnVmLkVudW1WYWx1",
+            "ZRIoCgdvcHRpb25zGAMgAygLMhcuZ29vZ2xlLnByb3RvYnVmLk9wdGlvbhI2",
+            "Cg5zb3VyY2VfY29udGV4dBgEIAEoCzIeLmdvb2dsZS5wcm90b2J1Zi5Tb3Vy",
+            "Y2VDb250ZXh0EicKBnN5bnRheBgFIAEoDjIXLmdvb2dsZS5wcm90b2J1Zi5T",
+            "eW50YXgiUwoJRW51bVZhbHVlEgwKBG5hbWUYASABKAkSDgoGbnVtYmVyGAIg",
+            "ASgFEigKB29wdGlvbnMYAyADKAsyFy5nb29nbGUucHJvdG9idWYuT3B0aW9u",
+            "IjsKBk9wdGlvbhIMCgRuYW1lGAEgASgJEiMKBXZhbHVlGAIgASgLMhQuZ29v",
+            "Z2xlLnByb3RvYnVmLkFueSouCgZTeW50YXgSEQoNU1lOVEFYX1BST1RPMhAA",
+            "EhEKDVNZTlRBWF9QUk9UTzMQAUJ7ChNjb20uZ29vZ2xlLnByb3RvYnVmQglU",
+            "eXBlUHJvdG9QAVotZ29vZ2xlLmdvbGFuZy5vcmcvcHJvdG9idWYvdHlwZXMv",
+            "a25vd24vdHlwZXBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxL",
+            "bm93blR5cGVzYgZwcm90bzM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::LC.Google.Protobuf.WellKnownTypes.AnyReflection.Descriptor, global::LC.Google.Protobuf.WellKnownTypes.SourceContextReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LC.Google.Protobuf.WellKnownTypes.Syntax), }, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Type), global::LC.Google.Protobuf.WellKnownTypes.Type.Parser, new[]{ "Name", "Fields", "Oneofs", "Options", "SourceContext", "Syntax" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Field), global::LC.Google.Protobuf.WellKnownTypes.Field.Parser, new[]{ "Kind", "Cardinality", "Number", "Name", "TypeUrl", "OneofIndex", "Packed", "Options", "JsonName", "DefaultValue" }, null, new[]{ typeof(global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind), typeof(global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality) }, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Enum), global::LC.Google.Protobuf.WellKnownTypes.Enum.Parser, new[]{ "Name", "Enumvalue", "Options", "SourceContext", "Syntax" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.EnumValue), global::LC.Google.Protobuf.WellKnownTypes.EnumValue.Parser, new[]{ "Name", "Number", "Options" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Option), global::LC.Google.Protobuf.WellKnownTypes.Option.Parser, new[]{ "Name", "Value" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Enums
+  /// <summary>
+  /// The syntax in which a protocol buffer element is defined.
+  /// </summary>
+  public enum Syntax {
+    /// <summary>
+    /// Syntax `proto2`.
+    /// </summary>
+    [pbr::OriginalName("SYNTAX_PROTO2")] Proto2 = 0,
+    /// <summary>
+    /// Syntax `proto3`.
+    /// </summary>
+    [pbr::OriginalName("SYNTAX_PROTO3")] Proto3 = 1,
+  }
+
+  #endregion
+
+  #region Messages
+  /// <summary>
+  /// A protocol buffer message type.
+  /// </summary>
+  public sealed partial class Type : pb::IMessage<Type>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Type> _parser = new pb::MessageParser<Type>(() => new Type());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Type> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.TypeReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Type() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Type(Type other) : this() {
+      name_ = other.name_;
+      fields_ = other.fields_.Clone();
+      oneofs_ = other.oneofs_.Clone();
+      options_ = other.options_.Clone();
+      sourceContext_ = other.sourceContext_ != null ? other.sourceContext_.Clone() : null;
+      syntax_ = other.syntax_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Type Clone() {
+      return new Type(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// The fully qualified message name.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "fields" field.</summary>
+    public const int FieldsFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Field> _repeated_fields_codec
+        = pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.WellKnownTypes.Field.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Field> fields_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Field>();
+    /// <summary>
+    /// The list of fields.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Field> Fields {
+      get { return fields_; }
+    }
+
+    /// <summary>Field number for the "oneofs" field.</summary>
+    public const int OneofsFieldNumber = 3;
+    private static readonly pb::FieldCodec<string> _repeated_oneofs_codec
+        = pb::FieldCodec.ForString(26);
+    private readonly pbc::RepeatedField<string> oneofs_ = new pbc::RepeatedField<string>();
+    /// <summary>
+    /// The list of types appearing in `oneof` definitions in this type.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<string> Oneofs {
+      get { return oneofs_; }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 4;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Option> _repeated_options_codec
+        = pb::FieldCodec.ForMessage(34, global::LC.Google.Protobuf.WellKnownTypes.Option.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> options_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option>();
+    /// <summary>
+    /// The protocol buffer options.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> Options {
+      get { return options_; }
+    }
+
+    /// <summary>Field number for the "source_context" field.</summary>
+    public const int SourceContextFieldNumber = 5;
+    private global::LC.Google.Protobuf.WellKnownTypes.SourceContext sourceContext_;
+    /// <summary>
+    /// The source context.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.SourceContext SourceContext {
+      get { return sourceContext_; }
+      set {
+        sourceContext_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "syntax" field.</summary>
+    public const int SyntaxFieldNumber = 6;
+    private global::LC.Google.Protobuf.WellKnownTypes.Syntax syntax_ = global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2;
+    /// <summary>
+    /// The source syntax.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Syntax Syntax {
+      get { return syntax_; }
+      set {
+        syntax_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Type);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Type other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if(!fields_.Equals(other.fields_)) return false;
+      if(!oneofs_.Equals(other.oneofs_)) return false;
+      if(!options_.Equals(other.options_)) return false;
+      if (!object.Equals(SourceContext, other.SourceContext)) return false;
+      if (Syntax != other.Syntax) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      hash ^= fields_.GetHashCode();
+      hash ^= oneofs_.GetHashCode();
+      hash ^= options_.GetHashCode();
+      if (sourceContext_ != null) hash ^= SourceContext.GetHashCode();
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) hash ^= Syntax.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      fields_.WriteTo(output, _repeated_fields_codec);
+      oneofs_.WriteTo(output, _repeated_oneofs_codec);
+      options_.WriteTo(output, _repeated_options_codec);
+      if (sourceContext_ != null) {
+        output.WriteRawTag(42);
+        output.WriteMessage(SourceContext);
+      }
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(48);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      fields_.WriteTo(ref output, _repeated_fields_codec);
+      oneofs_.WriteTo(ref output, _repeated_oneofs_codec);
+      options_.WriteTo(ref output, _repeated_options_codec);
+      if (sourceContext_ != null) {
+        output.WriteRawTag(42);
+        output.WriteMessage(SourceContext);
+      }
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(48);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      size += fields_.CalculateSize(_repeated_fields_codec);
+      size += oneofs_.CalculateSize(_repeated_oneofs_codec);
+      size += options_.CalculateSize(_repeated_options_codec);
+      if (sourceContext_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(SourceContext);
+      }
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Type other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      fields_.Add(other.fields_);
+      oneofs_.Add(other.oneofs_);
+      options_.Add(other.options_);
+      if (other.sourceContext_ != null) {
+        if (sourceContext_ == null) {
+          SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+        }
+        SourceContext.MergeFrom(other.SourceContext);
+      }
+      if (other.Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        Syntax = other.Syntax;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            fields_.AddEntriesFrom(input, _repeated_fields_codec);
+            break;
+          }
+          case 26: {
+            oneofs_.AddEntriesFrom(input, _repeated_oneofs_codec);
+            break;
+          }
+          case 34: {
+            options_.AddEntriesFrom(input, _repeated_options_codec);
+            break;
+          }
+          case 42: {
+            if (sourceContext_ == null) {
+              SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+            }
+            input.ReadMessage(SourceContext);
+            break;
+          }
+          case 48: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            fields_.AddEntriesFrom(ref input, _repeated_fields_codec);
+            break;
+          }
+          case 26: {
+            oneofs_.AddEntriesFrom(ref input, _repeated_oneofs_codec);
+            break;
+          }
+          case 34: {
+            options_.AddEntriesFrom(ref input, _repeated_options_codec);
+            break;
+          }
+          case 42: {
+            if (sourceContext_ == null) {
+              SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+            }
+            input.ReadMessage(SourceContext);
+            break;
+          }
+          case 48: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// A single field of a message type.
+  /// </summary>
+  public sealed partial class Field : pb::IMessage<Field>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Field> _parser = new pb::MessageParser<Field>(() => new Field());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Field> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.TypeReflection.Descriptor.MessageTypes[1]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Field() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Field(Field other) : this() {
+      kind_ = other.kind_;
+      cardinality_ = other.cardinality_;
+      number_ = other.number_;
+      name_ = other.name_;
+      typeUrl_ = other.typeUrl_;
+      oneofIndex_ = other.oneofIndex_;
+      packed_ = other.packed_;
+      options_ = other.options_.Clone();
+      jsonName_ = other.jsonName_;
+      defaultValue_ = other.defaultValue_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Field Clone() {
+      return new Field(this);
+    }
+
+    /// <summary>Field number for the "kind" field.</summary>
+    public const int KindFieldNumber = 1;
+    private global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind kind_ = global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown;
+    /// <summary>
+    /// The field type.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind Kind {
+      get { return kind_; }
+      set {
+        kind_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "cardinality" field.</summary>
+    public const int CardinalityFieldNumber = 2;
+    private global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality cardinality_ = global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality.Unknown;
+    /// <summary>
+    /// The field cardinality.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality Cardinality {
+      get { return cardinality_; }
+      set {
+        cardinality_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "number" field.</summary>
+    public const int NumberFieldNumber = 3;
+    private int number_;
+    /// <summary>
+    /// The field number.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int Number {
+      get { return number_; }
+      set {
+        number_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 4;
+    private string name_ = "";
+    /// <summary>
+    /// The field name.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "type_url" field.</summary>
+    public const int TypeUrlFieldNumber = 6;
+    private string typeUrl_ = "";
+    /// <summary>
+    /// The field type URL, without the scheme, for message or enumeration
+    /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string TypeUrl {
+      get { return typeUrl_; }
+      set {
+        typeUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "oneof_index" field.</summary>
+    public const int OneofIndexFieldNumber = 7;
+    private int oneofIndex_;
+    /// <summary>
+    /// The index of the field type in `Type.oneofs`, for message or enumeration
+    /// types. The first type has index 1; zero means the type is not in the list.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int OneofIndex {
+      get { return oneofIndex_; }
+      set {
+        oneofIndex_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "packed" field.</summary>
+    public const int PackedFieldNumber = 8;
+    private bool packed_;
+    /// <summary>
+    /// Whether to use alternative packed wire representation.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Packed {
+      get { return packed_; }
+      set {
+        packed_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 9;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Option> _repeated_options_codec
+        = pb::FieldCodec.ForMessage(74, global::LC.Google.Protobuf.WellKnownTypes.Option.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> options_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option>();
+    /// <summary>
+    /// The protocol buffer options.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> Options {
+      get { return options_; }
+    }
+
+    /// <summary>Field number for the "json_name" field.</summary>
+    public const int JsonNameFieldNumber = 10;
+    private string jsonName_ = "";
+    /// <summary>
+    /// The field JSON name.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string JsonName {
+      get { return jsonName_; }
+      set {
+        jsonName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "default_value" field.</summary>
+    public const int DefaultValueFieldNumber = 11;
+    private string defaultValue_ = "";
+    /// <summary>
+    /// The string value of the default value of this field. Proto2 syntax only.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string DefaultValue {
+      get { return defaultValue_; }
+      set {
+        defaultValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Field);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Field other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Kind != other.Kind) return false;
+      if (Cardinality != other.Cardinality) return false;
+      if (Number != other.Number) return false;
+      if (Name != other.Name) return false;
+      if (TypeUrl != other.TypeUrl) return false;
+      if (OneofIndex != other.OneofIndex) return false;
+      if (Packed != other.Packed) return false;
+      if(!options_.Equals(other.options_)) return false;
+      if (JsonName != other.JsonName) return false;
+      if (DefaultValue != other.DefaultValue) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Kind != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown) hash ^= Kind.GetHashCode();
+      if (Cardinality != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality.Unknown) hash ^= Cardinality.GetHashCode();
+      if (Number != 0) hash ^= Number.GetHashCode();
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      if (TypeUrl.Length != 0) hash ^= TypeUrl.GetHashCode();
+      if (OneofIndex != 0) hash ^= OneofIndex.GetHashCode();
+      if (Packed != false) hash ^= Packed.GetHashCode();
+      hash ^= options_.GetHashCode();
+      if (JsonName.Length != 0) hash ^= JsonName.GetHashCode();
+      if (DefaultValue.Length != 0) hash ^= DefaultValue.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Kind != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) Kind);
+      }
+      if (Cardinality != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality.Unknown) {
+        output.WriteRawTag(16);
+        output.WriteEnum((int) Cardinality);
+      }
+      if (Number != 0) {
+        output.WriteRawTag(24);
+        output.WriteInt32(Number);
+      }
+      if (Name.Length != 0) {
+        output.WriteRawTag(34);
+        output.WriteString(Name);
+      }
+      if (TypeUrl.Length != 0) {
+        output.WriteRawTag(50);
+        output.WriteString(TypeUrl);
+      }
+      if (OneofIndex != 0) {
+        output.WriteRawTag(56);
+        output.WriteInt32(OneofIndex);
+      }
+      if (Packed != false) {
+        output.WriteRawTag(64);
+        output.WriteBool(Packed);
+      }
+      options_.WriteTo(output, _repeated_options_codec);
+      if (JsonName.Length != 0) {
+        output.WriteRawTag(82);
+        output.WriteString(JsonName);
+      }
+      if (DefaultValue.Length != 0) {
+        output.WriteRawTag(90);
+        output.WriteString(DefaultValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Kind != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) Kind);
+      }
+      if (Cardinality != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality.Unknown) {
+        output.WriteRawTag(16);
+        output.WriteEnum((int) Cardinality);
+      }
+      if (Number != 0) {
+        output.WriteRawTag(24);
+        output.WriteInt32(Number);
+      }
+      if (Name.Length != 0) {
+        output.WriteRawTag(34);
+        output.WriteString(Name);
+      }
+      if (TypeUrl.Length != 0) {
+        output.WriteRawTag(50);
+        output.WriteString(TypeUrl);
+      }
+      if (OneofIndex != 0) {
+        output.WriteRawTag(56);
+        output.WriteInt32(OneofIndex);
+      }
+      if (Packed != false) {
+        output.WriteRawTag(64);
+        output.WriteBool(Packed);
+      }
+      options_.WriteTo(ref output, _repeated_options_codec);
+      if (JsonName.Length != 0) {
+        output.WriteRawTag(82);
+        output.WriteString(JsonName);
+      }
+      if (DefaultValue.Length != 0) {
+        output.WriteRawTag(90);
+        output.WriteString(DefaultValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Kind != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind);
+      }
+      if (Cardinality != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality.Unknown) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Cardinality);
+      }
+      if (Number != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Number);
+      }
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (TypeUrl.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(TypeUrl);
+      }
+      if (OneofIndex != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(OneofIndex);
+      }
+      if (Packed != false) {
+        size += 1 + 1;
+      }
+      size += options_.CalculateSize(_repeated_options_codec);
+      if (JsonName.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(JsonName);
+      }
+      if (DefaultValue.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(DefaultValue);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Field other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Kind != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown) {
+        Kind = other.Kind;
+      }
+      if (other.Cardinality != global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality.Unknown) {
+        Cardinality = other.Cardinality;
+      }
+      if (other.Number != 0) {
+        Number = other.Number;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      if (other.TypeUrl.Length != 0) {
+        TypeUrl = other.TypeUrl;
+      }
+      if (other.OneofIndex != 0) {
+        OneofIndex = other.OneofIndex;
+      }
+      if (other.Packed != false) {
+        Packed = other.Packed;
+      }
+      options_.Add(other.options_);
+      if (other.JsonName.Length != 0) {
+        JsonName = other.JsonName;
+      }
+      if (other.DefaultValue.Length != 0) {
+        DefaultValue = other.DefaultValue;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Kind = (global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind) input.ReadEnum();
+            break;
+          }
+          case 16: {
+            Cardinality = (global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality) input.ReadEnum();
+            break;
+          }
+          case 24: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 34: {
+            Name = input.ReadString();
+            break;
+          }
+          case 50: {
+            TypeUrl = input.ReadString();
+            break;
+          }
+          case 56: {
+            OneofIndex = input.ReadInt32();
+            break;
+          }
+          case 64: {
+            Packed = input.ReadBool();
+            break;
+          }
+          case 74: {
+            options_.AddEntriesFrom(input, _repeated_options_codec);
+            break;
+          }
+          case 82: {
+            JsonName = input.ReadString();
+            break;
+          }
+          case 90: {
+            DefaultValue = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Kind = (global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Kind) input.ReadEnum();
+            break;
+          }
+          case 16: {
+            Cardinality = (global::LC.Google.Protobuf.WellKnownTypes.Field.Types.Cardinality) input.ReadEnum();
+            break;
+          }
+          case 24: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 34: {
+            Name = input.ReadString();
+            break;
+          }
+          case 50: {
+            TypeUrl = input.ReadString();
+            break;
+          }
+          case 56: {
+            OneofIndex = input.ReadInt32();
+            break;
+          }
+          case 64: {
+            Packed = input.ReadBool();
+            break;
+          }
+          case 74: {
+            options_.AddEntriesFrom(ref input, _repeated_options_codec);
+            break;
+          }
+          case 82: {
+            JsonName = input.ReadString();
+            break;
+          }
+          case 90: {
+            DefaultValue = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the Field message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static partial class Types {
+      /// <summary>
+      /// Basic field types.
+      /// </summary>
+      public enum Kind {
+        /// <summary>
+        /// Field type unknown.
+        /// </summary>
+        [pbr::OriginalName("TYPE_UNKNOWN")] TypeUnknown = 0,
+        /// <summary>
+        /// Field type double.
+        /// </summary>
+        [pbr::OriginalName("TYPE_DOUBLE")] TypeDouble = 1,
+        /// <summary>
+        /// Field type float.
+        /// </summary>
+        [pbr::OriginalName("TYPE_FLOAT")] TypeFloat = 2,
+        /// <summary>
+        /// Field type int64.
+        /// </summary>
+        [pbr::OriginalName("TYPE_INT64")] TypeInt64 = 3,
+        /// <summary>
+        /// Field type uint64.
+        /// </summary>
+        [pbr::OriginalName("TYPE_UINT64")] TypeUint64 = 4,
+        /// <summary>
+        /// Field type int32.
+        /// </summary>
+        [pbr::OriginalName("TYPE_INT32")] TypeInt32 = 5,
+        /// <summary>
+        /// Field type fixed64.
+        /// </summary>
+        [pbr::OriginalName("TYPE_FIXED64")] TypeFixed64 = 6,
+        /// <summary>
+        /// Field type fixed32.
+        /// </summary>
+        [pbr::OriginalName("TYPE_FIXED32")] TypeFixed32 = 7,
+        /// <summary>
+        /// Field type bool.
+        /// </summary>
+        [pbr::OriginalName("TYPE_BOOL")] TypeBool = 8,
+        /// <summary>
+        /// Field type string.
+        /// </summary>
+        [pbr::OriginalName("TYPE_STRING")] TypeString = 9,
+        /// <summary>
+        /// Field type group. Proto2 syntax only, and deprecated.
+        /// </summary>
+        [pbr::OriginalName("TYPE_GROUP")] TypeGroup = 10,
+        /// <summary>
+        /// Field type message.
+        /// </summary>
+        [pbr::OriginalName("TYPE_MESSAGE")] TypeMessage = 11,
+        /// <summary>
+        /// Field type bytes.
+        /// </summary>
+        [pbr::OriginalName("TYPE_BYTES")] TypeBytes = 12,
+        /// <summary>
+        /// Field type uint32.
+        /// </summary>
+        [pbr::OriginalName("TYPE_UINT32")] TypeUint32 = 13,
+        /// <summary>
+        /// Field type enum.
+        /// </summary>
+        [pbr::OriginalName("TYPE_ENUM")] TypeEnum = 14,
+        /// <summary>
+        /// Field type sfixed32.
+        /// </summary>
+        [pbr::OriginalName("TYPE_SFIXED32")] TypeSfixed32 = 15,
+        /// <summary>
+        /// Field type sfixed64.
+        /// </summary>
+        [pbr::OriginalName("TYPE_SFIXED64")] TypeSfixed64 = 16,
+        /// <summary>
+        /// Field type sint32.
+        /// </summary>
+        [pbr::OriginalName("TYPE_SINT32")] TypeSint32 = 17,
+        /// <summary>
+        /// Field type sint64.
+        /// </summary>
+        [pbr::OriginalName("TYPE_SINT64")] TypeSint64 = 18,
+      }
+
+      /// <summary>
+      /// Whether a field is optional, required, or repeated.
+      /// </summary>
+      public enum Cardinality {
+        /// <summary>
+        /// For fields with unknown cardinality.
+        /// </summary>
+        [pbr::OriginalName("CARDINALITY_UNKNOWN")] Unknown = 0,
+        /// <summary>
+        /// For optional fields.
+        /// </summary>
+        [pbr::OriginalName("CARDINALITY_OPTIONAL")] Optional = 1,
+        /// <summary>
+        /// For required fields. Proto2 syntax only.
+        /// </summary>
+        [pbr::OriginalName("CARDINALITY_REQUIRED")] Required = 2,
+        /// <summary>
+        /// For repeated fields.
+        /// </summary>
+        [pbr::OriginalName("CARDINALITY_REPEATED")] Repeated = 3,
+      }
+
+    }
+    #endregion
+
+  }
+
+  /// <summary>
+  /// Enum type definition.
+  /// </summary>
+  public sealed partial class Enum : pb::IMessage<Enum>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Enum> _parser = new pb::MessageParser<Enum>(() => new Enum());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Enum> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.TypeReflection.Descriptor.MessageTypes[2]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Enum() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Enum(Enum other) : this() {
+      name_ = other.name_;
+      enumvalue_ = other.enumvalue_.Clone();
+      options_ = other.options_.Clone();
+      sourceContext_ = other.sourceContext_ != null ? other.sourceContext_.Clone() : null;
+      syntax_ = other.syntax_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Enum Clone() {
+      return new Enum(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// Enum type name.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "enumvalue" field.</summary>
+    public const int EnumvalueFieldNumber = 2;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.EnumValue> _repeated_enumvalue_codec
+        = pb::FieldCodec.ForMessage(18, global::LC.Google.Protobuf.WellKnownTypes.EnumValue.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.EnumValue> enumvalue_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.EnumValue>();
+    /// <summary>
+    /// Enum value definitions.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.EnumValue> Enumvalue {
+      get { return enumvalue_; }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 3;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Option> _repeated_options_codec
+        = pb::FieldCodec.ForMessage(26, global::LC.Google.Protobuf.WellKnownTypes.Option.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> options_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option>();
+    /// <summary>
+    /// Protocol buffer options.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> Options {
+      get { return options_; }
+    }
+
+    /// <summary>Field number for the "source_context" field.</summary>
+    public const int SourceContextFieldNumber = 4;
+    private global::LC.Google.Protobuf.WellKnownTypes.SourceContext sourceContext_;
+    /// <summary>
+    /// The source context.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.SourceContext SourceContext {
+      get { return sourceContext_; }
+      set {
+        sourceContext_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "syntax" field.</summary>
+    public const int SyntaxFieldNumber = 5;
+    private global::LC.Google.Protobuf.WellKnownTypes.Syntax syntax_ = global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2;
+    /// <summary>
+    /// The source syntax.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Syntax Syntax {
+      get { return syntax_; }
+      set {
+        syntax_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Enum);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Enum other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if(!enumvalue_.Equals(other.enumvalue_)) return false;
+      if(!options_.Equals(other.options_)) return false;
+      if (!object.Equals(SourceContext, other.SourceContext)) return false;
+      if (Syntax != other.Syntax) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      hash ^= enumvalue_.GetHashCode();
+      hash ^= options_.GetHashCode();
+      if (sourceContext_ != null) hash ^= SourceContext.GetHashCode();
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) hash ^= Syntax.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      enumvalue_.WriteTo(output, _repeated_enumvalue_codec);
+      options_.WriteTo(output, _repeated_options_codec);
+      if (sourceContext_ != null) {
+        output.WriteRawTag(34);
+        output.WriteMessage(SourceContext);
+      }
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(40);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      enumvalue_.WriteTo(ref output, _repeated_enumvalue_codec);
+      options_.WriteTo(ref output, _repeated_options_codec);
+      if (sourceContext_ != null) {
+        output.WriteRawTag(34);
+        output.WriteMessage(SourceContext);
+      }
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        output.WriteRawTag(40);
+        output.WriteEnum((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      size += enumvalue_.CalculateSize(_repeated_enumvalue_codec);
+      size += options_.CalculateSize(_repeated_options_codec);
+      if (sourceContext_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(SourceContext);
+      }
+      if (Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Syntax);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Enum other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      enumvalue_.Add(other.enumvalue_);
+      options_.Add(other.options_);
+      if (other.sourceContext_ != null) {
+        if (sourceContext_ == null) {
+          SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+        }
+        SourceContext.MergeFrom(other.SourceContext);
+      }
+      if (other.Syntax != global::LC.Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+        Syntax = other.Syntax;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            enumvalue_.AddEntriesFrom(input, _repeated_enumvalue_codec);
+            break;
+          }
+          case 26: {
+            options_.AddEntriesFrom(input, _repeated_options_codec);
+            break;
+          }
+          case 34: {
+            if (sourceContext_ == null) {
+              SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+            }
+            input.ReadMessage(SourceContext);
+            break;
+          }
+          case 40: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            enumvalue_.AddEntriesFrom(ref input, _repeated_enumvalue_codec);
+            break;
+          }
+          case 26: {
+            options_.AddEntriesFrom(ref input, _repeated_options_codec);
+            break;
+          }
+          case 34: {
+            if (sourceContext_ == null) {
+              SourceContext = new global::LC.Google.Protobuf.WellKnownTypes.SourceContext();
+            }
+            input.ReadMessage(SourceContext);
+            break;
+          }
+          case 40: {
+            Syntax = (global::LC.Google.Protobuf.WellKnownTypes.Syntax) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Enum value definition.
+  /// </summary>
+  public sealed partial class EnumValue : pb::IMessage<EnumValue>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<EnumValue> _parser = new pb::MessageParser<EnumValue>(() => new EnumValue());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<EnumValue> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.TypeReflection.Descriptor.MessageTypes[3]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValue() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValue(EnumValue other) : this() {
+      name_ = other.name_;
+      number_ = other.number_;
+      options_ = other.options_.Clone();
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public EnumValue Clone() {
+      return new EnumValue(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// Enum value name.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "number" field.</summary>
+    public const int NumberFieldNumber = 2;
+    private int number_;
+    /// <summary>
+    /// Enum value number.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int Number {
+      get { return number_; }
+      set {
+        number_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "options" field.</summary>
+    public const int OptionsFieldNumber = 3;
+    private static readonly pb::FieldCodec<global::LC.Google.Protobuf.WellKnownTypes.Option> _repeated_options_codec
+        = pb::FieldCodec.ForMessage(26, global::LC.Google.Protobuf.WellKnownTypes.Option.Parser);
+    private readonly pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> options_ = new pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option>();
+    /// <summary>
+    /// Protocol buffer options.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pbc::RepeatedField<global::LC.Google.Protobuf.WellKnownTypes.Option> Options {
+      get { return options_; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as EnumValue);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(EnumValue other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (Number != other.Number) return false;
+      if(!options_.Equals(other.options_)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      if (Number != 0) hash ^= Number.GetHashCode();
+      hash ^= options_.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (Number != 0) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Number);
+      }
+      options_.WriteTo(output, _repeated_options_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (Number != 0) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Number);
+      }
+      options_.WriteTo(ref output, _repeated_options_codec);
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (Number != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Number);
+      }
+      size += options_.CalculateSize(_repeated_options_codec);
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(EnumValue other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      if (other.Number != 0) {
+        Number = other.Number;
+      }
+      options_.Add(other.options_);
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 16: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 26: {
+            options_.AddEntriesFrom(input, _repeated_options_codec);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 16: {
+            Number = input.ReadInt32();
+            break;
+          }
+          case 26: {
+            options_.AddEntriesFrom(ref input, _repeated_options_codec);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// A protocol buffer option, which can be attached to a message, field,
+  /// enumeration, etc.
+  /// </summary>
+  public sealed partial class Option : pb::IMessage<Option>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Option> _parser = new pb::MessageParser<Option>(() => new Option());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Option> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.TypeReflection.Descriptor.MessageTypes[4]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Option() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Option(Option other) : this() {
+      name_ = other.name_;
+      value_ = other.value_ != null ? other.value_.Clone() : null;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Option Clone() {
+      return new Option(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// The option's name. For protobuf built-in options (options defined in
+    /// descriptor.proto), this is the short name. For example, `"map_entry"`.
+    /// For custom options, it should be the fully-qualified name. For example,
+    /// `"google.api.http"`.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 2;
+    private global::LC.Google.Protobuf.WellKnownTypes.Any value_;
+    /// <summary>
+    /// The option's value packed in an Any message. If the value is a primitive,
+    /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
+    /// should be used. If the value is an enum, it should be stored as an int32
+    /// value using the google.protobuf.Int32Value type.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public global::LC.Google.Protobuf.WellKnownTypes.Any Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Option);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Option other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (!object.Equals(Value, other.Value)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      if (value_ != null) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (value_ != null) {
+        output.WriteRawTag(18);
+        output.WriteMessage(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (value_ != null) {
+        output.WriteRawTag(18);
+        output.WriteMessage(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (value_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Option other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      if (other.value_ != null) {
+        if (value_ == null) {
+          Value = new global::LC.Google.Protobuf.WellKnownTypes.Any();
+        }
+        Value.MergeFrom(other.Value);
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            if (value_ == null) {
+              Value = new global::LC.Google.Protobuf.WellKnownTypes.Any();
+            }
+            input.ReadMessage(Value);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            if (value_ == null) {
+              Value = new global::LC.Google.Protobuf.WellKnownTypes.Any();
+            }
+            input.ReadMessage(Value);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/ValuePartial.cs b/Libs/Google.Protobuf/WellKnownTypes/ValuePartial.cs
new file mode 100644
index 0000000..e2b89e8
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/ValuePartial.cs
@@ -0,0 +1,99 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf.WellKnownTypes
+{
+    public partial class Value
+    {
+        /// <summary>
+        /// Convenience method to create a Value message with a string value.
+        /// </summary>
+        /// <param name="value">Value to set for the StringValue property.</param>
+        /// <returns>A newly-created Value message with the given value.</returns>
+        public static Value ForString(string value)
+        {
+            ProtoPreconditions.CheckNotNull(value, "value");
+            return new Value { StringValue = value };
+        }
+
+        /// <summary>
+        /// Convenience method to create a Value message with a number value.
+        /// </summary>
+        /// <param name="value">Value to set for the NumberValue property.</param>
+        /// <returns>A newly-created Value message with the given value.</returns>
+        public static Value ForNumber(double value)
+        {
+            return new Value { NumberValue = value };
+        }
+
+        /// <summary>
+        /// Convenience method to create a Value message with a Boolean value.
+        /// </summary>
+        /// <param name="value">Value to set for the BoolValue property.</param>
+        /// <returns>A newly-created Value message with the given value.</returns>
+        public static Value ForBool(bool value)
+        {
+            return new Value { BoolValue = value };
+        }
+
+        /// <summary>
+        /// Convenience method to create a Value message with a null initial value.
+        /// </summary>
+        /// <returns>A newly-created Value message a null initial value.</returns>
+        public static Value ForNull()
+        {
+            return new Value { NullValue = 0 };
+        }
+
+        /// <summary>
+        /// Convenience method to create a Value message with an initial list of values.
+        /// </summary>
+        /// <remarks>The values provided are not cloned; the references are copied directly.</remarks>
+        /// <returns>A newly-created Value message an initial list value.</returns>
+        public static Value ForList(params Value[] values)
+        {
+            ProtoPreconditions.CheckNotNull(values, "values");
+            return new Value { ListValue = new ListValue { Values = { values } } };
+        }
+
+        /// <summary>
+        /// Convenience method to create a Value message with an initial struct value
+        /// </summary>
+        /// <remarks>The value provided is not cloned; the reference is copied directly.</remarks>
+        /// <returns>A newly-created Value message an initial struct value.</returns>
+        public static Value ForStruct(Struct value)
+        {
+            ProtoPreconditions.CheckNotNull(value, "value");
+            return new Value { StructValue = value };
+        }
+    }
+}
diff --git a/Libs/Google.Protobuf/WellKnownTypes/Wrappers.cs b/Libs/Google.Protobuf/WellKnownTypes/Wrappers.cs
new file mode 100644
index 0000000..d6158ba
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/Wrappers.cs
@@ -0,0 +1,1680 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: google/protobuf/wrappers.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::LC.Google.Protobuf;
+using pbc = global::LC.Google.Protobuf.Collections;
+using pbr = global::LC.Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace LC.Google.Protobuf.WellKnownTypes {
+
+  /// <summary>Holder for reflection information generated from google/protobuf/wrappers.proto</summary>
+  public static partial class WrappersReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for google/protobuf/wrappers.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static WrappersReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Ch5nb29nbGUvcHJvdG9idWYvd3JhcHBlcnMucHJvdG8SD2dvb2dsZS5wcm90",
+            "b2J1ZiIcCgtEb3VibGVWYWx1ZRINCgV2YWx1ZRgBIAEoASIbCgpGbG9hdFZh",
+            "bHVlEg0KBXZhbHVlGAEgASgCIhsKCkludDY0VmFsdWUSDQoFdmFsdWUYASAB",
+            "KAMiHAoLVUludDY0VmFsdWUSDQoFdmFsdWUYASABKAQiGwoKSW50MzJWYWx1",
+            "ZRINCgV2YWx1ZRgBIAEoBSIcCgtVSW50MzJWYWx1ZRINCgV2YWx1ZRgBIAEo",
+            "DSIaCglCb29sVmFsdWUSDQoFdmFsdWUYASABKAgiHAoLU3RyaW5nVmFsdWUS",
+            "DQoFdmFsdWUYASABKAkiGwoKQnl0ZXNWYWx1ZRINCgV2YWx1ZRgBIAEoDEKD",
+            "AQoTY29tLmdvb2dsZS5wcm90b2J1ZkINV3JhcHBlcnNQcm90b1ABWjFnb29n",
+            "bGUuZ29sYW5nLm9yZy9wcm90b2J1Zi90eXBlcy9rbm93bi93cmFwcGVyc3Bi",
+            "+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZw",
+            "cm90bzM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.DoubleValue), global::LC.Google.Protobuf.WellKnownTypes.DoubleValue.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.FloatValue), global::LC.Google.Protobuf.WellKnownTypes.FloatValue.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Int64Value), global::LC.Google.Protobuf.WellKnownTypes.Int64Value.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.UInt64Value), global::LC.Google.Protobuf.WellKnownTypes.UInt64Value.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.Int32Value), global::LC.Google.Protobuf.WellKnownTypes.Int32Value.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.UInt32Value), global::LC.Google.Protobuf.WellKnownTypes.UInt32Value.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.BoolValue), global::LC.Google.Protobuf.WellKnownTypes.BoolValue.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.StringValue), global::LC.Google.Protobuf.WellKnownTypes.StringValue.Parser, new[]{ "Value" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::LC.Google.Protobuf.WellKnownTypes.BytesValue), global::LC.Google.Protobuf.WellKnownTypes.BytesValue.Parser, new[]{ "Value" }, null, null, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// Wrapper message for `double`.
+  ///
+  /// The JSON representation for `DoubleValue` is JSON number.
+  /// </summary>
+  public sealed partial class DoubleValue : pb::IMessage<DoubleValue>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<DoubleValue> _parser = new pb::MessageParser<DoubleValue>(() => new DoubleValue());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<DoubleValue> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public DoubleValue() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public DoubleValue(DoubleValue other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public DoubleValue Clone() {
+      return new DoubleValue(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private double value_;
+    /// <summary>
+    /// The double value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public double Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as DoubleValue);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(DoubleValue other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Value, other.Value)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Value);
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value != 0D) {
+        output.WriteRawTag(9);
+        output.WriteDouble(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value != 0D) {
+        output.WriteRawTag(9);
+        output.WriteDouble(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value != 0D) {
+        size += 1 + 8;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(DoubleValue other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value != 0D) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 9: {
+            Value = input.ReadDouble();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 9: {
+            Value = input.ReadDouble();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `float`.
+  ///
+  /// The JSON representation for `FloatValue` is JSON number.
+  /// </summary>
+  public sealed partial class FloatValue : pb::IMessage<FloatValue>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FloatValue> _parser = new pb::MessageParser<FloatValue>(() => new FloatValue());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<FloatValue> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[1]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FloatValue() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FloatValue(FloatValue other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public FloatValue Clone() {
+      return new FloatValue(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private float value_;
+    /// <summary>
+    /// The float value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public float Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as FloatValue);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(FloatValue other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Value, other.Value)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value != 0F) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Value);
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value != 0F) {
+        output.WriteRawTag(13);
+        output.WriteFloat(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value != 0F) {
+        output.WriteRawTag(13);
+        output.WriteFloat(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value != 0F) {
+        size += 1 + 4;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(FloatValue other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value != 0F) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 13: {
+            Value = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 13: {
+            Value = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `int64`.
+  ///
+  /// The JSON representation for `Int64Value` is JSON string.
+  /// </summary>
+  public sealed partial class Int64Value : pb::IMessage<Int64Value>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Int64Value> _parser = new pb::MessageParser<Int64Value>(() => new Int64Value());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Int64Value> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[2]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Int64Value() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Int64Value(Int64Value other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Int64Value Clone() {
+      return new Int64Value(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private long value_;
+    /// <summary>
+    /// The int64 value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public long Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Int64Value);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Int64Value other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value != 0L) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value != 0L) {
+        output.WriteRawTag(8);
+        output.WriteInt64(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value != 0L) {
+        output.WriteRawTag(8);
+        output.WriteInt64(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value != 0L) {
+        size += 1 + pb::CodedOutputStream.ComputeInt64Size(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Int64Value other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value != 0L) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Value = input.ReadInt64();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Value = input.ReadInt64();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `uint64`.
+  ///
+  /// The JSON representation for `UInt64Value` is JSON string.
+  /// </summary>
+  public sealed partial class UInt64Value : pb::IMessage<UInt64Value>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<UInt64Value> _parser = new pb::MessageParser<UInt64Value>(() => new UInt64Value());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<UInt64Value> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[3]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UInt64Value() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UInt64Value(UInt64Value other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UInt64Value Clone() {
+      return new UInt64Value(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private ulong value_;
+    /// <summary>
+    /// The uint64 value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public ulong Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as UInt64Value);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(UInt64Value other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value != 0UL) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value != 0UL) {
+        output.WriteRawTag(8);
+        output.WriteUInt64(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value != 0UL) {
+        output.WriteRawTag(8);
+        output.WriteUInt64(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value != 0UL) {
+        size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(UInt64Value other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value != 0UL) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Value = input.ReadUInt64();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Value = input.ReadUInt64();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `int32`.
+  ///
+  /// The JSON representation for `Int32Value` is JSON number.
+  /// </summary>
+  public sealed partial class Int32Value : pb::IMessage<Int32Value>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<Int32Value> _parser = new pb::MessageParser<Int32Value>(() => new Int32Value());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<Int32Value> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[4]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Int32Value() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Int32Value(Int32Value other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public Int32Value Clone() {
+      return new Int32Value(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private int value_;
+    /// <summary>
+    /// The int32 value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as Int32Value);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(Int32Value other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value != 0) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value != 0) {
+        output.WriteRawTag(8);
+        output.WriteInt32(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value != 0) {
+        output.WriteRawTag(8);
+        output.WriteInt32(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(Int32Value other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value != 0) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Value = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Value = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `uint32`.
+  ///
+  /// The JSON representation for `UInt32Value` is JSON number.
+  /// </summary>
+  public sealed partial class UInt32Value : pb::IMessage<UInt32Value>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<UInt32Value> _parser = new pb::MessageParser<UInt32Value>(() => new UInt32Value());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<UInt32Value> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[5]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UInt32Value() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UInt32Value(UInt32Value other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public UInt32Value Clone() {
+      return new UInt32Value(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private uint value_;
+    /// <summary>
+    /// The uint32 value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public uint Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as UInt32Value);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(UInt32Value other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value != 0) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value != 0) {
+        output.WriteRawTag(8);
+        output.WriteUInt32(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value != 0) {
+        output.WriteRawTag(8);
+        output.WriteUInt32(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(UInt32Value other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value != 0) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Value = input.ReadUInt32();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Value = input.ReadUInt32();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `bool`.
+  ///
+  /// The JSON representation for `BoolValue` is JSON `true` and `false`.
+  /// </summary>
+  public sealed partial class BoolValue : pb::IMessage<BoolValue>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<BoolValue> _parser = new pb::MessageParser<BoolValue>(() => new BoolValue());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<BoolValue> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[6]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public BoolValue() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public BoolValue(BoolValue other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public BoolValue Clone() {
+      return new BoolValue(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private bool value_;
+    /// <summary>
+    /// The bool value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Value {
+      get { return value_; }
+      set {
+        value_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as BoolValue);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(BoolValue other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value != false) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value != false) {
+        output.WriteRawTag(8);
+        output.WriteBool(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value != false) {
+        output.WriteRawTag(8);
+        output.WriteBool(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value != false) {
+        size += 1 + 1;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(BoolValue other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value != false) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Value = input.ReadBool();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Value = input.ReadBool();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `string`.
+  ///
+  /// The JSON representation for `StringValue` is JSON string.
+  /// </summary>
+  public sealed partial class StringValue : pb::IMessage<StringValue>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<StringValue> _parser = new pb::MessageParser<StringValue>(() => new StringValue());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<StringValue> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[7]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StringValue() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StringValue(StringValue other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public StringValue Clone() {
+      return new StringValue(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private string value_ = "";
+    /// <summary>
+    /// The string value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public string Value {
+      get { return value_; }
+      set {
+        value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as StringValue);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(StringValue other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value.Length != 0) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(StringValue other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value.Length != 0) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Value = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Value = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Wrapper message for `bytes`.
+  ///
+  /// The JSON representation for `BytesValue` is JSON string.
+  /// </summary>
+  public sealed partial class BytesValue : pb::IMessage<BytesValue>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<BytesValue> _parser = new pb::MessageParser<BytesValue>(() => new BytesValue());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pb::MessageParser<BytesValue> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::LC.Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor.MessageTypes[8]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public BytesValue() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public BytesValue(BytesValue other) : this() {
+      value_ = other.value_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public BytesValue Clone() {
+      return new BytesValue(this);
+    }
+
+    /// <summary>Field number for the "value" field.</summary>
+    public const int ValueFieldNumber = 1;
+    private pb::ByteString value_ = pb::ByteString.Empty;
+    /// <summary>
+    /// The bytes value.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public pb::ByteString Value {
+      get { return value_; }
+      set {
+        value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override bool Equals(object other) {
+      return Equals(other as BytesValue);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public bool Equals(BytesValue other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Value != other.Value) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Value.Length != 0) hash ^= Value.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Value.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteBytes(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Value.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteBytes(Value);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public int CalculateSize() {
+      int size = 0;
+      if (Value.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeBytesSize(Value);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(BytesValue other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Value.Length != 0) {
+        Value = other.Value;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Value = input.ReadBytes();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Value = input.ReadBytes();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/Libs/Google.Protobuf/WellKnownTypes/WrappersPartial.cs b/Libs/Google.Protobuf/WellKnownTypes/WrappersPartial.cs
new file mode 100644
index 0000000..102a9d0
--- /dev/null
+++ b/Libs/Google.Protobuf/WellKnownTypes/WrappersPartial.cs
@@ -0,0 +1,42 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf.WellKnownTypes
+{
+    public static partial class WrappersReflection
+    {
+        /// <summary>
+        /// Field number for the single "value" field in all wrapper types.
+        /// </summary>
+        internal const int WrapperValueFieldNumber = Int32Value.ValueFieldNumber;
+    }
+}
diff --git a/Libs/Google.Protobuf/WireFormat.cs b/Libs/Google.Protobuf/WireFormat.cs
new file mode 100644
index 0000000..95642d3
--- /dev/null
+++ b/Libs/Google.Protobuf/WireFormat.cs
@@ -0,0 +1,104 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// This class is used internally by the Protocol Buffer Library and generated
+    /// message implementations. It is public only for the sake of those generated
+    /// messages. Others should not use this class directly.
+    /// <para>
+    /// This class contains constants and helper functions useful for dealing with
+    /// the Protocol Buffer wire format.
+    /// </para>
+    /// </summary>
+    public static class WireFormat
+    {
+        /// <summary>
+        /// Wire types within protobuf encoding.
+        /// </summary>
+        public enum WireType : uint
+        {
+            /// <summary>
+            /// Variable-length integer.
+            /// </summary>
+            Varint = 0,
+            /// <summary>
+            /// A fixed-length 64-bit value.
+            /// </summary>
+            Fixed64 = 1,
+            /// <summary>
+            /// A length-delimited value, i.e. a length followed by that many bytes of data.
+            /// </summary>
+            LengthDelimited = 2,
+            /// <summary>
+            /// A "start group" value
+            /// </summary>
+            StartGroup = 3,
+            /// <summary>
+            /// An "end group" value
+            /// </summary>
+            EndGroup = 4,
+            /// <summary>
+            /// A fixed-length 32-bit value.
+            /// </summary>
+            Fixed32 = 5
+        }
+
+        private const int TagTypeBits = 3;
+        private const uint TagTypeMask = (1 << TagTypeBits) - 1;
+
+        /// <summary>
+        /// Given a tag value, determines the wire type (lower 3 bits).
+        /// </summary>
+        public static WireType GetTagWireType(uint tag)
+        {
+            return (WireType) (tag & TagTypeMask);
+        }
+
+        /// <summary>
+        /// Given a tag value, determines the field number (the upper 29 bits).
+        /// </summary>
+        public static int GetTagFieldNumber(uint tag)
+        {
+            return (int) tag >> TagTypeBits;
+        }
+
+        /// <summary>
+        /// Makes a tag value given a field number and wire type.
+        /// </summary>
+        public static uint MakeTag(int fieldNumber, WireType wireType)
+        {
+            return (uint) (fieldNumber << TagTypeBits) | (uint) wireType;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/WriteBufferHelper.cs b/Libs/Google.Protobuf/WriteBufferHelper.cs
new file mode 100644
index 0000000..5476284
--- /dev/null
+++ b/Libs/Google.Protobuf/WriteBufferHelper.cs
@@ -0,0 +1,166 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Abstraction for writing to a steam / IBufferWriter
+    /// </summary>
+    [SecuritySafeCritical]
+    internal struct WriteBufferHelper
+    {
+        private IBufferWriter<byte> bufferWriter;
+        private CodedOutputStream codedOutputStream;
+
+        public CodedOutputStream CodedOutputStream => codedOutputStream;
+
+        /// <summary>
+        /// Initialize an instance with a coded output stream.
+        /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+        /// and we can write directly into it without copying.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Initialize(CodedOutputStream codedOutputStream, out WriteBufferHelper instance)
+        {
+            instance.bufferWriter = null;
+            instance.codedOutputStream = codedOutputStream;
+        }
+
+        /// <summary>
+        /// Initialize an instance with a buffer writer.
+        /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+        /// and we can write directly into it without copying.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Initialize(IBufferWriter<byte> bufferWriter, out WriteBufferHelper instance, out Span<byte> buffer)
+        {
+            instance.bufferWriter = bufferWriter;
+            instance.codedOutputStream = null;
+            buffer = default;  // TODO: initialize the initial buffer so that the first write is not via slowpath.
+        }
+
+        /// <summary>
+        /// Initialize an instance with a buffer represented by a single span (i.e. buffer cannot be refreshed)
+        /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+        /// and we can write directly into it without copying.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void InitializeNonRefreshable(out WriteBufferHelper instance)
+        {
+            instance.bufferWriter = null;
+            instance.codedOutputStream = null;
+        }
+
+        /// <summary>
+        /// Verifies that SpaceLeft returns zero.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void CheckNoSpaceLeft(ref WriterInternalState state)
+        {
+            if (GetSpaceLeft(ref state) != 0)
+            {
+                throw new InvalidOperationException("Did not write as much data as expected.");
+            }
+        }
+
+        /// <summary>
+        /// If writing to a flat array, returns the space left in the array. Otherwise,
+        /// throws an InvalidOperationException.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int GetSpaceLeft(ref WriterInternalState state)
+        {
+            if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream == null && state.writeBufferHelper.bufferWriter == null)
+            {
+                return state.limit - state.position;
+            }
+            else
+            {
+                throw new InvalidOperationException(
+                    "SpaceLeft can only be called on CodedOutputStreams that are " +
+                        "writing to a flat array or when writing to a single span.");
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void RefreshBuffer(ref Span<byte> buffer, ref WriterInternalState state)
+        {
+            if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null)
+            {
+                // because we're using coded output stream, we know that "buffer" and codedOutputStream.InternalBuffer are identical.
+                state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position);
+                // reset position, limit stays the same because we are reusing the codedOutputStream's internal buffer.
+                state.position = 0;
+            }
+            else if (state.writeBufferHelper.bufferWriter != null)
+            {
+                // commit the bytes and get a new buffer to write to.
+                state.writeBufferHelper.bufferWriter.Advance(state.position);
+                state.position = 0;
+                buffer = state.writeBufferHelper.bufferWriter.GetSpan();
+                state.limit = buffer.Length;
+            }
+            else
+            {
+                // We're writing to a single buffer.
+                throw new CodedOutputStream.OutOfSpaceException();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Flush(ref Span<byte> buffer, ref WriterInternalState state)
+        {
+            if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null)
+            {
+                // because we're using coded output stream, we know that "buffer" and codedOutputStream.InternalBuffer are identical.
+                state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position);
+                state.position = 0;
+            }
+            else if (state.writeBufferHelper.bufferWriter != null)
+            {
+                // calling Advance invalidates the current buffer and we must not continue writing to it,
+                // so we set the current buffer to point to an empty Span. If any subsequent writes happen,
+                // the first subsequent write will trigger refresing of the buffer.
+                state.writeBufferHelper.bufferWriter.Advance(state.position);
+                state.position = 0;
+                state.limit = 0;
+                buffer = default;  // invalidate the current buffer
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/WriteContext.cs b/Libs/Google.Protobuf/WriteContext.cs
new file mode 100644
index 0000000..d489be9
--- /dev/null
+++ b/Libs/Google.Protobuf/WriteContext.cs
@@ -0,0 +1,371 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// An opaque struct that represents the current serialization state and is passed along
+    /// as the serialization proceeds.
+    /// All the public methods are intended to be invoked only by the generated code,
+    /// users should never invoke them directly.
+    /// </summary>
+    [SecuritySafeCritical]
+    public ref struct WriteContext
+    {
+        internal Span<byte> buffer;
+        internal WriterInternalState state;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(ref Span<byte> buffer, ref WriterInternalState state, out WriteContext ctx)
+        {
+            ctx.buffer = buffer;
+            ctx.state = state;
+        }
+
+        /// <summary>
+        /// Creates a WriteContext instance from CodedOutputStream.
+        /// WARNING: internally this copies the CodedOutputStream's state, so after done with the WriteContext,
+        /// the CodedOutputStream's state needs to be updated.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(CodedOutputStream output, out WriteContext ctx)
+        {
+            ctx.buffer = new Span<byte>(output.InternalBuffer);
+            // ideally we would use a reference to the original state, but that doesn't seem possible
+            // so we just copy the struct that holds the state. We will need to later store the state back
+            // into CodedOutputStream if we want to keep it usable.
+            ctx.state = output.InternalState;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(IBufferWriter<byte> output, out WriteContext ctx)
+        {
+            ctx.buffer = default;
+            ctx.state = default;
+            WriteBufferHelper.Initialize(output, out ctx.state.writeBufferHelper, out ctx.buffer);
+            ctx.state.limit = ctx.buffer.Length;
+            ctx.state.position = 0;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void Initialize(ref Span<byte> buffer, out WriteContext ctx)
+        {
+            ctx.buffer = buffer;
+            ctx.state = default;
+            ctx.state.limit = ctx.buffer.Length;
+            ctx.state.position = 0;
+            WriteBufferHelper.InitializeNonRefreshable(out ctx.state.writeBufferHelper);
+        }
+
+        /// <summary>
+        /// Writes a double field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteDouble(double value)
+        {
+            WritingPrimitives.WriteDouble(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a float field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteFloat(float value)
+        {
+            WritingPrimitives.WriteFloat(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a uint64 field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteUInt64(ulong value)
+        {
+            WritingPrimitives.WriteUInt64(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an int64 field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteInt64(long value)
+        {
+            WritingPrimitives.WriteInt64(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an int32 field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteInt32(int value)
+        {
+            WritingPrimitives.WriteInt32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a fixed64 field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteFixed64(ulong value)
+        {
+            WritingPrimitives.WriteFixed64(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a fixed32 field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteFixed32(uint value)
+        {
+            WritingPrimitives.WriteFixed32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a bool field value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteBool(bool value)
+        {
+            WritingPrimitives.WriteBool(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a string field value, without a tag.
+        /// The data is length-prefixed.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteString(string value)
+        {
+            WritingPrimitives.WriteString(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a message, without a tag.
+        /// The data is length-prefixed.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteMessage(IMessage value)
+        {
+            WritingPrimitivesMessages.WriteMessage(ref this, value);
+        }
+
+        /// <summary>
+        /// Writes a group, without a tag, to the stream.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteGroup(IMessage value)
+        {
+            WritingPrimitivesMessages.WriteGroup(ref this, value);
+        }
+
+        /// <summary>
+        /// Write a byte string, without a tag, to the stream.
+        /// The data is length-prefixed.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteBytes(ByteString value)
+        {
+            WritingPrimitives.WriteBytes(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a uint32 value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteUInt32(uint value)
+        {
+            WritingPrimitives.WriteUInt32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an enum value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteEnum(int value)
+        {
+            WritingPrimitives.WriteEnum(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sfixed32 value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write.</param>
+        public void WriteSFixed32(int value)
+        {
+            WritingPrimitives.WriteSFixed32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sfixed64 value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteSFixed64(long value)
+        {
+            WritingPrimitives.WriteSFixed64(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sint32 value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteSInt32(int value)
+        {
+            WritingPrimitives.WriteSInt32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sint64 value, without a tag.
+        /// </summary>
+        /// <param name="value">The value to write</param>
+        public void WriteSInt64(long value)
+        {
+            WritingPrimitives.WriteSInt64(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a length (in bytes) for length-delimited data.
+        /// </summary>
+        /// <remarks>
+        /// This method simply writes a rawint, but exists for clarity in calling code.
+        /// </remarks>
+        /// <param name="length">Length value, in bytes.</param>
+        public void WriteLength(int length)
+        {
+            WritingPrimitives.WriteLength(ref buffer, ref state, length);
+        }
+
+        /// <summary>
+        /// Encodes and writes a tag.
+        /// </summary>
+        /// <param name="fieldNumber">The number of the field to write the tag for</param>
+        /// <param name="type">The wire format type of the tag to write</param>
+        public void WriteTag(int fieldNumber, WireFormat.WireType type)
+        {
+            WritingPrimitives.WriteTag(ref buffer, ref state, fieldNumber, type);
+        }
+
+        /// <summary>
+        /// Writes an already-encoded tag.
+        /// </summary>
+        /// <param name="tag">The encoded tag</param>
+        public void WriteTag(uint tag)
+        {
+            WritingPrimitives.WriteTag(ref buffer, ref state, tag);
+        }
+
+        /// <summary>
+        /// Writes the given single-byte tag.
+        /// </summary>
+        /// <param name="b1">The encoded tag</param>
+        public void WriteRawTag(byte b1)
+        {
+            WritingPrimitives.WriteRawTag(ref buffer, ref state, b1);
+        }
+
+        /// <summary>
+        /// Writes the given two-byte tag.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2)
+        {
+            WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2);
+        }
+
+        /// <summary>
+        /// Writes the given three-byte tag.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        /// <param name="b3">The third byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2, byte b3)
+        {
+            WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3);
+        }
+
+        /// <summary>
+        /// Writes the given four-byte tag.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        /// <param name="b3">The third byte of the encoded tag</param>
+        /// <param name="b4">The fourth byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2, byte b3, byte b4)
+        {
+            WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3, b4);
+        }
+
+        /// <summary>
+        /// Writes the given five-byte tag.
+        /// </summary>
+        /// <param name="b1">The first byte of the encoded tag</param>
+        /// <param name="b2">The second byte of the encoded tag</param>
+        /// <param name="b3">The third byte of the encoded tag</param>
+        /// <param name="b4">The fourth byte of the encoded tag</param>
+        /// <param name="b5">The fifth byte of the encoded tag</param>
+        public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5)
+        {
+            WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3, b4, b5);
+        }
+
+        internal void Flush()
+        {
+            WriteBufferHelper.Flush(ref buffer, ref state);
+        }
+
+        internal void CheckNoSpaceLeft()
+        {
+            WriteBufferHelper.CheckNoSpaceLeft(ref state);
+        }
+
+        internal void CopyStateTo(CodedOutputStream output)
+        {
+            output.InternalState = state;
+        }
+
+        internal void LoadStateFrom(CodedOutputStream output)
+        {
+            state = output.InternalState;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/WriterInternalState.cs b/Libs/Google.Protobuf/WriterInternalState.cs
new file mode 100644
index 0000000..bf228e6
--- /dev/null
+++ b/Libs/Google.Protobuf/WriterInternalState.cs
@@ -0,0 +1,62 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using LC.Google.Protobuf.Collections;
+
+namespace LC.Google.Protobuf
+{
+    
+    // warning: this is a mutable struct, so it needs to be only passed as a ref!
+    internal struct WriterInternalState
+    {
+        // NOTE: the Span representing the current buffer is kept separate so that this doesn't have to be a ref struct and so it can
+        // be included in CodedOutputStream's internal state
+
+        internal int limit;  // the size of the current buffer
+        internal int position;  // position in the current buffer
+
+        internal WriteBufferHelper writeBufferHelper;
+
+        // If non-null, the top level parse method was started with given coded output stream as an argument
+        // which also means we can potentially fallback to calling WriteTo(CodedOutputStream cos) if needed.
+        internal CodedOutputStream CodedOutputStream => writeBufferHelper.CodedOutputStream;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/WritingPrimitives.cs b/Libs/Google.Protobuf/WritingPrimitives.cs
new file mode 100644
index 0000000..0babf09
--- /dev/null
+++ b/Libs/Google.Protobuf/WritingPrimitives.cs
@@ -0,0 +1,757 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers.Binary;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+#if GOOGLE_PROTOBUF_SIMD
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.X86;
+#endif
+using System.Security;
+using System.Text;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Primitives for encoding protobuf wire format.
+    /// </summary>
+    [SecuritySafeCritical]
+    internal static class WritingPrimitives
+    {
+#if NET5_0
+        internal static Encoding Utf8Encoding => Encoding.UTF8; // allows JIT to devirtualize
+#else
+        internal static readonly Encoding Utf8Encoding = Encoding.UTF8; // "Local" copy of Encoding.UTF8, for efficiency. (Yes, it makes a difference.)
+#endif
+
+        #region Writing of values (not including tags)
+
+        /// <summary>
+        /// Writes a double field value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteDouble(ref Span<byte> buffer, ref WriterInternalState state, double value)
+        {
+            WriteRawLittleEndian64(ref buffer, ref state, (ulong)BitConverter.DoubleToInt64Bits(value));
+        }
+
+        /// <summary>
+        /// Writes a float field value, without a tag, to the stream.
+        /// </summary>
+        public static unsafe void WriteFloat(ref Span<byte> buffer, ref WriterInternalState state, float value)
+        {
+            const int length = sizeof(float);
+            if (buffer.Length - state.position >= length)
+            {
+                // if there's enough space in the buffer, write the float directly into the buffer
+                var floatSpan = buffer.Slice(state.position, length);
+                Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(floatSpan), value);
+
+                if (!BitConverter.IsLittleEndian)
+                {
+                    floatSpan.Reverse();
+                }
+                state.position += length;
+            }
+            else
+            {
+                WriteFloatSlowPath(ref buffer, ref state, value);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static unsafe void WriteFloatSlowPath(ref Span<byte> buffer, ref WriterInternalState state, float value)
+        {
+            const int length = sizeof(float);
+
+            // TODO(jtattermusch): deduplicate the code. Populating the span is the same as for the fastpath.
+            Span<byte> floatSpan = stackalloc byte[length];
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(floatSpan), value);
+            if (!BitConverter.IsLittleEndian)
+            {
+                floatSpan.Reverse();
+            }
+
+            WriteRawByte(ref buffer, ref state, floatSpan[0]);
+            WriteRawByte(ref buffer, ref state, floatSpan[1]);
+            WriteRawByte(ref buffer, ref state, floatSpan[2]);
+            WriteRawByte(ref buffer, ref state, floatSpan[3]);
+        }
+
+        /// <summary>
+        /// Writes a uint64 field value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteUInt64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
+        {
+            WriteRawVarint64(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an int64 field value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteInt64(ref Span<byte> buffer, ref WriterInternalState state, long value)
+        {
+            WriteRawVarint64(ref buffer, ref state, (ulong)value);
+        }
+
+        /// <summary>
+        /// Writes an int32 field value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteInt32(ref Span<byte> buffer, ref WriterInternalState state, int value)
+        {
+            if (value >= 0)
+            {
+                WriteRawVarint32(ref buffer, ref state, (uint)value);
+            }
+            else
+            {
+                // Must sign-extend.
+                WriteRawVarint64(ref buffer, ref state, (ulong)value);
+            }
+        }
+
+        /// <summary>
+        /// Writes a fixed64 field value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteFixed64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
+        {
+            WriteRawLittleEndian64(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a fixed32 field value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteFixed32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
+        {
+            WriteRawLittleEndian32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes a bool field value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteBool(ref Span<byte> buffer, ref WriterInternalState state, bool value)
+        {
+            WriteRawByte(ref buffer, ref state, value ? (byte)1 : (byte)0);
+        }
+
+        /// <summary>
+        /// Writes a string field value, without a tag, to the stream.
+        /// The data is length-prefixed.
+        /// </summary>
+        public static void WriteString(ref Span<byte> buffer, ref WriterInternalState state, string value)
+        {
+            const int MaxBytesPerChar = 3;
+            const int MaxSmallStringLength = 128 / MaxBytesPerChar;
+
+            // The string is small enough that the length will always be a 1 byte varint.
+            // Also there is enough space to write length + bytes to buffer.
+            // Write string directly to the buffer, and then write length.
+            // This saves calling GetByteCount on the string. We get the string length from GetBytes.
+            if (value.Length <= MaxSmallStringLength && buffer.Length - state.position - 1 >= value.Length * MaxBytesPerChar)
+            {
+                int indexOfLengthDelimiter = state.position++;
+                buffer[indexOfLengthDelimiter] = (byte)WriteStringToBuffer(buffer, ref state, value);
+                return;
+            }
+
+            int length = Utf8Encoding.GetByteCount(value);
+            WriteLength(ref buffer, ref state, length);
+
+            // Optimise the case where we have enough space to write
+            // the string directly to the buffer, which should be common.
+            if (buffer.Length - state.position >= length)
+            {
+                if (length == value.Length) // Must be all ASCII...
+                {
+                    WriteAsciiStringToBuffer(buffer, ref state, value, length);
+                }
+                else
+                {
+                    WriteStringToBuffer(buffer, ref state, value);
+                }
+            }
+            else
+            {
+                // Opportunity for future optimization:
+                // Large strings that don't fit into the current buffer segment
+                // can probably be optimized by using Utf8Encoding.GetEncoder()
+                // but more benchmarks would need to be added as evidence.
+                byte[] bytes = Utf8Encoding.GetBytes(value);
+                WriteRawBytes(ref buffer, ref state, bytes);
+            }
+        }
+
+        // Calling this method with non-ASCII content will break.
+        // Content must be verified to be all ASCII before using this method.
+        private static void WriteAsciiStringToBuffer(Span<byte> buffer, ref WriterInternalState state, string value, int length)
+        {
+            ref char sourceChars = ref MemoryMarshal.GetReference(value.AsSpan());
+            ref byte destinationBytes = ref MemoryMarshal.GetReference(buffer.Slice(state.position));
+
+            int currentIndex = 0;
+            // If 64bit, process 4 chars at a time.
+            // The logic inside this check will be elided by JIT in 32bit programs.
+            if (IntPtr.Size == 8)
+            {
+                // Need at least 4 chars available to use this optimization. 
+                if (length >= 4)
+                {
+                    ref byte sourceBytes = ref Unsafe.As<char, byte>(ref sourceChars);
+
+                    // Process 4 chars at a time until there are less than 4 remaining.
+                    // We already know all characters are ASCII so there is no need to validate the source.
+                    int lastIndexWhereCanReadFourChars = value.Length - 4;
+                    do
+                    {
+                        NarrowFourUtf16CharsToAsciiAndWriteToBuffer(
+                            ref Unsafe.AddByteOffset(ref destinationBytes, (IntPtr)currentIndex),
+                            Unsafe.ReadUnaligned<ulong>(ref Unsafe.AddByteOffset(ref sourceBytes, (IntPtr)(currentIndex * 2))));
+
+                    } while ((currentIndex += 4) <= lastIndexWhereCanReadFourChars);
+                }
+            }
+
+            // Process any remaining, 1 char at a time.
+            // Avoid bounds checking with ref + Unsafe
+            for (; currentIndex < length; currentIndex++)
+            {
+                Unsafe.AddByteOffset(ref destinationBytes, (IntPtr)currentIndex) = (byte)Unsafe.AddByteOffset(ref sourceChars, (IntPtr)(currentIndex * 2));
+            }
+
+            state.position += length;
+        }
+
+        // Copied with permission from https://github.com/dotnet/runtime/blob/1cdafd27e4afd2c916af5df949c13f8b373c4335/src/libraries/System.Private.CoreLib/src/System/Text/ASCIIUtility.cs#L1119-L1171
+        //
+        /// <summary>
+        /// Given a QWORD which represents a buffer of 4 ASCII chars in machine-endian order,
+        /// narrows each WORD to a BYTE, then writes the 4-byte result to the output buffer
+        /// also in machine-endian order.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void NarrowFourUtf16CharsToAsciiAndWriteToBuffer(ref byte outputBuffer, ulong value)
+        {
+#if GOOGLE_PROTOBUF_SIMD
+            if (Sse2.X64.IsSupported)
+            {
+                // Narrows a vector of words [ w0 w1 w2 w3 ] to a vector of bytes
+                // [ b0 b1 b2 b3 b0 b1 b2 b3 ], then writes 4 bytes (32 bits) to the destination.
+
+                Vector128<short> vecWide = Sse2.X64.ConvertScalarToVector128UInt64(value).AsInt16();
+                Vector128<uint> vecNarrow = Sse2.PackUnsignedSaturate(vecWide, vecWide).AsUInt32();
+                Unsafe.WriteUnaligned<uint>(ref outputBuffer, Sse2.ConvertToUInt32(vecNarrow));
+            }
+            else if (AdvSimd.IsSupported)
+            {
+                // Narrows a vector of words [ w0 w1 w2 w3 ] to a vector of bytes
+                // [ b0 b1 b2 b3 * * * * ], then writes 4 bytes (32 bits) to the destination.
+
+                Vector128<short> vecWide = Vector128.CreateScalarUnsafe(value).AsInt16();
+                Vector64<byte> lower = AdvSimd.ExtractNarrowingSaturateUnsignedLower(vecWide);
+                Unsafe.WriteUnaligned<uint>(ref outputBuffer, lower.AsUInt32().ToScalar());
+            }
+            else
+#endif
+            {
+                // Fallback to non-SIMD approach when SIMD is not available.
+                // This could happen either because the APIs are not available, or hardware doesn't support it.
+                // Processing 4 chars at a time in this fallback is still faster than casting one char at a time.
+                if (BitConverter.IsLittleEndian)
+                {
+                    outputBuffer = (byte)value;
+                    value >>= 16;
+                    Unsafe.Add(ref outputBuffer, 1) = (byte)value;
+                    value >>= 16;
+                    Unsafe.Add(ref outputBuffer, 2) = (byte)value;
+                    value >>= 16;
+                    Unsafe.Add(ref outputBuffer, 3) = (byte)value;
+                }
+                else
+                {
+                    Unsafe.Add(ref outputBuffer, 3) = (byte)value;
+                    value >>= 16;
+                    Unsafe.Add(ref outputBuffer, 2) = (byte)value;
+                    value >>= 16;
+                    Unsafe.Add(ref outputBuffer, 1) = (byte)value;
+                    value >>= 16;
+                    outputBuffer = (byte)value;
+                }
+            }
+        }
+
+        private static int WriteStringToBuffer(Span<byte> buffer, ref WriterInternalState state, string value)
+        {
+#if NETSTANDARD1_1
+            // slowpath when Encoding.GetBytes(Char*, Int32, Byte*, Int32) is not available
+            byte[] bytes = Utf8Encoding.GetBytes(value);
+            WriteRawBytes(ref buffer, ref state, bytes);
+            return bytes.Length;
+#else
+            ReadOnlySpan<char> source = value.AsSpan();
+            int bytesUsed;
+            unsafe
+            {
+                fixed (char* sourceChars = &MemoryMarshal.GetReference(source))
+                fixed (byte* destinationBytes = &MemoryMarshal.GetReference(buffer))
+                {
+                    bytesUsed = Utf8Encoding.GetBytes(
+                        sourceChars,
+                        source.Length,
+                        destinationBytes + state.position,
+                        buffer.Length - state.position);
+                }
+            }
+            state.position += bytesUsed;
+            return bytesUsed;
+#endif
+        }
+
+        /// <summary>
+        /// Write a byte string, without a tag, to the stream.
+        /// The data is length-prefixed.
+        /// </summary>
+        public static void WriteBytes(ref Span<byte> buffer, ref WriterInternalState state, ByteString value)
+        {
+            WriteLength(ref buffer, ref state, value.Length);
+            WriteRawBytes(ref buffer, ref state, value.Span);
+        }
+
+        /// <summary>
+        /// Writes a uint32 value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteUInt32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
+        {
+            WriteRawVarint32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an enum value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteEnum(ref Span<byte> buffer, ref WriterInternalState state, int value)
+        {
+            WriteInt32(ref buffer, ref state, value);
+        }
+
+        /// <summary>
+        /// Writes an sfixed32 value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteSFixed32(ref Span<byte> buffer, ref WriterInternalState state, int value)
+        {
+            WriteRawLittleEndian32(ref buffer, ref state, (uint)value);
+        }
+
+        /// <summary>
+        /// Writes an sfixed64 value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteSFixed64(ref Span<byte> buffer, ref WriterInternalState state, long value)
+        {
+            WriteRawLittleEndian64(ref buffer, ref state, (ulong)value);
+        }
+
+        /// <summary>
+        /// Writes an sint32 value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteSInt32(ref Span<byte> buffer, ref WriterInternalState state, int value)
+        {
+            WriteRawVarint32(ref buffer, ref state, EncodeZigZag32(value));
+        }
+
+        /// <summary>
+        /// Writes an sint64 value, without a tag, to the stream.
+        /// </summary>
+        public static void WriteSInt64(ref Span<byte> buffer, ref WriterInternalState state, long value)
+        {
+            WriteRawVarint64(ref buffer, ref state, EncodeZigZag64(value));
+        }
+
+        /// <summary>
+        /// Writes a length (in bytes) for length-delimited data.
+        /// </summary>
+        /// <remarks>
+        /// This method simply writes a rawint, but exists for clarity in calling code.
+        /// </remarks>
+        public static void WriteLength(ref Span<byte> buffer, ref WriterInternalState state, int length)
+        {
+            WriteRawVarint32(ref buffer, ref state, (uint)length);
+        }
+
+        #endregion
+
+        #region Writing primitives
+        /// <summary>
+        /// Writes a 32 bit value as a varint. The fast route is taken when
+        /// there's enough buffer space left to whizz through without checking
+        /// for each byte; otherwise, we resort to calling WriteRawByte each time.
+        /// </summary>
+        public static void WriteRawVarint32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
+        {
+            // Optimize for the common case of a single byte value
+            if (value < 128 && state.position < buffer.Length)
+            {
+                buffer[state.position++] = (byte)value;
+                return;
+            }
+
+            // Fast path when capacity is available
+            while (state.position < buffer.Length)
+            {
+                if (value > 127)
+                {
+                    buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
+                    value >>= 7;
+                }
+                else
+                {
+                    buffer[state.position++] = (byte)value;
+                    return;
+                }
+            }
+
+            while (value > 127)
+            {
+                WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
+                value >>= 7;
+            }
+
+            WriteRawByte(ref buffer, ref state, (byte)value);
+        }
+
+        public static void WriteRawVarint64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
+        {
+            // Optimize for the common case of a single byte value
+            if (value < 128 && state.position < buffer.Length)
+            {
+                buffer[state.position++] = (byte)value;
+                return;
+            }
+
+            // Fast path when capacity is available
+            while (state.position < buffer.Length)
+            {
+                if (value > 127)
+                {
+                    buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
+                    value >>= 7;
+                }
+                else
+                {
+                    buffer[state.position++] = (byte)value;
+                    return;
+                }
+            }
+
+            while (value > 127)
+            {
+                WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
+                value >>= 7;
+            }
+
+            WriteRawByte(ref buffer, ref state, (byte)value);
+        }
+
+        public static void WriteRawLittleEndian32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
+        {
+            const int length = sizeof(uint);
+            if (state.position + length > buffer.Length)
+            {
+                WriteRawLittleEndian32SlowPath(ref buffer, ref state, value);
+            }
+            else
+            {
+                BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(state.position), value);
+                state.position += length;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static void WriteRawLittleEndian32SlowPath(ref Span<byte> buffer, ref WriterInternalState state, uint value)
+        {
+            WriteRawByte(ref buffer, ref state, (byte)value);
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
+        }
+
+        public static void WriteRawLittleEndian64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
+        {
+            const int length = sizeof(ulong);
+            if (state.position + length > buffer.Length)
+            {
+                WriteRawLittleEndian64SlowPath(ref buffer, ref state, value);
+            }
+            else
+            {
+                BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(state.position), value);
+                state.position += length;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void WriteRawLittleEndian64SlowPath(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
+        {
+            WriteRawByte(ref buffer, ref state, (byte)value);
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 32));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 40));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 48));
+            WriteRawByte(ref buffer, ref state, (byte)(value >> 56));
+        }
+
+        private static void WriteRawByte(ref Span<byte> buffer, ref WriterInternalState state, byte value)
+        {
+            if (state.position == buffer.Length)
+            {
+                WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
+            }
+
+            buffer[state.position++] = value;
+        }
+
+        /// <summary>
+        /// Writes out an array of bytes.
+        /// </summary>
+        public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, byte[] value)
+        {
+            WriteRawBytes(ref buffer, ref state, new ReadOnlySpan<byte>(value));
+        }
+
+        /// <summary>
+        /// Writes out part of an array of bytes.
+        /// </summary>
+        public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, byte[] value, int offset, int length)
+        {
+            WriteRawBytes(ref buffer, ref state, new ReadOnlySpan<byte>(value, offset, length));
+        }
+
+        /// <summary>
+        /// Writes out part of an array of bytes.
+        /// </summary>
+        public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, ReadOnlySpan<byte> value)
+        {
+            if (buffer.Length - state.position >= value.Length)
+            {
+                // We have room in the current buffer.    
+                value.CopyTo(buffer.Slice(state.position, value.Length));
+                state.position += value.Length;
+            }
+            else
+            {
+                // When writing to a CodedOutputStream backed by a Stream, we could avoid
+                // copying the data twice (first copying to the current buffer and
+                // and later writing from the current buffer to the underlying Stream)
+                // in some circumstances by writing the data directly to the underlying Stream.
+                // Current this is not being done to avoid specialcasing the code for
+                // CodedOutputStream vs IBufferWriter<byte>.
+                int bytesWritten = 0;
+                while (buffer.Length - state.position < value.Length - bytesWritten)
+                {
+                    int length = buffer.Length - state.position;
+                    value.Slice(bytesWritten, length).CopyTo(buffer.Slice(state.position, length));
+                    bytesWritten += length;
+                    state.position += length;
+                    WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
+                }
+
+                // copy the remaining data
+                int remainderLength = value.Length - bytesWritten;
+                value.Slice(bytesWritten, remainderLength).CopyTo(buffer.Slice(state.position, remainderLength));
+                state.position += remainderLength;
+            }
+        }
+        #endregion
+
+        #region Raw tag writing
+        /// <summary>
+        /// Encodes and writes a tag.
+        /// </summary>
+        public static void WriteTag(ref Span<byte> buffer, ref WriterInternalState state, int fieldNumber, WireFormat.WireType type)
+        {
+            WriteRawVarint32(ref buffer, ref state, WireFormat.MakeTag(fieldNumber, type));
+        }
+
+        /// <summary>
+        /// Writes an already-encoded tag.
+        /// </summary>
+        public static void WriteTag(ref Span<byte> buffer, ref WriterInternalState state, uint tag)
+        {
+            WriteRawVarint32(ref buffer, ref state, tag);
+        }
+
+        /// <summary>
+        /// Writes the given single-byte tag directly to the stream.
+        /// </summary>
+        public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1)
+        {
+            WriteRawByte(ref buffer, ref state, b1);
+        }
+
+        /// <summary>
+        /// Writes the given two-byte tag directly to the stream.
+        /// </summary>
+        public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2)
+        {
+            if (state.position + 2 > buffer.Length)
+            {
+                WriteRawTagSlowPath(ref buffer, ref state, b1, b2);
+            }
+            else
+            {
+                buffer[state.position++] = b1;
+                buffer[state.position++] = b2;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2)
+        {
+            WriteRawByte(ref buffer, ref state, b1);
+            WriteRawByte(ref buffer, ref state, b2);
+        }
+
+        /// <summary>
+        /// Writes the given three-byte tag directly to the stream.
+        /// </summary>
+        public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
+        {
+            if (state.position + 3 > buffer.Length)
+            {
+                WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3);
+            }
+            else
+            {
+                buffer[state.position++] = b1;
+                buffer[state.position++] = b2;
+                buffer[state.position++] = b3;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
+        {
+            WriteRawByte(ref buffer, ref state, b1);
+            WriteRawByte(ref buffer, ref state, b2);
+            WriteRawByte(ref buffer, ref state, b3);
+        }
+
+        /// <summary>
+        /// Writes the given four-byte tag directly to the stream.
+        /// </summary>
+        public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
+        {
+            if (state.position + 4 > buffer.Length)
+            {
+                WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4);
+            }
+            else
+            {
+                buffer[state.position++] = b1;
+                buffer[state.position++] = b2;
+                buffer[state.position++] = b3;
+                buffer[state.position++] = b4;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+
+        private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
+        {
+            WriteRawByte(ref buffer, ref state, b1);
+            WriteRawByte(ref buffer, ref state, b2);
+            WriteRawByte(ref buffer, ref state, b3);
+            WriteRawByte(ref buffer, ref state, b4);
+        }
+
+        /// <summary>
+        /// Writes the given five-byte tag directly to the stream.
+        /// </summary>
+        public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
+        {
+            if (state.position + 5 > buffer.Length)
+            {
+                WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4, b5);
+            }
+            else
+            {
+                buffer[state.position++] = b1;
+                buffer[state.position++] = b2;
+                buffer[state.position++] = b3;
+                buffer[state.position++] = b4;
+                buffer[state.position++] = b5;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
+        {
+            WriteRawByte(ref buffer, ref state, b1);
+            WriteRawByte(ref buffer, ref state, b2);
+            WriteRawByte(ref buffer, ref state, b3);
+            WriteRawByte(ref buffer, ref state, b4);
+            WriteRawByte(ref buffer, ref state, b5);
+        }
+        #endregion
+
+        /// <summary>
+        /// Encode a 32-bit value with ZigZag encoding.
+        /// </summary>
+        /// <remarks>
+        /// ZigZag encodes signed integers into values that can be efficiently
+        /// encoded with varint.  (Otherwise, negative values must be 
+        /// sign-extended to 64 bits to be varint encoded, thus always taking
+        /// 10 bytes on the wire.)
+        /// </remarks>
+        public static uint EncodeZigZag32(int n)
+        {
+            // Note:  the right-shift must be arithmetic
+            return (uint)((n << 1) ^ (n >> 31));
+        }
+
+        /// <summary>
+        /// Encode a 64-bit value with ZigZag encoding.
+        /// </summary>
+        /// <remarks>
+        /// ZigZag encodes signed integers into values that can be efficiently
+        /// encoded with varint.  (Otherwise, negative values must be 
+        /// sign-extended to 64 bits to be varint encoded, thus always taking
+        /// 10 bytes on the wire.)
+        /// </remarks>
+        public static ulong EncodeZigZag64(long n)
+        {
+            return (ulong)((n << 1) ^ (n >> 63));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/WritingPrimitivesMessages.cs b/Libs/Google.Protobuf/WritingPrimitivesMessages.cs
new file mode 100644
index 0000000..3b4b4b7
--- /dev/null
+++ b/Libs/Google.Protobuf/WritingPrimitivesMessages.cs
@@ -0,0 +1,112 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices.ComTypes;
+using System.Security;
+
+namespace LC.Google.Protobuf
+{
+    /// <summary>
+    /// Writing messages / groups.
+    /// </summary>
+    [SecuritySafeCritical]
+    internal static class WritingPrimitivesMessages
+    {
+        /// <summary>
+        /// Writes a message, without a tag.
+        /// The data is length-prefixed.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void WriteMessage(ref WriteContext ctx, IMessage value)
+        {
+            WritingPrimitives.WriteLength(ref ctx.buffer, ref ctx.state, value.CalculateSize());
+            WriteRawMessage(ref ctx, value);
+        }
+
+        /// <summary>
+        /// Writes a group, without a tag.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void WriteGroup(ref WriteContext ctx, IMessage value)
+        {
+            WriteRawMessage(ref ctx, value);
+        }
+
+        /// <summary>
+        /// Writes a message, without a tag.
+        /// Message will be written without a length prefix.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void WriteRawMessage(ref WriteContext ctx, IMessage message)
+        {
+            if (message is IBufferMessage bufferMessage)
+            {
+                bufferMessage.InternalWriteTo(ref ctx);
+            }
+            else
+            {
+                // If we reached here, it means we've ran into a nested message with older generated code
+                // which doesn't provide the InternalWriteTo method that takes a WriteContext.
+                // With a slight performance overhead, we can still serialize this message just fine,
+                // but we need to find the original CodedOutputStream instance that initiated this
+                // serialization process and make sure its internal state is up to date.
+                // Note that this performance overhead is not very high (basically copying contents of a struct)
+                // and it will only be incurred in case the application mixes older and newer generated code.
+                // Regenerating the code from .proto files will remove this overhead because it will
+                // generate the InternalWriteTo method we need.
+
+                if (ctx.state.CodedOutputStream == null)
+                {
+                    // This can only happen when the serialization started without providing a CodedOutputStream instance
+                    // (e.g. WriteContext was created directly from a IBufferWriter).
+                    // That also means that one of the new parsing APIs was used at the top level
+                    // and in such case it is reasonable to require that all the nested message provide
+                    // up-to-date generated code with WriteContext support (and fail otherwise).
+                    throw new InvalidProtocolBufferException($"Message {message.GetType().Name} doesn't provide the generated method that enables WriteContext-based serialization. You might need to regenerate the generated protobuf code.");
+                }
+
+                ctx.CopyStateTo(ctx.state.CodedOutputStream);
+                try
+                {
+                    // fallback parse using the CodedOutputStream that started current serialization tree
+                    message.WriteTo(ctx.state.CodedOutputStream);
+                }
+                finally
+                {
+                    ctx.LoadStateFrom(ctx.state.CodedOutputStream);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Google.Protobuf/keys/Google.Protobuf.public.snk b/Libs/Google.Protobuf/keys/Google.Protobuf.public.snk
new file mode 100644
index 0000000..59cd369
Binary files /dev/null and b/Libs/Google.Protobuf/keys/Google.Protobuf.public.snk differ
diff --git a/Libs/Google.Protobuf/keys/Google.Protobuf.snk b/Libs/Google.Protobuf/keys/Google.Protobuf.snk
new file mode 100644
index 0000000..7515443
Binary files /dev/null and b/Libs/Google.Protobuf/keys/Google.Protobuf.snk differ
diff --git a/Libs/Google.Protobuf/keys/README.md b/Libs/Google.Protobuf/keys/README.md
new file mode 100644
index 0000000..ede6735
--- /dev/null
+++ b/Libs/Google.Protobuf/keys/README.md
@@ -0,0 +1,9 @@
+Contents
+--------
+
+- Google.Protobuf.public.snk:
+  Public key to verify strong name of Google.Protobuf assemblies.
+- Google.Protobuf.snk:
+  Signing key to provide strong name of Google.Protobuf assemblies.
+  As per [Microsoft guidance](https://msdn.microsoft.com/en-us/library/wd40t7ad(v=vs.110).aspx)
+  signing key should be checked into the repository.
diff --git a/Libs/Newtonsoft.Json/Bson/BsonBinaryType.cs b/Libs/Newtonsoft.Json/Bson/BsonBinaryType.cs
new file mode 100644
index 0000000..8c37edf
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Bson/BsonBinaryType.cs
@@ -0,0 +1,46 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Bson
+{
+    internal enum BsonBinaryType : byte
+    {
+        Binary = 0x00,
+        Function = 0x01,
+
+        [Obsolete("This type has been deprecated in the BSON specification. Use Binary instead.")]
+        BinaryOld = 0x02,
+
+        [Obsolete("This type has been deprecated in the BSON specification. Use Uuid instead.")]
+        UuidOld = 0x03,
+        Uuid = 0x04,
+        Md5 = 0x05,
+        UserDefined = 0x80
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Bson/BsonBinaryWriter.cs b/Libs/Newtonsoft.Json/Bson/BsonBinaryWriter.cs
new file mode 100644
index 0000000..2617ff6
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Bson/BsonBinaryWriter.cs
@@ -0,0 +1,330 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using LC.Newtonsoft.Json.Utilities;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Bson
+{
+    internal class BsonBinaryWriter
+    {
+        private static readonly Encoding Encoding = new UTF8Encoding(false);
+
+        private readonly BinaryWriter _writer;
+
+        private byte[] _largeByteBuffer;
+
+        public DateTimeKind DateTimeKindHandling { get; set; }
+
+        public BsonBinaryWriter(BinaryWriter writer)
+        {
+            DateTimeKindHandling = DateTimeKind.Utc;
+            _writer = writer;
+        }
+
+        public void Flush()
+        {
+            _writer.Flush();
+        }
+
+        public void Close()
+        {
+#if HAVE_STREAM_READER_WRITER_CLOSE
+            _writer.Close();
+#else
+            _writer.Dispose();
+#endif
+        }
+
+        public void WriteToken(BsonToken t)
+        {
+            CalculateSize(t);
+            WriteTokenInternal(t);
+        }
+
+        private void WriteTokenInternal(BsonToken t)
+        {
+            switch (t.Type)
+            {
+                case BsonType.Object:
+                {
+                    BsonObject value = (BsonObject)t;
+                    _writer.Write(value.CalculatedSize);
+                    foreach (BsonProperty property in value)
+                    {
+                        _writer.Write((sbyte)property.Value.Type);
+                        WriteString((string)property.Name.Value, property.Name.ByteCount, null);
+                        WriteTokenInternal(property.Value);
+                    }
+                    _writer.Write((byte)0);
+                }
+                    break;
+                case BsonType.Array:
+                {
+                    BsonArray value = (BsonArray)t;
+                    _writer.Write(value.CalculatedSize);
+                    ulong index = 0;
+                    foreach (BsonToken c in value)
+                    {
+                        _writer.Write((sbyte)c.Type);
+                        WriteString(index.ToString(CultureInfo.InvariantCulture), MathUtils.IntLength(index), null);
+                        WriteTokenInternal(c);
+                        index++;
+                    }
+                    _writer.Write((byte)0);
+                }
+                    break;
+                case BsonType.Integer:
+                {
+                    BsonValue value = (BsonValue)t;
+                    _writer.Write(Convert.ToInt32(value.Value, CultureInfo.InvariantCulture));
+                }
+                    break;
+                case BsonType.Long:
+                {
+                    BsonValue value = (BsonValue)t;
+                    _writer.Write(Convert.ToInt64(value.Value, CultureInfo.InvariantCulture));
+                }
+                    break;
+                case BsonType.Number:
+                {
+                    BsonValue value = (BsonValue)t;
+                    _writer.Write(Convert.ToDouble(value.Value, CultureInfo.InvariantCulture));
+                }
+                    break;
+                case BsonType.String:
+                {
+                    BsonString value = (BsonString)t;
+                    WriteString((string)value.Value, value.ByteCount, value.CalculatedSize - 4);
+                }
+                    break;
+                case BsonType.Boolean:
+                    _writer.Write(t == BsonBoolean.True);
+                    break;
+                case BsonType.Null:
+                case BsonType.Undefined:
+                    break;
+                case BsonType.Date:
+                {
+                    BsonValue value = (BsonValue)t;
+
+                    long ticks = 0;
+
+                    if (value.Value is DateTime dateTime)
+                    {
+                        if (DateTimeKindHandling == DateTimeKind.Utc)
+                        {
+                            dateTime = dateTime.ToUniversalTime();
+                        }
+                        else if (DateTimeKindHandling == DateTimeKind.Local)
+                        {
+                            dateTime = dateTime.ToLocalTime();
+                        }
+
+                        ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(dateTime, false);
+                    }
+#if HAVE_DATE_TIME_OFFSET
+                    else
+                    {
+                        DateTimeOffset dateTimeOffset = (DateTimeOffset)value.Value;
+                        ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(dateTimeOffset.UtcDateTime, dateTimeOffset.Offset);
+                    }
+#endif
+
+                    _writer.Write(ticks);
+                }
+                    break;
+                case BsonType.Binary:
+                {
+                    BsonBinary value = (BsonBinary)t;
+
+                    byte[] data = (byte[])value.Value;
+                    _writer.Write(data.Length);
+                    _writer.Write((byte)value.BinaryType);
+                    _writer.Write(data);
+                }
+                    break;
+                case BsonType.Oid:
+                {
+                    BsonValue value = (BsonValue)t;
+
+                    byte[] data = (byte[])value.Value;
+                    _writer.Write(data);
+                }
+                    break;
+                case BsonType.Regex:
+                {
+                    BsonRegex value = (BsonRegex)t;
+
+                    WriteString((string)value.Pattern.Value, value.Pattern.ByteCount, null);
+                    WriteString((string)value.Options.Value, value.Options.ByteCount, null);
+                }
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(t), "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
+            }
+        }
+
+        private void WriteString(string s, int byteCount, int? calculatedlengthPrefix)
+        {
+            if (calculatedlengthPrefix != null)
+            {
+                _writer.Write(calculatedlengthPrefix.GetValueOrDefault());
+            }
+
+            WriteUtf8Bytes(s, byteCount);
+
+            _writer.Write((byte)0);
+        }
+
+        public void WriteUtf8Bytes(string s, int byteCount)
+        {
+            if (s != null)
+            {
+                if (byteCount <= 256)
+                {
+                    if (_largeByteBuffer == null)
+                    {
+                        _largeByteBuffer = new byte[256];
+                    }
+
+                    Encoding.GetBytes(s, 0, s.Length, _largeByteBuffer, 0);
+                    _writer.Write(_largeByteBuffer, 0, byteCount);
+                }
+                else
+                {
+                    byte[] bytes = Encoding.GetBytes(s);
+                    _writer.Write(bytes);
+                }
+            }
+        }
+
+        private int CalculateSize(int stringByteCount)
+        {
+            return stringByteCount + 1;
+        }
+
+        private int CalculateSizeWithLength(int stringByteCount, bool includeSize)
+        {
+            int baseSize = (includeSize)
+                ? 5 // size bytes + terminator
+                : 1; // terminator
+
+            return baseSize + stringByteCount;
+        }
+
+        private int CalculateSize(BsonToken t)
+        {
+            switch (t.Type)
+            {
+                case BsonType.Object:
+                {
+                    BsonObject value = (BsonObject)t;
+
+                    int bases = 4;
+                    foreach (BsonProperty p in value)
+                    {
+                        int size = 1;
+                        size += CalculateSize(p.Name);
+                        size += CalculateSize(p.Value);
+
+                        bases += size;
+                    }
+                    bases += 1;
+                    value.CalculatedSize = bases;
+                    return bases;
+                }
+                case BsonType.Array:
+                {
+                    BsonArray value = (BsonArray)t;
+
+                    int size = 4;
+                    ulong index = 0;
+                    foreach (BsonToken c in value)
+                    {
+                        size += 1;
+                        size += CalculateSize(MathUtils.IntLength(index));
+                        size += CalculateSize(c);
+                        index++;
+                    }
+                    size += 1;
+                    value.CalculatedSize = size;
+
+                    return value.CalculatedSize;
+                }
+                case BsonType.Integer:
+                    return 4;
+                case BsonType.Long:
+                    return 8;
+                case BsonType.Number:
+                    return 8;
+                case BsonType.String:
+                {
+                    BsonString value = (BsonString)t;
+                    string s = (string)value.Value;
+                    value.ByteCount = (s != null) ? Encoding.GetByteCount(s) : 0;
+                    value.CalculatedSize = CalculateSizeWithLength(value.ByteCount, value.IncludeLength);
+
+                    return value.CalculatedSize;
+                }
+                case BsonType.Boolean:
+                    return 1;
+                case BsonType.Null:
+                case BsonType.Undefined:
+                    return 0;
+                case BsonType.Date:
+                    return 8;
+                case BsonType.Binary:
+                {
+                    BsonBinary value = (BsonBinary)t;
+
+                    byte[] data = (byte[])value.Value;
+                    value.CalculatedSize = 4 + 1 + data.Length;
+
+                    return value.CalculatedSize;
+                }
+                case BsonType.Oid:
+                    return 12;
+                case BsonType.Regex:
+                {
+                    BsonRegex value = (BsonRegex)t;
+                    int size = 0;
+                    size += CalculateSize(value.Pattern);
+                    size += CalculateSize(value.Options);
+                    value.CalculatedSize = size;
+
+                    return value.CalculatedSize;
+                }
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(t), "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Bson/BsonObjectId.cs b/Libs/Newtonsoft.Json/Bson/BsonObjectId.cs
new file mode 100644
index 0000000..4244cb2
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Bson/BsonObjectId.cs
@@ -0,0 +1,60 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Utilities;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Bson
+{
+    /// <summary>
+    /// Represents a BSON Oid (object id).
+    /// </summary>
+    [Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
+    public class BsonObjectId
+    {
+        /// <summary>
+        /// Gets or sets the value of the Oid.
+        /// </summary>
+        /// <value>The value of the Oid.</value>
+        public byte[] Value { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonObjectId"/> class.
+        /// </summary>
+        /// <param name="value">The Oid value.</param>
+        public BsonObjectId(byte[] value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            if (value.Length != 12)
+            {
+                throw new ArgumentException("An ObjectId must be 12 bytes", nameof(value));
+            }
+
+            Value = value;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Bson/BsonReader.cs b/Libs/Newtonsoft.Json/Bson/BsonReader.cs
new file mode 100644
index 0000000..3790513
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Bson/BsonReader.cs
@@ -0,0 +1,836 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using System.IO;
+using LC.Newtonsoft.Json.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+using LC.Newtonsoft.Json.Linq;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Bson
+{
+    /// <summary>
+    /// Represents a reader that provides fast, non-cached, forward-only access to serialized BSON data.
+    /// </summary>
+    [Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
+    public class BsonReader : JsonReader
+    {
+        private const int MaxCharBytesSize = 128;
+        private static readonly byte[] SeqRange1 = new byte[] { 0, 127 }; // range of 1-byte sequence
+        private static readonly byte[] SeqRange2 = new byte[] { 194, 223 }; // range of 2-byte sequence
+        private static readonly byte[] SeqRange3 = new byte[] { 224, 239 }; // range of 3-byte sequence
+        private static readonly byte[] SeqRange4 = new byte[] { 240, 244 }; // range of 4-byte sequence
+
+        private readonly BinaryReader _reader;
+        private readonly List<ContainerContext> _stack;
+
+        private byte[] _byteBuffer;
+        private char[] _charBuffer;
+
+        private BsonType _currentElementType;
+        private BsonReaderState _bsonReaderState;
+        private ContainerContext _currentContext;
+
+        private bool _readRootValueAsArray;
+        private bool _jsonNet35BinaryCompatibility;
+        private DateTimeKind _dateTimeKindHandling;
+
+        private enum BsonReaderState
+        {
+            Normal = 0,
+            ReferenceStart = 1,
+            ReferenceRef = 2,
+            ReferenceId = 3,
+            CodeWScopeStart = 4,
+            CodeWScopeCode = 5,
+            CodeWScopeScope = 6,
+            CodeWScopeScopeObject = 7,
+            CodeWScopeScopeEnd = 8
+        }
+
+        private class ContainerContext
+        {
+            public readonly BsonType Type;
+            public int Length;
+            public int Position;
+
+            public ContainerContext(BsonType type)
+            {
+                Type = type;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether binary data reading should be compatible with incorrect Json.NET 3.5 written binary.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if binary data reading will be compatible with incorrect Json.NET 3.5 written binary; otherwise, <c>false</c>.
+        /// </value>
+        [Obsolete("JsonNet35BinaryCompatibility will be removed in a future version of Json.NET.")]
+        public bool JsonNet35BinaryCompatibility
+        {
+            get => _jsonNet35BinaryCompatibility;
+            set => _jsonNet35BinaryCompatibility = value;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the root object will be read as a JSON array.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if the root object will be read as a JSON array; otherwise, <c>false</c>.
+        /// </value>
+        public bool ReadRootValueAsArray
+        {
+            get => _readRootValueAsArray;
+            set => _readRootValueAsArray = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="DateTimeKind" /> used when reading <see cref="DateTime"/> values from BSON.
+        /// </summary>
+        /// <value>The <see cref="DateTimeKind" /> used when reading <see cref="DateTime"/> values from BSON.</value>
+        public DateTimeKind DateTimeKindHandling
+        {
+            get => _dateTimeKindHandling;
+            set => _dateTimeKindHandling = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonReader"/> class.
+        /// </summary>
+        /// <param name="stream">The <see cref="Stream"/> containing the BSON data to read.</param>
+        public BsonReader(Stream stream)
+            : this(stream, false, DateTimeKind.Local)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonReader"/> class.
+        /// </summary>
+        /// <param name="reader">The <see cref="BinaryReader"/> containing the BSON data to read.</param>
+        public BsonReader(BinaryReader reader)
+            : this(reader, false, DateTimeKind.Local)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonReader"/> class.
+        /// </summary>
+        /// <param name="stream">The <see cref="Stream"/> containing the BSON data to read.</param>
+        /// <param name="readRootValueAsArray">if set to <c>true</c> the root object will be read as a JSON array.</param>
+        /// <param name="dateTimeKindHandling">The <see cref="DateTimeKind" /> used when reading <see cref="DateTime"/> values from BSON.</param>
+        public BsonReader(Stream stream, bool readRootValueAsArray, DateTimeKind dateTimeKindHandling)
+        {
+            ValidationUtils.ArgumentNotNull(stream, nameof(stream));
+            _reader = new BinaryReader(stream);
+            _stack = new List<ContainerContext>();
+            _readRootValueAsArray = readRootValueAsArray;
+            _dateTimeKindHandling = dateTimeKindHandling;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonReader"/> class.
+        /// </summary>
+        /// <param name="reader">The <see cref="BinaryReader"/> containing the BSON data to read.</param>
+        /// <param name="readRootValueAsArray">if set to <c>true</c> the root object will be read as a JSON array.</param>
+        /// <param name="dateTimeKindHandling">The <see cref="DateTimeKind" /> used when reading <see cref="DateTime"/> values from BSON.</param>
+        public BsonReader(BinaryReader reader, bool readRootValueAsArray, DateTimeKind dateTimeKindHandling)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+            _reader = reader;
+            _stack = new List<ContainerContext>();
+            _readRootValueAsArray = readRootValueAsArray;
+            _dateTimeKindHandling = dateTimeKindHandling;
+        }
+
+        private string ReadElement()
+        {
+            _currentElementType = ReadType();
+            string elementName = ReadString();
+            return elementName;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="Stream"/>.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the next token was read successfully; <c>false</c> if there are no more tokens to read.
+        /// </returns>
+        public override bool Read()
+        {
+            try
+            {
+                bool success;
+
+                switch (_bsonReaderState)
+                {
+                    case BsonReaderState.Normal:
+                        success = ReadNormal();
+                        break;
+                    case BsonReaderState.ReferenceStart:
+                    case BsonReaderState.ReferenceRef:
+                    case BsonReaderState.ReferenceId:
+                        success = ReadReference();
+                        break;
+                    case BsonReaderState.CodeWScopeStart:
+                    case BsonReaderState.CodeWScopeCode:
+                    case BsonReaderState.CodeWScopeScope:
+                    case BsonReaderState.CodeWScopeScopeObject:
+                    case BsonReaderState.CodeWScopeScopeEnd:
+                        success = ReadCodeWScope();
+                        break;
+                    default:
+                        throw JsonReaderException.Create(this, "Unexpected state: {0}".FormatWith(CultureInfo.InvariantCulture, _bsonReaderState));
+                }
+
+                if (!success)
+                {
+                    SetToken(JsonToken.None);
+                    return false;
+                }
+
+                return true;
+            }
+            catch (EndOfStreamException)
+            {
+                SetToken(JsonToken.None);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Changes the reader's state to <see cref="JsonReader.State.Closed"/>.
+        /// If <see cref="JsonReader.CloseInput"/> is set to <c>true</c>, the underlying <see cref="Stream"/> is also closed.
+        /// </summary>
+        public override void Close()
+        {
+            base.Close();
+
+            if (CloseInput)
+            {
+#if HAVE_STREAM_READER_WRITER_CLOSE
+                _reader?.Close();
+#else
+                _reader?.Dispose();
+#endif
+            }
+        }
+
+        private bool ReadCodeWScope()
+        {
+            switch (_bsonReaderState)
+            {
+                case BsonReaderState.CodeWScopeStart:
+                    SetToken(JsonToken.PropertyName, "$code");
+                    _bsonReaderState = BsonReaderState.CodeWScopeCode;
+                    return true;
+                case BsonReaderState.CodeWScopeCode:
+                    // total CodeWScope size - not used
+                    ReadInt32();
+
+                    SetToken(JsonToken.String, ReadLengthString());
+                    _bsonReaderState = BsonReaderState.CodeWScopeScope;
+                    return true;
+                case BsonReaderState.CodeWScopeScope:
+                    if (CurrentState == State.PostValue)
+                    {
+                        SetToken(JsonToken.PropertyName, "$scope");
+                        return true;
+                    }
+                    else
+                    {
+                        SetToken(JsonToken.StartObject);
+                        _bsonReaderState = BsonReaderState.CodeWScopeScopeObject;
+
+                        ContainerContext newContext = new ContainerContext(BsonType.Object);
+                        PushContext(newContext);
+                        newContext.Length = ReadInt32();
+
+                        return true;
+                    }
+                case BsonReaderState.CodeWScopeScopeObject:
+                    bool result = ReadNormal();
+                    if (result && TokenType == JsonToken.EndObject)
+                    {
+                        _bsonReaderState = BsonReaderState.CodeWScopeScopeEnd;
+                    }
+
+                    return result;
+                case BsonReaderState.CodeWScopeScopeEnd:
+                    SetToken(JsonToken.EndObject);
+                    _bsonReaderState = BsonReaderState.Normal;
+                    return true;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        private bool ReadReference()
+        {
+            switch (CurrentState)
+            {
+                case State.ObjectStart:
+                {
+                    SetToken(JsonToken.PropertyName, JsonTypeReflector.RefPropertyName);
+                    _bsonReaderState = BsonReaderState.ReferenceRef;
+                    return true;
+                }
+                case State.Property:
+                {
+                    if (_bsonReaderState == BsonReaderState.ReferenceRef)
+                    {
+                        SetToken(JsonToken.String, ReadLengthString());
+                        return true;
+                    }
+                    else if (_bsonReaderState == BsonReaderState.ReferenceId)
+                    {
+                        SetToken(JsonToken.Bytes, ReadBytes(12));
+                        return true;
+                    }
+                    else
+                    {
+                        throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + _bsonReaderState);
+                    }
+                }
+                case State.PostValue:
+                {
+                    if (_bsonReaderState == BsonReaderState.ReferenceRef)
+                    {
+                        SetToken(JsonToken.PropertyName, JsonTypeReflector.IdPropertyName);
+                        _bsonReaderState = BsonReaderState.ReferenceId;
+                        return true;
+                    }
+                    else if (_bsonReaderState == BsonReaderState.ReferenceId)
+                    {
+                        SetToken(JsonToken.EndObject);
+                        _bsonReaderState = BsonReaderState.Normal;
+                        return true;
+                    }
+                    else
+                    {
+                        throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + _bsonReaderState);
+                    }
+                }
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + CurrentState);
+            }
+        }
+
+        private bool ReadNormal()
+        {
+            switch (CurrentState)
+            {
+                case State.Start:
+                {
+                    JsonToken token = (!_readRootValueAsArray) ? JsonToken.StartObject : JsonToken.StartArray;
+                    BsonType type = (!_readRootValueAsArray) ? BsonType.Object : BsonType.Array;
+
+                    SetToken(token);
+                    ContainerContext newContext = new ContainerContext(type);
+                    PushContext(newContext);
+                    newContext.Length = ReadInt32();
+                    return true;
+                }
+                case State.Complete:
+                case State.Closed:
+                    return false;
+                case State.Property:
+                {
+                    ReadType(_currentElementType);
+                    return true;
+                }
+                case State.ObjectStart:
+                case State.ArrayStart:
+                case State.PostValue:
+                    ContainerContext context = _currentContext;
+                    if (context == null)
+                    {
+                        if (SupportMultipleContent)
+                        {
+                            goto case State.Start;
+                        }
+
+                        return false;
+                    }
+
+                    int lengthMinusEnd = context.Length - 1;
+
+                    if (context.Position < lengthMinusEnd)
+                    {
+                        if (context.Type == BsonType.Array)
+                        {
+                            ReadElement();
+                            ReadType(_currentElementType);
+                            return true;
+                        }
+                        else
+                        {
+                            SetToken(JsonToken.PropertyName, ReadElement());
+                            return true;
+                        }
+                    }
+                    else if (context.Position == lengthMinusEnd)
+                    {
+                        if (ReadByte() != 0)
+                        {
+                            throw JsonReaderException.Create(this, "Unexpected end of object byte value.");
+                        }
+
+                        PopContext();
+                        if (_currentContext != null)
+                        {
+                            MovePosition(context.Length);
+                        }
+
+                        JsonToken endToken = (context.Type == BsonType.Object) ? JsonToken.EndObject : JsonToken.EndArray;
+                        SetToken(endToken);
+                        return true;
+                    }
+                    else
+                    {
+                        throw JsonReaderException.Create(this, "Read past end of current container context.");
+                    }
+                case State.ConstructorStart:
+                    break;
+                case State.Constructor:
+                    break;
+                case State.Error:
+                    break;
+                case State.Finished:
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            return false;
+        }
+
+        private void PopContext()
+        {
+            _stack.RemoveAt(_stack.Count - 1);
+            if (_stack.Count == 0)
+            {
+                _currentContext = null;
+            }
+            else
+            {
+                _currentContext = _stack[_stack.Count - 1];
+            }
+        }
+
+        private void PushContext(ContainerContext newContext)
+        {
+            _stack.Add(newContext);
+            _currentContext = newContext;
+        }
+
+        private byte ReadByte()
+        {
+            MovePosition(1);
+            return _reader.ReadByte();
+        }
+
+        private void ReadType(BsonType type)
+        {
+            switch (type)
+            {
+                case BsonType.Number:
+                    double d = ReadDouble();
+
+                    if (_floatParseHandling == FloatParseHandling.Decimal)
+                    {
+                        SetToken(JsonToken.Float, Convert.ToDecimal(d, CultureInfo.InvariantCulture));
+                    }
+                    else
+                    {
+                        SetToken(JsonToken.Float, d);
+                    }
+                    break;
+                case BsonType.String:
+                case BsonType.Symbol:
+                    SetToken(JsonToken.String, ReadLengthString());
+                    break;
+                case BsonType.Object:
+                {
+                    SetToken(JsonToken.StartObject);
+
+                    ContainerContext newContext = new ContainerContext(BsonType.Object);
+                    PushContext(newContext);
+                    newContext.Length = ReadInt32();
+                    break;
+                }
+                case BsonType.Array:
+                {
+                    SetToken(JsonToken.StartArray);
+
+                    ContainerContext newContext = new ContainerContext(BsonType.Array);
+                    PushContext(newContext);
+                    newContext.Length = ReadInt32();
+                    break;
+                }
+                case BsonType.Binary:
+                    BsonBinaryType binaryType;
+                    byte[] data = ReadBinary(out binaryType);
+
+                    object value = (binaryType != BsonBinaryType.Uuid)
+                        ? data
+                        : (object)new Guid(data);
+
+                    SetToken(JsonToken.Bytes, value);
+                    break;
+                case BsonType.Undefined:
+                    SetToken(JsonToken.Undefined);
+                    break;
+                case BsonType.Oid:
+                    byte[] oid = ReadBytes(12);
+                    SetToken(JsonToken.Bytes, oid);
+                    break;
+                case BsonType.Boolean:
+                    bool b = Convert.ToBoolean(ReadByte());
+                    SetToken(JsonToken.Boolean, b);
+                    break;
+                case BsonType.Date:
+                    long ticks = ReadInt64();
+                    DateTime utcDateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);
+
+                    DateTime dateTime;
+                    switch (DateTimeKindHandling)
+                    {
+                        case DateTimeKind.Unspecified:
+                            dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
+                            break;
+                        case DateTimeKind.Local:
+                            dateTime = utcDateTime.ToLocalTime();
+                            break;
+                        default:
+                            dateTime = utcDateTime;
+                            break;
+                    }
+
+                    SetToken(JsonToken.Date, dateTime);
+                    break;
+                case BsonType.Null:
+                    SetToken(JsonToken.Null);
+                    break;
+                case BsonType.Regex:
+                    string expression = ReadString();
+                    string modifiers = ReadString();
+
+                    string regex = @"/" + expression + @"/" + modifiers;
+                    SetToken(JsonToken.String, regex);
+                    break;
+                case BsonType.Reference:
+                    SetToken(JsonToken.StartObject);
+                    _bsonReaderState = BsonReaderState.ReferenceStart;
+                    break;
+                case BsonType.Code:
+                    SetToken(JsonToken.String, ReadLengthString());
+                    break;
+                case BsonType.CodeWScope:
+                    SetToken(JsonToken.StartObject);
+                    _bsonReaderState = BsonReaderState.CodeWScopeStart;
+                    break;
+                case BsonType.Integer:
+                    SetToken(JsonToken.Integer, (long)ReadInt32());
+                    break;
+                case BsonType.TimeStamp:
+                case BsonType.Long:
+                    SetToken(JsonToken.Integer, ReadInt64());
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(type), "Unexpected BsonType value: " + type);
+            }
+        }
+
+        private byte[] ReadBinary(out BsonBinaryType binaryType)
+        {
+            int dataLength = ReadInt32();
+
+            binaryType = (BsonBinaryType)ReadByte();
+
+#pragma warning disable 612,618
+            // the old binary type has the data length repeated in the data for some reason
+            if (binaryType == BsonBinaryType.BinaryOld && !_jsonNet35BinaryCompatibility)
+            {
+                dataLength = ReadInt32();
+            }
+#pragma warning restore 612,618
+
+            return ReadBytes(dataLength);
+        }
+
+        private string ReadString()
+        {
+            EnsureBuffers();
+
+            StringBuilder builder = null;
+
+            int totalBytesRead = 0;
+            // used in case of left over multibyte characters in the buffer
+            int offset = 0;
+            while (true)
+            {
+                int count = offset;
+                byte b;
+                while (count < MaxCharBytesSize && (b = _reader.ReadByte()) > 0)
+                {
+                    _byteBuffer[count++] = b;
+                }
+                int byteCount = count - offset;
+                totalBytesRead += byteCount;
+
+                if (count < MaxCharBytesSize && builder == null)
+                {
+                    // pref optimization to avoid reading into a string builder
+                    // if string is smaller than the buffer then return it directly
+                    int length = Encoding.UTF8.GetChars(_byteBuffer, 0, byteCount, _charBuffer, 0);
+
+                    MovePosition(totalBytesRead + 1);
+                    return new string(_charBuffer, 0, length);
+                }
+                else
+                {
+                    // calculate the index of the end of the last full character in the buffer
+                    int lastFullCharStop = GetLastFullCharStop(count - 1);
+
+                    int charCount = Encoding.UTF8.GetChars(_byteBuffer, 0, lastFullCharStop + 1, _charBuffer, 0);
+
+                    if (builder == null)
+                    {
+                        builder = new StringBuilder(MaxCharBytesSize * 2);
+                    }
+
+                    builder.Append(_charBuffer, 0, charCount);
+
+                    if (lastFullCharStop < byteCount - 1)
+                    {
+                        offset = byteCount - lastFullCharStop - 1;
+                        // copy left over multi byte characters to beginning of buffer for next iteration
+                        Array.Copy(_byteBuffer, lastFullCharStop + 1, _byteBuffer, 0, offset);
+                    }
+                    else
+                    {
+                        // reached end of string
+                        if (count < MaxCharBytesSize)
+                        {
+                            MovePosition(totalBytesRead + 1);
+                            return builder.ToString();
+                        }
+
+                        offset = 0;
+                    }
+                }
+            }
+        }
+
+        private string ReadLengthString()
+        {
+            int length = ReadInt32();
+
+            MovePosition(length);
+
+            string s = GetString(length - 1);
+            _reader.ReadByte();
+
+            return s;
+        }
+
+        private string GetString(int length)
+        {
+            if (length == 0)
+            {
+                return string.Empty;
+            }
+
+            EnsureBuffers();
+
+            StringBuilder builder = null;
+
+            int totalBytesRead = 0;
+
+            // used in case of left over multibyte characters in the buffer
+            int offset = 0;
+            do
+            {
+                int count = ((length - totalBytesRead) > MaxCharBytesSize - offset)
+                    ? MaxCharBytesSize - offset
+                    : length - totalBytesRead;
+
+                int byteCount = _reader.Read(_byteBuffer, offset, count);
+
+                if (byteCount == 0)
+                {
+                    throw new EndOfStreamException("Unable to read beyond the end of the stream.");
+                }
+
+                totalBytesRead += byteCount;
+
+                // Above, byteCount is how many bytes we read this time.
+                // Below, byteCount is how many bytes are in the _byteBuffer.
+                byteCount += offset;
+
+                if (byteCount == length)
+                {
+                    // pref optimization to avoid reading into a string builder
+                    // first iteration and all bytes read then return string directly
+                    int charCount = Encoding.UTF8.GetChars(_byteBuffer, 0, byteCount, _charBuffer, 0);
+                    return new string(_charBuffer, 0, charCount);
+                }
+                else
+                {
+                    int lastFullCharStop = GetLastFullCharStop(byteCount - 1);
+
+                    if (builder == null)
+                    {
+                        builder = new StringBuilder(length);
+                    }
+
+                    int charCount = Encoding.UTF8.GetChars(_byteBuffer, 0, lastFullCharStop + 1, _charBuffer, 0);
+                    builder.Append(_charBuffer, 0, charCount);
+
+                    if (lastFullCharStop < byteCount - 1)
+                    {
+                        offset = byteCount - lastFullCharStop - 1;
+                        // copy left over multi byte characters to beginning of buffer for next iteration
+                        Array.Copy(_byteBuffer, lastFullCharStop + 1, _byteBuffer, 0, offset);
+                    }
+                    else
+                    {
+                        offset = 0;
+                    }
+                }
+            } while (totalBytesRead < length);
+
+            return builder.ToString();
+        }
+
+        private int GetLastFullCharStop(int start)
+        {
+            int lookbackPos = start;
+            int bis = 0;
+            while (lookbackPos >= 0)
+            {
+                bis = BytesInSequence(_byteBuffer[lookbackPos]);
+                if (bis == 0)
+                {
+                    lookbackPos--;
+                    continue;
+                }
+                else if (bis == 1)
+                {
+                    break;
+                }
+                else
+                {
+                    lookbackPos--;
+                    break;
+                }
+            }
+            if (bis == start - lookbackPos)
+            {
+                //Full character.
+                return start;
+            }
+            else
+            {
+                return lookbackPos;
+            }
+        }
+
+        private int BytesInSequence(byte b)
+        {
+            if (b <= SeqRange1[1])
+            {
+                return 1;
+            }
+            if (b >= SeqRange2[0] && b <= SeqRange2[1])
+            {
+                return 2;
+            }
+            if (b >= SeqRange3[0] && b <= SeqRange3[1])
+            {
+                return 3;
+            }
+            if (b >= SeqRange4[0] && b <= SeqRange4[1])
+            {
+                return 4;
+            }
+            return 0;
+        }
+
+        private void EnsureBuffers()
+        {
+            if (_byteBuffer == null)
+            {
+                _byteBuffer = new byte[MaxCharBytesSize];
+            }
+            if (_charBuffer == null)
+            {
+                int charBufferSize = Encoding.UTF8.GetMaxCharCount(MaxCharBytesSize);
+                _charBuffer = new char[charBufferSize];
+            }
+        }
+
+        private double ReadDouble()
+        {
+            MovePosition(8);
+            return _reader.ReadDouble();
+        }
+
+        private int ReadInt32()
+        {
+            MovePosition(4);
+            return _reader.ReadInt32();
+        }
+
+        private long ReadInt64()
+        {
+            MovePosition(8);
+            return _reader.ReadInt64();
+        }
+
+        private BsonType ReadType()
+        {
+            MovePosition(1);
+            return (BsonType)_reader.ReadSByte();
+        }
+
+        private void MovePosition(int count)
+        {
+            _currentContext.Position += count;
+        }
+
+        private byte[] ReadBytes(int count)
+        {
+            MovePosition(count);
+            return _reader.ReadBytes(count);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Bson/BsonToken.cs b/Libs/Newtonsoft.Json/Bson/BsonToken.cs
new file mode 100644
index 0000000..73e5014
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Bson/BsonToken.cs
@@ -0,0 +1,168 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System.Collections;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Bson
+{
+    internal abstract class BsonToken
+    {
+        public abstract BsonType Type { get; }
+        public BsonToken Parent { get; set; }
+        public int CalculatedSize { get; set; }
+    }
+
+    internal class BsonObject : BsonToken, IEnumerable<BsonProperty>
+    {
+        private readonly List<BsonProperty> _children = new List<BsonProperty>();
+
+        public void Add(string name, BsonToken token)
+        {
+            _children.Add(new BsonProperty { Name = new BsonString(name, false), Value = token });
+            token.Parent = this;
+        }
+
+        public override BsonType Type => BsonType.Object;
+
+        public IEnumerator<BsonProperty> GetEnumerator()
+        {
+            return _children.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+
+    internal class BsonArray : BsonToken, IEnumerable<BsonToken>
+    {
+        private readonly List<BsonToken> _children = new List<BsonToken>();
+
+        public void Add(BsonToken token)
+        {
+            _children.Add(token);
+            token.Parent = this;
+        }
+
+        public override BsonType Type => BsonType.Array;
+
+        public IEnumerator<BsonToken> GetEnumerator()
+        {
+            return _children.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+
+    internal class BsonEmpty : BsonToken
+    {
+        public static readonly BsonToken Null = new BsonEmpty(BsonType.Null);
+        public static readonly BsonToken Undefined = new BsonEmpty(BsonType.Undefined);
+
+        private BsonEmpty(BsonType type)
+        {
+            Type = type;
+        }
+
+        public override BsonType Type { get; }
+    }
+
+    internal class BsonValue : BsonToken
+    {
+        private readonly object _value;
+        private readonly BsonType _type;
+
+        public BsonValue(object value, BsonType type)
+        {
+            _value = value;
+            _type = type;
+        }
+
+        public object Value => _value;
+
+        public override BsonType Type => _type;
+    }
+
+    internal class BsonBoolean : BsonValue
+    {
+        public static readonly BsonBoolean False = new BsonBoolean(false);
+        public static readonly BsonBoolean True = new BsonBoolean(true);
+
+        private BsonBoolean(bool value)
+            : base(value, BsonType.Boolean)
+        {
+        }
+    }
+
+    internal class BsonString : BsonValue
+    {
+        public int ByteCount { get; set; }
+        public bool IncludeLength { get; }
+
+        public BsonString(object value, bool includeLength)
+            : base(value, BsonType.String)
+        {
+            IncludeLength = includeLength;
+        }
+    }
+
+    internal class BsonBinary : BsonValue
+    {
+        public BsonBinaryType BinaryType { get; set; }
+
+        public BsonBinary(byte[] value, BsonBinaryType binaryType)
+            : base(value, BsonType.Binary)
+        {
+            BinaryType = binaryType;
+        }
+    }
+
+    internal class BsonRegex : BsonToken
+    {
+        public BsonString Pattern { get; set; }
+        public BsonString Options { get; set; }
+
+        public BsonRegex(string pattern, string options)
+        {
+            Pattern = new BsonString(pattern, false);
+            Options = new BsonString(options, false);
+        }
+
+        public override BsonType Type => BsonType.Regex;
+    }
+
+    internal class BsonProperty
+    {
+        public BsonString Name { get; set; }
+        public BsonToken Value { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Bson/BsonType.cs b/Libs/Newtonsoft.Json/Bson/BsonType.cs
new file mode 100644
index 0000000..90d7b08
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Bson/BsonType.cs
@@ -0,0 +1,53 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Bson
+{
+    internal enum BsonType : sbyte
+    {
+        Number = 1,
+        String = 2,
+        Object = 3,
+        Array = 4,
+        Binary = 5,
+        Undefined = 6,
+        Oid = 7,
+        Boolean = 8,
+        Date = 9,
+        Null = 10,
+        Regex = 11,
+        Reference = 12,
+        Code = 13,
+        Symbol = 14,
+        CodeWScope = 15,
+        Integer = 16,
+        TimeStamp = 17,
+        Long = 18,
+        MinKey = -1,
+        MaxKey = 127
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Bson/BsonWriter.cs b/Libs/Newtonsoft.Json/Bson/BsonWriter.cs
new file mode 100644
index 0000000..1f059d6
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Bson/BsonWriter.cs
@@ -0,0 +1,539 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Text;
+using LC.Newtonsoft.Json.Utilities;
+using LC.Newtonsoft.Json.Linq;
+using System.Globalization;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Bson
+{
+    /// <summary>
+    /// Represents a writer that provides a fast, non-cached, forward-only way of generating BSON data.
+    /// </summary>
+    [Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
+    public class BsonWriter : JsonWriter
+    {
+        private readonly BsonBinaryWriter _writer;
+
+        private BsonToken _root;
+        private BsonToken _parent;
+        private string _propertyName;
+
+        /// <summary>
+        /// Gets or sets the <see cref="DateTimeKind" /> used when writing <see cref="DateTime"/> values to BSON.
+        /// When set to <see cref="DateTimeKind.Unspecified" /> no conversion will occur.
+        /// </summary>
+        /// <value>The <see cref="DateTimeKind" /> used when writing <see cref="DateTime"/> values to BSON.</value>
+        public DateTimeKind DateTimeKindHandling
+        {
+            get => _writer.DateTimeKindHandling;
+            set => _writer.DateTimeKindHandling = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonWriter"/> class.
+        /// </summary>
+        /// <param name="stream">The <see cref="Stream"/> to write to.</param>
+        public BsonWriter(Stream stream)
+        {
+            ValidationUtils.ArgumentNotNull(stream, nameof(stream));
+            _writer = new BsonBinaryWriter(new BinaryWriter(stream));
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonWriter"/> class.
+        /// </summary>
+        /// <param name="writer">The <see cref="BinaryWriter"/> to write to.</param>
+        public BsonWriter(BinaryWriter writer)
+        {
+            ValidationUtils.ArgumentNotNull(writer, nameof(writer));
+            _writer = new BsonBinaryWriter(writer);
+        }
+
+        /// <summary>
+        /// Flushes whatever is in the buffer to the underlying <see cref="Stream"/> and also flushes the underlying stream.
+        /// </summary>
+        public override void Flush()
+        {
+            _writer.Flush();
+        }
+
+        /// <summary>
+        /// Writes the end.
+        /// </summary>
+        /// <param name="token">The token.</param>
+        protected override void WriteEnd(JsonToken token)
+        {
+            base.WriteEnd(token);
+            RemoveParent();
+
+            if (Top == 0)
+            {
+                _writer.WriteToken(_root);
+            }
+        }
+
+        /// <summary>
+        /// Writes a comment <c>/*...*/</c> containing the specified text.
+        /// </summary>
+        /// <param name="text">Text to place inside the comment.</param>
+        public override void WriteComment(string text)
+        {
+            throw JsonWriterException.Create(this, "Cannot write JSON comment as BSON.", null);
+        }
+
+        /// <summary>
+        /// Writes the start of a constructor with the given name.
+        /// </summary>
+        /// <param name="name">The name of the constructor.</param>
+        public override void WriteStartConstructor(string name)
+        {
+            throw JsonWriterException.Create(this, "Cannot write JSON constructor as BSON.", null);
+        }
+
+        /// <summary>
+        /// Writes raw JSON.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        public override void WriteRaw(string json)
+        {
+            throw JsonWriterException.Create(this, "Cannot write raw JSON as BSON.", null);
+        }
+
+        /// <summary>
+        /// Writes raw JSON where a value is expected and updates the writer's state.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        public override void WriteRawValue(string json)
+        {
+            throw JsonWriterException.Create(this, "Cannot write raw JSON as BSON.", null);
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON array.
+        /// </summary>
+        public override void WriteStartArray()
+        {
+            base.WriteStartArray();
+
+            AddParent(new BsonArray());
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON object.
+        /// </summary>
+        public override void WriteStartObject()
+        {
+            base.WriteStartObject();
+
+            AddParent(new BsonObject());
+        }
+
+        /// <summary>
+        /// Writes the property name of a name/value pair on a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        public override void WritePropertyName(string name)
+        {
+            base.WritePropertyName(name);
+
+            _propertyName = name;
+        }
+
+        /// <summary>
+        /// Closes this writer.
+        /// If <see cref="JsonWriter.CloseOutput"/> is set to <c>true</c>, the underlying <see cref="Stream"/> is also closed.
+        /// If <see cref="JsonWriter.AutoCompleteOnClose"/> is set to <c>true</c>, the JSON is auto-completed.
+        /// </summary>
+        public override void Close()
+        {
+            base.Close();
+
+            if (CloseOutput)
+            {
+                _writer?.Close();
+            }
+        }
+
+        private void AddParent(BsonToken container)
+        {
+            AddToken(container);
+            _parent = container;
+        }
+
+        private void RemoveParent()
+        {
+            _parent = _parent.Parent;
+        }
+
+        private void AddValue(object value, BsonType type)
+        {
+            AddToken(new BsonValue(value, type));
+        }
+
+        internal void AddToken(BsonToken token)
+        {
+            if (_parent != null)
+            {
+                if (_parent is BsonObject bo)
+                {
+                    bo.Add(_propertyName, token);
+                    _propertyName = null;
+                }
+                else
+                {
+                    ((BsonArray)_parent).Add(token);
+                }
+            }
+            else
+            {
+                if (token.Type != BsonType.Object && token.Type != BsonType.Array)
+                {
+                    throw JsonWriterException.Create(this, "Error writing {0} value. BSON must start with an Object or Array.".FormatWith(CultureInfo.InvariantCulture, token.Type), null);
+                }
+
+                _parent = token;
+                _root = token;
+            }
+        }
+
+        #region WriteValue methods
+        /// <summary>
+        /// Writes a <see cref="Object"/> value.
+        /// An error will raised if the value cannot be written as a single JSON token.
+        /// </summary>
+        /// <param name="value">The <see cref="Object"/> value to write.</param>
+        public override void WriteValue(object value)
+        {
+#if HAVE_BIG_INTEGER
+            if (value is BigInteger i)
+            {
+                SetWriteState(JsonToken.Integer, null);
+                AddToken(new BsonBinary(i.ToByteArray(), BsonBinaryType.Binary));
+            }
+            else
+#endif
+            {
+                base.WriteValue(value);
+            }
+        }
+
+        /// <summary>
+        /// Writes a null value.
+        /// </summary>
+        public override void WriteNull()
+        {
+            base.WriteNull();
+            AddToken(BsonEmpty.Null);
+        }
+
+        /// <summary>
+        /// Writes an undefined value.
+        /// </summary>
+        public override void WriteUndefined()
+        {
+            base.WriteUndefined();
+            AddToken(BsonEmpty.Undefined);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="String"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="String"/> value to write.</param>
+        public override void WriteValue(string value)
+        {
+            base.WriteValue(value);
+            AddToken(value == null ? BsonEmpty.Null : new BsonString(value, true));
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int32"/> value to write.</param>
+        public override void WriteValue(int value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt32"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(uint value)
+        {
+            if (value > int.MaxValue)
+            {
+                throw JsonWriterException.Create(this, "Value is too large to fit in a signed 32 bit integer. BSON does not support unsigned values.", null);
+            }
+
+            base.WriteValue(value);
+            AddValue(value, BsonType.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int64"/> value to write.</param>
+        public override void WriteValue(long value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Long);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt64"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(ulong value)
+        {
+            if (value > long.MaxValue)
+            {
+                throw JsonWriterException.Create(this, "Value is too large to fit in a signed 64 bit integer. BSON does not support unsigned values.", null);
+            }
+
+            base.WriteValue(value);
+            AddValue(value, BsonType.Long);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Single"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Single"/> value to write.</param>
+        public override void WriteValue(float value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Number);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Double"/> value to write.</param>
+        public override void WriteValue(double value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Number);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Boolean"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Boolean"/> value to write.</param>
+        public override void WriteValue(bool value)
+        {
+            base.WriteValue(value);
+            AddToken(value ? BsonBoolean.True : BsonBoolean.False);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int16"/> value to write.</param>
+        public override void WriteValue(short value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt16"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(ushort value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Char"/> value to write.</param>
+        public override void WriteValue(char value)
+        {
+            base.WriteValue(value);
+            string s = null;
+#if HAVE_CHAR_TO_STRING_WITH_CULTURE
+            s = value.ToString(CultureInfo.InvariantCulture);
+#else
+            s = value.ToString();
+#endif
+            AddToken(new BsonString(s, true));
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/> value to write.</param>
+        public override void WriteValue(byte value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="SByte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="SByte"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(sbyte value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Decimal"/> value to write.</param>
+        public override void WriteValue(decimal value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Number);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
+        public override void WriteValue(DateTime value)
+        {
+            base.WriteValue(value);
+            value = DateTimeUtils.EnsureDateTime(value, DateTimeZoneHandling);
+            AddValue(value, BsonType.Date);
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Writes a <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTimeOffset"/> value to write.</param>
+        public override void WriteValue(DateTimeOffset value)
+        {
+            base.WriteValue(value);
+            AddValue(value, BsonType.Date);
+        }
+#endif
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/>[] value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/>[] value to write.</param>
+        public override void WriteValue(byte[] value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+                return;
+            }
+
+            base.WriteValue(value);
+            AddToken(new BsonBinary(value, BsonBinaryType.Binary));
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Guid"/> value to write.</param>
+        public override void WriteValue(Guid value)
+        {
+            base.WriteValue(value);
+            AddToken(new BsonBinary(value.ToByteArray(), BsonBinaryType.Uuid));
+        }
+
+        /// <summary>
+        /// Writes a <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="TimeSpan"/> value to write.</param>
+        public override void WriteValue(TimeSpan value)
+        {
+            base.WriteValue(value);
+            AddToken(new BsonString(value.ToString(), true));
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Uri"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Uri"/> value to write.</param>
+        public override void WriteValue(Uri value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+                return;
+            }
+
+            base.WriteValue(value);
+            AddToken(new BsonString(value.ToString(), true));
+        }
+        #endregion
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/>[] value that represents a BSON object id.
+        /// </summary>
+        /// <param name="value">The Object ID value to write.</param>
+        public void WriteObjectId(byte[] value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+
+            if (value.Length != 12)
+            {
+                throw JsonWriterException.Create(this, "An object id must be 12 bytes", null);
+            }
+
+            // hack to update the writer state
+            SetWriteState(JsonToken.Undefined, null);
+            AddValue(value, BsonType.Oid);
+        }
+
+        /// <summary>
+        /// Writes a BSON regex.
+        /// </summary>
+        /// <param name="pattern">The regex pattern.</param>
+        /// <param name="options">The regex options.</param>
+        public void WriteRegex(string pattern, string options)
+        {
+            ValidationUtils.ArgumentNotNull(pattern, nameof(pattern));
+
+            // hack to update the writer state
+            SetWriteState(JsonToken.Undefined, null);
+            AddToken(new BsonRegex(pattern, options));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/ConstructorHandling.cs b/Libs/Newtonsoft.Json/ConstructorHandling.cs
new file mode 100644
index 0000000..499e734
--- /dev/null
+++ b/Libs/Newtonsoft.Json/ConstructorHandling.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies how constructors are used when initializing objects during deserialization by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public enum ConstructorHandling
+    {
+        /// <summary>
+        /// First attempt to use the public default constructor, then fall back to a single parameterized constructor, then to the non-public default constructor.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// Json.NET will use a non-public default constructor before falling back to a parameterized constructor.
+        /// </summary>
+        AllowNonPublicDefaultConstructor = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/BinaryConverter.cs b/Libs/Newtonsoft.Json/Converters/BinaryConverter.cs
new file mode 100644
index 0000000..8462478
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/BinaryConverter.cs
@@ -0,0 +1,212 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_LINQ || HAVE_ADO_NET
+using System;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+using System.Collections.Generic;
+using System.Diagnostics;
+#if HAVE_ADO_NET
+using System.Data.SqlTypes;
+#endif
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a binary value to and from a base 64 string value.
+    /// </summary>
+    public class BinaryConverter : JsonConverter
+    {
+#if HAVE_LINQ
+        private const string BinaryTypeName = "System.Data.Linq.Binary";
+        private const string BinaryToArrayName = "ToArray";
+        private static ReflectionObject? _reflectionObject;
+#endif
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            byte[] data = GetByteArray(value);
+
+            writer.WriteValue(data);
+        }
+
+        private byte[] GetByteArray(object value)
+        {
+#if HAVE_LINQ
+            if (value.GetType().FullName == BinaryTypeName)
+            {
+                EnsureReflectionObject(value.GetType());
+                MiscellaneousUtils.Assert(_reflectionObject != null);
+
+                return (byte[])_reflectionObject.GetValue(value, BinaryToArrayName)!;
+            }
+#endif
+#if HAVE_ADO_NET
+            if (value is SqlBinary binary)
+            {
+                return binary.Value;
+            }
+#endif
+
+            throw new JsonSerializationException("Unexpected value type when writing binary: {0}".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
+        }
+
+#if HAVE_LINQ
+        private static void EnsureReflectionObject(Type t)
+        {
+            if (_reflectionObject == null)
+            {
+                _reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new[] { typeof(byte[]) }), BinaryToArrayName);
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullable(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            byte[] data;
+
+            if (reader.TokenType == JsonToken.StartArray)
+            {
+                data = ReadByteArray(reader);
+            }
+            else if (reader.TokenType == JsonToken.String)
+            {
+                // current token is already at base64 string
+                // unable to call ReadAsBytes so do it the old fashion way
+                string encodedData = reader.Value!.ToString();
+                data = Convert.FromBase64String(encodedData);
+            }
+            else
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token parsing binary. Expected String or StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+#if HAVE_LINQ
+            if (t.FullName == BinaryTypeName)
+            {
+                EnsureReflectionObject(t);
+                MiscellaneousUtils.Assert(_reflectionObject != null);
+
+                return _reflectionObject.Creator!(data);
+            }
+#endif
+
+#if HAVE_ADO_NET
+            if (t == typeof(SqlBinary))
+            {
+                return new SqlBinary(data);
+            }
+#endif
+
+            throw JsonSerializationException.Create(reader, "Unexpected object type when writing binary: {0}".FormatWith(CultureInfo.InvariantCulture, objectType));
+        }
+
+        private byte[] ReadByteArray(JsonReader reader)
+        {
+            List<byte> byteList = new List<byte>();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.Integer:
+                        byteList.Add(Convert.ToByte(reader.Value, CultureInfo.InvariantCulture));
+                        break;
+                    case JsonToken.EndArray:
+                        return byteList.ToArray();
+                    case JsonToken.Comment:
+                        // skip
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token when reading bytes: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading bytes.");
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+#if HAVE_LINQ
+            if (objectType.FullName == BinaryTypeName)
+            {
+                return true;
+            }
+#endif
+#if HAVE_ADO_NET
+            if (objectType == typeof(SqlBinary) || objectType == typeof(SqlBinary?))
+            {
+                return true;
+            }
+#endif
+
+            return false;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/BsonObjectIdConverter.cs b/Libs/Newtonsoft.Json/Converters/BsonObjectIdConverter.cs
new file mode 100644
index 0000000..6e2a3e9
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/BsonObjectIdConverter.cs
@@ -0,0 +1,93 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Bson;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="BsonObjectId"/> to and from JSON and BSON.
+    /// </summary>
+    [Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
+    public class BsonObjectIdConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            BsonObjectId objectId = (BsonObjectId)value;
+
+            if (writer is BsonWriter bsonWriter)
+            {
+                bsonWriter.WriteObjectId(objectId.Value);
+            }
+            else
+            {
+                writer.WriteValue(objectId.Value);
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType != JsonToken.Bytes)
+            {
+                throw new JsonSerializationException("Expected Bytes but got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            byte[] value = (byte[])reader.Value;
+
+            return new BsonObjectId(value);
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return (objectType == typeof(BsonObjectId));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/CustomCreationConverter.cs b/Libs/Newtonsoft.Json/Converters/CustomCreationConverter.cs
new file mode 100644
index 0000000..b08fe59
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/CustomCreationConverter.cs
@@ -0,0 +1,101 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Creates a custom object.
+    /// </summary>
+    /// <typeparam name="T">The object type to convert.</typeparam>
+    public abstract class CustomCreationConverter<T> : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            throw new NotSupportedException("CustomCreationConverter should only be used while deserializing.");
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            T value = Create(objectType);
+            if (value == null)
+            {
+                throw new JsonSerializationException("No object created.");
+            }
+
+            serializer.Populate(reader, value);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates an object which will then be populated by the serializer.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>The created object.</returns>
+        public abstract T Create(Type objectType);
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(T).IsAssignableFrom(objectType);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanWrite => false;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/DataSetConverter.cs b/Libs/Newtonsoft.Json/Converters/DataSetConverter.cs
new file mode 100644
index 0000000..c4f57bf
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/DataSetConverter.cs
@@ -0,0 +1,125 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ADO_NET
+using System;
+using System.Data;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DataSet"/> to and from JSON.
+    /// </summary>
+    public class DataSetConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            DataSet dataSet = (DataSet)value;
+            DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            DataTableConverter converter = new DataTableConverter();
+
+            writer.WriteStartObject();
+
+            foreach (DataTable table in dataSet.Tables)
+            {
+                writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(table.TableName) : table.TableName);
+
+                converter.WriteJson(writer, table, serializer);
+            }
+
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            // handle typed datasets
+            DataSet ds = (objectType == typeof(DataSet))
+                ? new DataSet()
+                : (DataSet)Activator.CreateInstance(objectType);
+
+            DataTableConverter converter = new DataTableConverter();
+
+            reader.ReadAndAssert();
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                DataTable dt = ds.Tables[(string)reader.Value!];
+                bool exists = (dt != null);
+
+                dt = (DataTable)converter.ReadJson(reader, typeof(DataTable), dt, serializer)!;
+
+                if (!exists)
+                {
+                    ds.Tables.Add(dt);
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            return ds;
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified value type.
+        /// </summary>
+        /// <param name="valueType">Type of the value.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type valueType)
+        {
+            return typeof(DataSet).IsAssignableFrom(valueType);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/DataTableConverter.cs b/Libs/Newtonsoft.Json/Converters/DataTableConverter.cs
new file mode 100644
index 0000000..afaec81
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/DataTableConverter.cs
@@ -0,0 +1,254 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ADO_NET
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+using System;
+using System.Data;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DataTable"/> to and from JSON.
+    /// </summary>
+    public class DataTableConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            DataTable table = (DataTable)value;
+            DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            writer.WriteStartArray();
+
+            foreach (DataRow row in table.Rows)
+            {
+                writer.WriteStartObject();
+                foreach (DataColumn column in row.Table.Columns)
+                {
+                    object columnValue = row[column];
+
+                    if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value))
+                    {
+                        continue;
+                    }
+
+                    writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName);
+                    serializer.Serialize(writer, columnValue);
+                }
+                writer.WriteEndObject();
+            }
+
+            writer.WriteEndArray();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            if (!(existingValue is DataTable dt))
+            {
+                // handle typed datasets
+                dt = (objectType == typeof(DataTable))
+                    ? new DataTable()
+                    : (DataTable)Activator.CreateInstance(objectType);
+            }
+
+            // DataTable is inside a DataSet
+            // populate the name from the property name
+            if (reader.TokenType == JsonToken.PropertyName)
+            {
+                dt.TableName = (string)reader.Value!;
+
+                reader.ReadAndAssert();
+
+                if (reader.TokenType == JsonToken.Null)
+                {
+                    return dt;
+                }
+            }
+
+            if (reader.TokenType != JsonToken.StartArray)
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable. Expected StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            reader.ReadAndAssert();
+
+            while (reader.TokenType != JsonToken.EndArray)
+            {
+                CreateRow(reader, dt, serializer);
+
+                reader.ReadAndAssert();
+            }
+
+            return dt;
+        }
+
+        private static void CreateRow(JsonReader reader, DataTable dt, JsonSerializer serializer)
+        {
+            DataRow dr = dt.NewRow();
+            reader.ReadAndAssert();
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                string columnName = (string)reader.Value!;
+
+                reader.ReadAndAssert();
+
+                DataColumn column = dt.Columns[columnName];
+                if (column == null)
+                {
+                    Type columnType = GetColumnDataType(reader);
+                    column = new DataColumn(columnName, columnType);
+                    dt.Columns.Add(column);
+                }
+
+                if (column.DataType == typeof(DataTable))
+                {
+                    if (reader.TokenType == JsonToken.StartArray)
+                    {
+                        reader.ReadAndAssert();
+                    }
+
+                    DataTable nestedDt = new DataTable();
+
+                    while (reader.TokenType != JsonToken.EndArray)
+                    {
+                        CreateRow(reader, nestedDt, serializer);
+
+                        reader.ReadAndAssert();
+                    }
+
+                    dr[columnName] = nestedDt;
+                }
+                else if (column.DataType.IsArray && column.DataType != typeof(byte[]))
+                {
+                    if (reader.TokenType == JsonToken.StartArray)
+                    {
+                        reader.ReadAndAssert();
+                    }
+
+                    List<object?> o = new List<object?>();
+
+                    while (reader.TokenType != JsonToken.EndArray)
+                    {
+                        o.Add(reader.Value);
+                        reader.ReadAndAssert();
+                    }
+
+                    Array destinationArray = Array.CreateInstance(column.DataType.GetElementType(), o.Count);
+                    ((IList)o).CopyTo(destinationArray, 0);
+
+                    dr[columnName] = destinationArray;
+                }
+                else
+                {
+                    object columnValue = (reader.Value != null)
+                        ? serializer.Deserialize(reader, column.DataType) ?? DBNull.Value
+                        : DBNull.Value;
+
+                    dr[columnName] = columnValue;
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            dr.EndEdit();
+            dt.Rows.Add(dr);
+        }
+
+        private static Type GetColumnDataType(JsonReader reader)
+        {
+            JsonToken tokenType = reader.TokenType;
+
+            switch (tokenType)
+            {
+                case JsonToken.Integer:
+                case JsonToken.Boolean:
+                case JsonToken.Float:
+                case JsonToken.String:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                    return reader.ValueType!;
+                case JsonToken.Null:
+                case JsonToken.Undefined:
+                case JsonToken.EndArray:
+                    return typeof(string);
+                case JsonToken.StartArray:
+                    reader.ReadAndAssert();
+                    if (reader.TokenType == JsonToken.StartObject)
+                    {
+                        return typeof(DataTable); // nested datatable
+                    }
+
+                    Type arrayType = GetColumnDataType(reader);
+                    return arrayType.MakeArrayType();
+                default:
+                    throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable: {0}".FormatWith(CultureInfo.InvariantCulture, tokenType));
+            }
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified value type.
+        /// </summary>
+        /// <param name="valueType">Type of the value.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type valueType)
+        {
+            return typeof(DataTable).IsAssignableFrom(valueType);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/DateTimeConverterBase.cs b/Libs/Newtonsoft.Json/Converters/DateTimeConverterBase.cs
new file mode 100644
index 0000000..49a0e19
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/DateTimeConverterBase.cs
@@ -0,0 +1,58 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Provides a base class for converting a <see cref="DateTime"/> to and from JSON.
+    /// </summary>
+    public abstract class DateTimeConverterBase : JsonConverter
+    {
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            if (objectType == typeof(DateTime) || objectType == typeof(DateTime?))
+            {
+                return true;
+            }
+#if HAVE_DATE_TIME_OFFSET
+            if (objectType == typeof(DateTimeOffset) || objectType == typeof(DateTimeOffset?))
+            {
+                return true;
+            }
+#endif
+
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs b/Libs/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs
new file mode 100644
index 0000000..184ecb5
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs
@@ -0,0 +1,298 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_FSHARP_TYPES
+using LC.Newtonsoft.Json.Linq;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+using LC.Newtonsoft.Json.Serialization;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a F# discriminated union type to and from JSON.
+    /// </summary>
+    public class DiscriminatedUnionConverter : JsonConverter
+    {
+        #region UnionDefinition
+        internal class Union
+        {
+            public readonly FSharpFunction TagReader;
+            public readonly List<UnionCase> Cases;
+
+            public Union(FSharpFunction tagReader, List<UnionCase> cases)
+            {
+                TagReader = tagReader;
+                Cases = cases;
+            }
+        }
+
+        internal class UnionCase
+        {
+            public readonly int Tag;
+            public readonly string Name;
+            public readonly PropertyInfo[] Fields;
+            public readonly FSharpFunction FieldReader;
+            public readonly FSharpFunction Constructor;
+
+            public UnionCase(int tag, string name, PropertyInfo[] fields, FSharpFunction fieldReader, FSharpFunction constructor)
+            {
+                Tag = tag;
+                Name = name;
+                Fields = fields;
+                FieldReader = fieldReader;
+                Constructor = constructor;
+            }
+        }
+        #endregion
+
+        private const string CasePropertyName = "Case";
+        private const string FieldsPropertyName = "Fields";
+
+        private static readonly ThreadSafeStore<Type, Union> UnionCache = new ThreadSafeStore<Type, Union>(CreateUnion);
+        private static readonly ThreadSafeStore<Type, Type> UnionTypeLookupCache = new ThreadSafeStore<Type, Type>(CreateUnionTypeLookup);
+
+        private static Type CreateUnionTypeLookup(Type t)
+        {
+            // this lookup is because cases with fields are derived from union type
+            // need to get declaring type to avoid duplicate Unions in cache
+
+            // hacky but I can't find an API to get the declaring type without GetUnionCases
+            object[] cases = (object[])FSharpUtils.Instance.GetUnionCases(null, t, null)!;
+
+            object caseInfo = cases.First();
+
+            Type unionType = (Type)FSharpUtils.Instance.GetUnionCaseInfoDeclaringType(caseInfo)!;
+            return unionType;
+        }
+
+        private static Union CreateUnion(Type t)
+        {
+            Union u = new Union((FSharpFunction)FSharpUtils.Instance.PreComputeUnionTagReader(null, t, null), new List<UnionCase>());
+
+            object[] cases = (object[])FSharpUtils.Instance.GetUnionCases(null, t, null)!;
+
+            foreach (object unionCaseInfo in cases)
+            {
+                UnionCase unionCase = new UnionCase(
+                    (int)FSharpUtils.Instance.GetUnionCaseInfoTag(unionCaseInfo),
+                    (string)FSharpUtils.Instance.GetUnionCaseInfoName(unionCaseInfo),
+                    (PropertyInfo[])FSharpUtils.Instance.GetUnionCaseInfoFields(unionCaseInfo)!,
+                    (FSharpFunction)FSharpUtils.Instance.PreComputeUnionReader(null, unionCaseInfo, null),
+                    (FSharpFunction)FSharpUtils.Instance.PreComputeUnionConstructor(null, unionCaseInfo, null));
+
+                u.Cases.Add(unionCase);
+            }
+
+            return u;
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            Type unionType = UnionTypeLookupCache.Get(value.GetType());
+            Union union = UnionCache.Get(unionType);
+
+            int tag = (int)union.TagReader.Invoke(value);
+            UnionCase caseInfo = union.Cases.Single(c => c.Tag == tag);
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName);
+            writer.WriteValue(caseInfo.Name);
+            if (caseInfo.Fields != null && caseInfo.Fields.Length > 0)
+            {
+                object[] fields = (object[])caseInfo.FieldReader.Invoke(value)!;
+
+                writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName);
+                writer.WriteStartArray();
+                foreach (object field in fields)
+                {
+                    serializer.Serialize(writer, field);
+                }
+                writer.WriteEndArray();
+            }
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            UnionCase? caseInfo = null;
+            string? caseName = null;
+            JArray? fields = null;
+
+            // start object
+            reader.ReadAndAssert();
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                string propertyName = reader.Value!.ToString();
+                if (string.Equals(propertyName, CasePropertyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadAndAssert();
+
+                    Union union = UnionCache.Get(objectType);
+
+                    caseName = reader.Value!.ToString();
+
+                    caseInfo = union.Cases.SingleOrDefault(c => c.Name == caseName);
+
+                    if (caseInfo == null)
+                    {
+                        throw JsonSerializationException.Create(reader, "No union type found with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, caseName));
+                    }
+                }
+                else if (string.Equals(propertyName, FieldsPropertyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadAndAssert();
+                    if (reader.TokenType != JsonToken.StartArray)
+                    {
+                        throw JsonSerializationException.Create(reader, "Union fields must been an array.");
+                    }
+
+                    fields = (JArray)JToken.ReadFrom(reader);
+                }
+                else
+                {
+                    throw JsonSerializationException.Create(reader, "Unexpected property '{0}' found when reading union.".FormatWith(CultureInfo.InvariantCulture, propertyName));
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            if (caseInfo == null)
+            {
+                throw JsonSerializationException.Create(reader, "No '{0}' property with union name found.".FormatWith(CultureInfo.InvariantCulture, CasePropertyName));
+            }
+
+            object?[] typedFieldValues = new object?[caseInfo.Fields.Length];
+
+            if (caseInfo.Fields.Length > 0 && fields == null)
+            {
+                throw JsonSerializationException.Create(reader, "No '{0}' property with union fields found.".FormatWith(CultureInfo.InvariantCulture, FieldsPropertyName));
+            }
+
+            if (fields != null)
+            {
+                if (caseInfo.Fields.Length != fields.Count)
+                {
+                    throw JsonSerializationException.Create(reader, "The number of field values does not match the number of properties defined by union '{0}'.".FormatWith(CultureInfo.InvariantCulture, caseName));
+                }
+
+                for (int i = 0; i < fields.Count; i++)
+                {
+                    JToken t = fields[i];
+                    PropertyInfo fieldProperty = caseInfo.Fields[i];
+
+                    typedFieldValues[i] = t.ToObject(fieldProperty.PropertyType, serializer);
+                }
+            }
+
+            object[] args = { typedFieldValues };
+
+            return caseInfo.Constructor.Invoke(args);
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            if (typeof(IEnumerable).IsAssignableFrom(objectType))
+            {
+                return false;
+            }
+
+            // all fsharp objects have CompilationMappingAttribute
+            // get the fsharp assembly from the attribute and initialize latebound methods
+            object[] attributes;
+#if HAVE_FULL_REFLECTION
+            attributes = objectType.GetCustomAttributes(true);
+#else
+            attributes = objectType.GetTypeInfo().GetCustomAttributes(true).ToArray();
+#endif
+
+            bool isFSharpType = false;
+            foreach (object attribute in attributes)
+            {
+                Type attributeType = attribute.GetType();
+                if (attributeType.FullName == "Microsoft.FSharp.Core.CompilationMappingAttribute")
+                {
+                    FSharpUtils.EnsureInitialized(attributeType.Assembly());
+
+                    isFSharpType = true;
+                    break;
+                }
+            }
+
+            if (!isFSharpType)
+            {
+                return false;
+            }
+
+            return (bool)FSharpUtils.Instance.IsUnion(null, objectType, null);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/EntityKeyMemberConverter.cs b/Libs/Newtonsoft.Json/Converters/EntityKeyMemberConverter.cs
new file mode 100644
index 0000000..f138b6e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/EntityKeyMemberConverter.cs
@@ -0,0 +1,165 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ENTITY_FRAMEWORK
+using System;
+using LC.Newtonsoft.Json.Serialization;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts an Entity Framework <see cref="T:System.Data.EntityKeyMember"/> to and from JSON.
+    /// </summary>
+    public class EntityKeyMemberConverter : JsonConverter
+    {
+        private const string EntityKeyMemberFullTypeName = "System.Data.EntityKeyMember";
+
+        private const string KeyPropertyName = "Key";
+        private const string TypePropertyName = "Type";
+        private const string ValuePropertyName = "Value";
+
+        private static ReflectionObject? _reflectionObject;
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            EnsureReflectionObject(value.GetType());
+            MiscellaneousUtils.Assert(_reflectionObject != null);
+
+            DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName)!;
+            object? keyValue = _reflectionObject.GetValue(value, ValuePropertyName);
+
+            Type? keyValueType = keyValue?.GetType();
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
+            writer.WriteValue(keyName);
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
+            writer.WriteValue(keyValueType?.FullName);
+
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);
+
+            if (keyValueType != null)
+            {
+                if (JsonSerializerInternalWriter.TryConvertToString(keyValue!, keyValueType, out string? valueJson))
+                {
+                    writer.WriteValue(valueJson);
+                }
+                else
+                {
+                    writer.WriteValue(keyValue);
+                }
+            }
+            else
+            {
+                writer.WriteNull();
+            }
+
+            writer.WriteEndObject();
+        }
+
+        private static void ReadAndAssertProperty(JsonReader reader, string propertyName)
+        {
+            reader.ReadAndAssert();
+
+            if (reader.TokenType != JsonToken.PropertyName || !string.Equals(reader.Value?.ToString(), propertyName, StringComparison.OrdinalIgnoreCase))
+            {
+                throw new JsonSerializationException("Expected JSON property '{0}'.".FormatWith(CultureInfo.InvariantCulture, propertyName));
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            EnsureReflectionObject(objectType);
+            MiscellaneousUtils.Assert(_reflectionObject != null);
+
+            object entityKeyMember = _reflectionObject.Creator!();
+
+            ReadAndAssertProperty(reader, KeyPropertyName);
+            reader.ReadAndAssert();
+            _reflectionObject.SetValue(entityKeyMember, KeyPropertyName, reader.Value?.ToString());
+
+            ReadAndAssertProperty(reader, TypePropertyName);
+            reader.ReadAndAssert();
+            string? type = reader.Value?.ToString();
+
+            Type t = Type.GetType(type);
+
+            ReadAndAssertProperty(reader, ValuePropertyName);
+            reader.ReadAndAssert();
+            _reflectionObject.SetValue(entityKeyMember, ValuePropertyName, serializer.Deserialize(reader, t));
+
+            reader.ReadAndAssert();
+
+            return entityKeyMember;
+        }
+
+        private static void EnsureReflectionObject(Type objectType)
+        {
+            if (_reflectionObject == null)
+            {
+                _reflectionObject = ReflectionObject.Create(objectType, KeyPropertyName, ValuePropertyName);
+            }
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType.AssignableToTypeName(EntityKeyMemberFullTypeName, false);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs b/Libs/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs
new file mode 100644
index 0000000..8c8fef7
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs
@@ -0,0 +1,165 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_DYNAMIC
+
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts an <see cref="ExpandoObject"/> to and from JSON.
+    /// </summary>
+    public class ExpandoObjectConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            // can write is set to false
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            return ReadValue(reader);
+        }
+
+        private object? ReadValue(JsonReader reader)
+        {
+            if (!reader.MoveToContent())
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+            }
+
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return ReadObject(reader);
+                case JsonToken.StartArray:
+                    return ReadList(reader);
+                default:
+                    if (JsonTokenUtils.IsPrimitiveToken(reader.TokenType))
+                    {
+                        return reader.Value;
+                    }
+
+                    throw JsonSerializationException.Create(reader, "Unexpected token when converting ExpandoObject: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+        }
+
+        private object ReadList(JsonReader reader)
+        {
+            IList<object?> list = new List<object?>();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.Comment:
+                        break;
+                    default:
+                        object? v = ReadValue(reader);
+
+                        list.Add(v);
+                        break;
+                    case JsonToken.EndArray:
+                        return list;
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+        }
+
+        private object ReadObject(JsonReader reader)
+        {
+            IDictionary<string, object?> expandoObject = new ExpandoObject();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string propertyName = reader.Value!.ToString();
+
+                        if (!reader.Read())
+                        {
+                            throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+                        }
+
+                        object? v = ReadValue(reader);
+
+                        expandoObject[propertyName] = v;
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        return expandoObject;
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return (objectType == typeof(ExpandoObject));
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanWrite => false;
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/IsoDateTimeConverter.cs b/Libs/Newtonsoft.Json/Converters/IsoDateTimeConverter.cs
new file mode 100644
index 0000000..92d1a5e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/IsoDateTimeConverter.cs
@@ -0,0 +1,194 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DateTime"/> to and from the ISO 8601 date format (e.g. <c>"2008-04-12T12:53Z"</c>).
+    /// </summary>
+    public class IsoDateTimeConverter : DateTimeConverterBase
+    {
+        private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
+
+        private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind;
+        private string? _dateTimeFormat;
+        private CultureInfo? _culture;
+
+        /// <summary>
+        /// Gets or sets the date time styles used when converting a date to and from JSON.
+        /// </summary>
+        /// <value>The date time styles used when converting a date to and from JSON.</value>
+        public DateTimeStyles DateTimeStyles
+        {
+            get => _dateTimeStyles;
+            set => _dateTimeStyles = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the date time format used when converting a date to and from JSON.
+        /// </summary>
+        /// <value>The date time format used when converting a date to and from JSON.</value>
+        public string? DateTimeFormat
+        {
+            get => _dateTimeFormat ?? string.Empty;
+            set => _dateTimeFormat = (StringUtils.IsNullOrEmpty(value)) ? null : value;
+        }
+
+        /// <summary>
+        /// Gets or sets the culture used when converting a date to and from JSON.
+        /// </summary>
+        /// <value>The culture used when converting a date to and from JSON.</value>
+        public CultureInfo Culture
+        {
+            get => _culture ?? CultureInfo.CurrentCulture;
+            set => _culture = value;
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            string text;
+
+            if (value is DateTime dateTime)
+            {
+                if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
+                    || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
+                {
+                    dateTime = dateTime.ToUniversalTime();
+                }
+
+                text = dateTime.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
+            }
+#if HAVE_DATE_TIME_OFFSET
+            else if (value is DateTimeOffset dateTimeOffset)
+            {
+                if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
+                    || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
+                {
+                    dateTimeOffset = dateTimeOffset.ToUniversalTime();
+                }
+
+                text = dateTimeOffset.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
+            }
+#endif
+            else
+            {
+                throw new JsonSerializationException("Unexpected value when converting date. Expected DateTime or DateTimeOffset, got {0}.".FormatWith(CultureInfo.InvariantCulture, ReflectionUtils.GetObjectType(value)!));
+            }
+
+            writer.WriteValue(text);
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            bool nullable = ReflectionUtils.IsNullableType(objectType);
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!nullable)
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+#if HAVE_DATE_TIME_OFFSET
+            Type t = (nullable)
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+#endif
+
+            if (reader.TokenType == JsonToken.Date)
+            {
+#if HAVE_DATE_TIME_OFFSET
+                if (t == typeof(DateTimeOffset))
+                {
+                    return (reader.Value is DateTimeOffset) ? reader.Value : new DateTimeOffset((DateTime)reader.Value!);
+                }
+
+                // converter is expected to return a DateTime
+                if (reader.Value is DateTimeOffset offset)
+                {
+                    return offset.DateTime;
+                }
+#endif
+
+                return reader.Value;
+            }
+
+            if (reader.TokenType != JsonToken.String)
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected String, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            string? dateText = reader.Value?.ToString();
+
+            if (StringUtils.IsNullOrEmpty(dateText) && nullable)
+            {
+                return null;
+            }
+
+#if HAVE_DATE_TIME_OFFSET
+            if (t == typeof(DateTimeOffset))
+            {
+                if (!StringUtils.IsNullOrEmpty(_dateTimeFormat))
+                {
+                    return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
+                }
+                else
+                {
+                    return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles);
+                }
+            }
+#endif
+
+            if (!StringUtils.IsNullOrEmpty(_dateTimeFormat))
+            {
+                return DateTime.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
+            }
+            else
+            {
+                return DateTime.Parse(dateText, Culture, _dateTimeStyles);
+            }
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Converters/JavaScriptDateTimeConverter.cs b/Libs/Newtonsoft.Json/Converters/JavaScriptDateTimeConverter.cs
new file mode 100644
index 0000000..0101751
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/JavaScriptDateTimeConverter.cs
@@ -0,0 +1,111 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DateTime"/> to and from a JavaScript <c>Date</c> constructor (e.g. <c>new Date(52231943)</c>).
+    /// </summary>
+    public class JavaScriptDateTimeConverter : DateTimeConverterBase
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            long ticks;
+
+            if (value is DateTime dateTime)
+            {
+                DateTime utcDateTime = dateTime.ToUniversalTime();
+                ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTime);
+            }
+#if HAVE_DATE_TIME_OFFSET
+            else if (value is DateTimeOffset dateTimeOffset)
+            {
+                DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
+                ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
+            }
+#endif
+            else
+            {
+                throw new JsonSerializationException("Expected date object value.");
+            }
+
+            writer.WriteStartConstructor("Date");
+            writer.WriteValue(ticks);
+            writer.WriteEndConstructor();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullable(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            if (reader.TokenType != JsonToken.StartConstructor || !string.Equals(reader.Value?.ToString(), "Date", StringComparison.Ordinal))
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing date. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
+            }
+
+            if (!JavaScriptUtils.TryGetDateFromConstructorJson(reader, out DateTime d, out string? errorMessage))
+            {
+                throw JsonSerializationException.Create(reader, errorMessage);
+            }
+
+#if HAVE_DATE_TIME_OFFSET
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+            if (t == typeof(DateTimeOffset))
+            {
+                return new DateTimeOffset(d);
+            }
+#endif
+            return d;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/KeyValuePairConverter.cs b/Libs/Newtonsoft.Json/Converters/KeyValuePairConverter.cs
new file mode 100644
index 0000000..085af0c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/KeyValuePairConverter.cs
@@ -0,0 +1,159 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+using System.Reflection;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="KeyValuePair{TKey,TValue}"/> to and from JSON.
+    /// </summary>
+    public class KeyValuePairConverter : JsonConverter
+    {
+        private const string KeyName = "Key";
+        private const string ValueName = "Value";
+
+        private static readonly ThreadSafeStore<Type, ReflectionObject> ReflectionObjectPerType = new ThreadSafeStore<Type, ReflectionObject>(InitializeReflectionObject);
+
+        private static ReflectionObject InitializeReflectionObject(Type t)
+        {
+            IList<Type> genericArguments = t.GetGenericArguments();
+            Type keyType = genericArguments[0];
+            Type valueType = genericArguments[1];
+
+            return ReflectionObject.Create(t, t.GetConstructor(new[] { keyType, valueType }), KeyName, ValueName);
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
+
+            DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
+            serializer.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName));
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
+            serializer.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName));
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullableType(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair.");
+                }
+
+                return null;
+            }
+
+            object? key = null;
+            object? value = null;
+
+            reader.ReadAndAssert();
+
+            Type t = ReflectionUtils.IsNullableType(objectType)
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+            ReflectionObject reflectionObject = ReflectionObjectPerType.Get(t);
+            JsonContract keyContract = serializer.ContractResolver.ResolveContract(reflectionObject.GetType(KeyName));
+            JsonContract valueContract = serializer.ContractResolver.ResolveContract(reflectionObject.GetType(ValueName));
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                string propertyName = reader.Value!.ToString();
+                if (string.Equals(propertyName, KeyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadForTypeAndAssert(keyContract, false);
+
+                    key = serializer.Deserialize(reader, keyContract.UnderlyingType);
+                }
+                else if (string.Equals(propertyName, ValueName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadForTypeAndAssert(valueContract, false);
+
+                    value = serializer.Deserialize(reader, valueContract.UnderlyingType);
+                }
+                else
+                {
+                    reader.Skip();
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            return reflectionObject.Creator!(key, value);
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+            if (t.IsValueType() && t.IsGenericType())
+            {
+                return (t.GetGenericTypeDefinition() == typeof(KeyValuePair<,>));
+            }
+
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/RegexConverter.cs b/Libs/Newtonsoft.Json/Converters/RegexConverter.cs
new file mode 100644
index 0000000..69ea8d8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/RegexConverter.cs
@@ -0,0 +1,235 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Text.RegularExpressions;
+using LC.Newtonsoft.Json.Bson;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using LC.Newtonsoft.Json.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="Regex"/> to and from JSON and BSON.
+    /// </summary>
+    public class RegexConverter : JsonConverter
+    {
+        private const string PatternName = "Pattern";
+        private const string OptionsName = "Options";
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            Regex regex = (Regex)value;
+
+#pragma warning disable 618
+            if (writer is BsonWriter bsonWriter)
+            {
+                WriteBson(bsonWriter, regex);
+            }
+#pragma warning restore 618
+            else
+            {
+                WriteJson(writer, regex, serializer);
+            }
+        }
+
+        private bool HasFlag(RegexOptions options, RegexOptions flag)
+        {
+            return ((options & flag) == flag);
+        }
+
+#pragma warning disable 618
+        private void WriteBson(BsonWriter writer, Regex regex)
+        {
+            // Regular expression - The first cstring is the regex pattern, the second
+            // is the regex options string. Options are identified by characters, which 
+            // must be stored in alphabetical order. Valid options are 'i' for case 
+            // insensitive matching, 'm' for multiline matching, 'x' for verbose mode, 
+            // 'l' to make \w, \W, etc. locale dependent, 's' for dotall mode 
+            // ('.' matches everything), and 'u' to make \w, \W, etc. match unicode.
+
+            string? options = null;
+
+            if (HasFlag(regex.Options, RegexOptions.IgnoreCase))
+            {
+                options += "i";
+            }
+
+            if (HasFlag(regex.Options, RegexOptions.Multiline))
+            {
+                options += "m";
+            }
+
+            if (HasFlag(regex.Options, RegexOptions.Singleline))
+            {
+                options += "s";
+            }
+
+            options += "u";
+
+            if (HasFlag(regex.Options, RegexOptions.ExplicitCapture))
+            {
+                options += "x";
+            }
+
+            writer.WriteRegex(regex.ToString(), options);
+        }
+#pragma warning restore 618
+
+        private void WriteJson(JsonWriter writer, Regex regex, JsonSerializer serializer)
+        {
+            DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(PatternName) : PatternName);
+            writer.WriteValue(regex.ToString());
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(OptionsName) : OptionsName);
+            serializer.Serialize(writer, regex.Options);
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return ReadRegexObject(reader, serializer);
+                case JsonToken.String:
+                    return ReadRegexString(reader);
+                case JsonToken.Null:
+                    return null;
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected token when reading Regex.");
+        }
+
+        private object ReadRegexString(JsonReader reader)
+        {
+            string regexText = (string)reader.Value!;
+
+            if (regexText.Length > 0 && regexText[0] == '/')
+            {
+                int patternOptionDelimiterIndex = regexText.LastIndexOf('/');
+
+                if (patternOptionDelimiterIndex > 0)
+                {
+                    string patternText = regexText.Substring(1, patternOptionDelimiterIndex - 1);
+                    string optionsText = regexText.Substring(patternOptionDelimiterIndex + 1);
+
+                    RegexOptions options = MiscellaneousUtils.GetRegexOptions(optionsText);
+
+                    return new Regex(patternText, options);
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Regex pattern must be enclosed by slashes.");
+        }
+
+        private Regex ReadRegexObject(JsonReader reader, JsonSerializer serializer)
+        {
+            string? pattern = null;
+            RegexOptions? options = null;
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string propertyName = reader.Value!.ToString();
+
+                        if (!reader.Read())
+                        {
+                            throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex.");
+                        }
+
+                        if (string.Equals(propertyName, PatternName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            pattern = (string?)reader.Value;
+                        }
+                        else if (string.Equals(propertyName, OptionsName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            options = serializer.Deserialize<RegexOptions>(reader);
+                        }
+                        else
+                        {
+                            reader.Skip();
+                        }
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        if (pattern == null)
+                        {
+                            throw JsonSerializationException.Create(reader, "Error deserializing Regex. No pattern found.");
+                        }
+
+                        return new Regex(pattern, options ?? RegexOptions.None);
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex.");
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType.Name == nameof(Regex) && IsRegex(objectType);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private bool IsRegex(Type objectType)
+        {
+            return (objectType == typeof(Regex));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/StringEnumConverter.cs b/Libs/Newtonsoft.Json/Converters/StringEnumConverter.cs
new file mode 100644
index 0000000..b0b93a0
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/StringEnumConverter.cs
@@ -0,0 +1,276 @@
+#region License
+
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+using LC.Newtonsoft.Json.Serialization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts an <see cref="Enum"/> to and from its name string value.
+    /// </summary>
+    public class StringEnumConverter : JsonConverter
+    {
+        /// <summary>
+        /// Gets or sets a value indicating whether the written enum text should be camel case.
+        /// The default value is <c>false</c>.
+        /// </summary>
+        /// <value><c>true</c> if the written enum text will be camel case; otherwise, <c>false</c>.</value>
+        [Obsolete("StringEnumConverter.CamelCaseText is obsolete. Set StringEnumConverter.NamingStrategy with CamelCaseNamingStrategy instead.")]
+        public bool CamelCaseText
+        {
+            get => NamingStrategy is CamelCaseNamingStrategy ? true : false;
+            set
+            {
+                if (value)
+                {
+                    if (NamingStrategy is CamelCaseNamingStrategy)
+                    {
+                        return;
+                    }
+
+                    NamingStrategy = new CamelCaseNamingStrategy();
+                }
+                else
+                {
+                    if (!(NamingStrategy is CamelCaseNamingStrategy))
+                    {
+                        return;
+                    }
+
+                    NamingStrategy = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the naming strategy used to resolve how enum text is written.
+        /// </summary>
+        /// <value>The naming strategy used to resolve how enum text is written.</value>
+        public NamingStrategy? NamingStrategy { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether integer values are allowed when serializing and deserializing.
+        /// The default value is <c>true</c>.
+        /// </summary>
+        /// <value><c>true</c> if integers are allowed when serializing and deserializing; otherwise, <c>false</c>.</value>
+        public bool AllowIntegerValues { get; set; } = true;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        public StringEnumConverter()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        /// <param name="camelCaseText"><c>true</c> if the written enum text will be camel case; otherwise, <c>false</c>.</param>
+        [Obsolete("StringEnumConverter(bool) is obsolete. Create a converter with StringEnumConverter(NamingStrategy, bool) instead.")]
+        public StringEnumConverter(bool camelCaseText)
+        {
+            if (camelCaseText)
+            {
+                NamingStrategy = new CamelCaseNamingStrategy();
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        /// <param name="namingStrategy">The naming strategy used to resolve how enum text is written.</param>
+        /// <param name="allowIntegerValues"><c>true</c> if integers are allowed when serializing and deserializing; otherwise, <c>false</c>.</param>
+        public StringEnumConverter(NamingStrategy namingStrategy, bool allowIntegerValues = true)
+        {
+            NamingStrategy = namingStrategy;
+            AllowIntegerValues = allowIntegerValues;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        /// <param name="namingStrategyType">The <see cref="System.Type"/> of the <see cref="Newtonsoft.Json.Serialization.NamingStrategy"/> used to write enum text.</param>
+        public StringEnumConverter(Type namingStrategyType)
+        {
+            ValidationUtils.ArgumentNotNull(namingStrategyType, nameof(namingStrategyType));
+
+            NamingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(namingStrategyType, null);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        /// <param name="namingStrategyType">The <see cref="System.Type"/> of the <see cref="Newtonsoft.Json.Serialization.NamingStrategy"/> used to write enum text.</param>
+        /// <param name="namingStrategyParameters">
+        /// The parameter list to use when constructing the <see cref="Newtonsoft.Json.Serialization.NamingStrategy"/> described by <paramref name="namingStrategyType"/>.
+        /// If <c>null</c>, the default constructor is used.
+        /// When non-<c>null</c>, there must be a constructor defined in the <see cref="Newtonsoft.Json.Serialization.NamingStrategy"/> that exactly matches the number,
+        /// order, and type of these parameters.
+        /// </param>
+        public StringEnumConverter(Type namingStrategyType, object[] namingStrategyParameters)
+        {
+            ValidationUtils.ArgumentNotNull(namingStrategyType, nameof(namingStrategyType));
+
+            NamingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(namingStrategyType, namingStrategyParameters);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        /// <param name="namingStrategyType">The <see cref="System.Type"/> of the <see cref="Newtonsoft.Json.Serialization.NamingStrategy"/> used to write enum text.</param>
+        /// <param name="namingStrategyParameters">
+        /// The parameter list to use when constructing the <see cref="Newtonsoft.Json.Serialization.NamingStrategy"/> described by <paramref name="namingStrategyType"/>.
+        /// If <c>null</c>, the default constructor is used.
+        /// When non-<c>null</c>, there must be a constructor defined in the <see cref="Newtonsoft.Json.Serialization.NamingStrategy"/> that exactly matches the number,
+        /// order, and type of these parameters.
+        /// </param>
+        /// <param name="allowIntegerValues"><c>true</c> if integers are allowed when serializing and deserializing; otherwise, <c>false</c>.</param>
+        public StringEnumConverter(Type namingStrategyType, object[] namingStrategyParameters, bool allowIntegerValues)
+        {
+            ValidationUtils.ArgumentNotNull(namingStrategyType, nameof(namingStrategyType));
+
+            NamingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(namingStrategyType, namingStrategyParameters);
+            AllowIntegerValues = allowIntegerValues;
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            Enum e = (Enum)value;
+
+            if (!EnumUtils.TryToString(e.GetType(), value, NamingStrategy, out string? enumName))
+            {
+                if (!AllowIntegerValues)
+                {
+                    throw JsonSerializationException.Create(null, writer.ContainerPath, "Integer value {0} is not allowed.".FormatWith(CultureInfo.InvariantCulture, e.ToString("D")), null);
+                }
+
+                // enum value has no name so write number
+                writer.WriteValue(value);
+            }
+            else
+            {
+                writer.WriteValue(enumName);
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullableType(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            bool isNullable = ReflectionUtils.IsNullableType(objectType);
+            Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;
+
+            try
+            {
+                if (reader.TokenType == JsonToken.String)
+                {
+                    string? enumText = reader.Value?.ToString();
+
+                    if (StringUtils.IsNullOrEmpty(enumText) && isNullable)
+                    {
+                        return null;
+                    }
+
+                    return EnumUtils.ParseEnum(t, NamingStrategy, enumText!, !AllowIntegerValues);
+                }
+
+                if (reader.TokenType == JsonToken.Integer)
+                {
+                    if (!AllowIntegerValues)
+                    {
+                        throw JsonSerializationException.Create(reader, "Integer value {0} is not allowed.".FormatWith(CultureInfo.InvariantCulture, reader.Value));
+                    }
+
+                    return ConvertUtils.ConvertOrCast(reader.Value, CultureInfo.InvariantCulture, t);
+                }
+            }
+            catch (Exception ex)
+            {
+                throw JsonSerializationException.Create(reader, "Error converting value {0} to type '{1}'.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(reader.Value), objectType), ex);
+            }
+
+            // we don't actually expect to get here.
+            throw JsonSerializationException.Create(reader, "Unexpected token {0} when parsing enum.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+            return t.IsEnum();
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Converters/UnixDateTimeConverter.cs b/Libs/Newtonsoft.Json/Converters/UnixDateTimeConverter.cs
new file mode 100644
index 0000000..d69d224
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/UnixDateTimeConverter.cs
@@ -0,0 +1,132 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DateTime"/> to and from Unix epoch time
+    /// </summary>
+    public class UnixDateTimeConverter : DateTimeConverterBase
+    {
+        internal static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            long seconds;
+
+            if (value is DateTime dateTime)
+            {
+                seconds = (long)(dateTime.ToUniversalTime() - UnixEpoch).TotalSeconds;
+            }
+#if HAVE_DATE_TIME_OFFSET
+            else if (value is DateTimeOffset dateTimeOffset)
+            {
+                seconds = (long)(dateTimeOffset.ToUniversalTime() - UnixEpoch).TotalSeconds;
+            }
+#endif
+            else
+            {
+                throw new JsonSerializationException("Expected date object value.");
+            }
+
+            if (seconds < 0)
+            {
+                throw new JsonSerializationException("Cannot convert date value that is before Unix epoch of 00:00:00 UTC on 1 January 1970.");
+            }
+
+            writer.WriteValue(seconds);
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            bool nullable = ReflectionUtils.IsNullable(objectType);
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!nullable)
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            long seconds;
+
+            if (reader.TokenType == JsonToken.Integer)
+            {
+                seconds = (long)reader.Value!;
+            }
+            else if (reader.TokenType == JsonToken.String)
+            {
+                if (!long.TryParse((string)reader.Value!, out seconds))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert invalid value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+            }
+            else
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected Integer or String, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            if (seconds >= 0)
+            {
+                DateTime d = UnixEpoch.AddSeconds(seconds);
+
+#if HAVE_DATE_TIME_OFFSET
+                Type t = (nullable)
+                    ? Nullable.GetUnderlyingType(objectType)
+                    : objectType;
+                if (t == typeof(DateTimeOffset))
+                {
+                    return new DateTimeOffset(d, TimeSpan.Zero);
+                }
+#endif
+                return d;
+            }
+            else
+            {
+                throw JsonSerializationException.Create(reader, "Cannot convert value that is before Unix epoch of 00:00:00 UTC on 1 January 1970 to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/VersionConverter.cs b/Libs/Newtonsoft.Json/Converters/VersionConverter.cs
new file mode 100644
index 0000000..449d950
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/VersionConverter.cs
@@ -0,0 +1,106 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="Version"/> to and from a string (e.g. <c>"1.2.3.4"</c>).
+    /// </summary>
+    public class VersionConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+            }
+            else if (value is Version)
+            {
+                writer.WriteValue(value.ToString());
+            }
+            else
+            {
+                throw new JsonSerializationException("Expected Version object value");
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+            else
+            {
+                if (reader.TokenType == JsonToken.String)
+                {
+                    try
+                    {
+                        Version v = new Version((string)reader.Value!);
+                        return v;
+                    }
+                    catch (Exception ex)
+                    {
+                        throw JsonSerializationException.Create(reader, "Error parsing version string: {0}".FormatWith(CultureInfo.InvariantCulture, reader.Value), ex);
+                    }
+                }
+                else
+                {
+                    throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing version. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(Version);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Converters/XmlNodeConverter.cs b/Libs/Newtonsoft.Json/Converters/XmlNodeConverter.cs
new file mode 100644
index 0000000..1d8d320
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Converters/XmlNodeConverter.cs
@@ -0,0 +1,2222 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if (HAVE_XML_DOCUMENT || HAVE_XLINQ)
+
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Xml;
+using LC.Newtonsoft.Json.Serialization;
+#if HAVE_XLINQ
+using System.Xml.Linq;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LC.Newtonsoft.Json.Converters
+{
+    #region XmlNodeWrappers
+#if HAVE_XML_DOCUMENT
+    internal class XmlDocumentWrapper : XmlNodeWrapper, IXmlDocument
+    {
+        private readonly XmlDocument _document;
+
+        public XmlDocumentWrapper(XmlDocument document)
+            : base(document)
+        {
+            _document = document;
+        }
+
+        public IXmlNode CreateComment(string? data)
+        {
+            return new XmlNodeWrapper(_document.CreateComment(data));
+        }
+
+        public IXmlNode CreateTextNode(string? text)
+        {
+            return new XmlNodeWrapper(_document.CreateTextNode(text));
+        }
+
+        public IXmlNode CreateCDataSection(string? data)
+        {
+            return new XmlNodeWrapper(_document.CreateCDataSection(data));
+        }
+
+        public IXmlNode CreateWhitespace(string? text)
+        {
+            return new XmlNodeWrapper(_document.CreateWhitespace(text));
+        }
+
+        public IXmlNode CreateSignificantWhitespace(string? text)
+        {
+            return new XmlNodeWrapper(_document.CreateSignificantWhitespace(text));
+        }
+
+        public IXmlNode CreateXmlDeclaration(string? version, string? encoding, string? standalone)
+        {
+            return new XmlDeclarationWrapper(_document.CreateXmlDeclaration(version, encoding, standalone));
+        }
+
+#if HAVE_XML_DOCUMENT_TYPE
+        public IXmlNode CreateXmlDocumentType(string? name, string? publicId, string? systemId, string? internalSubset)
+        {
+            return new XmlDocumentTypeWrapper(_document.CreateDocumentType(name, publicId, systemId, null));
+        }
+#endif
+
+        public IXmlNode CreateProcessingInstruction(string target, string? data)
+        {
+            return new XmlNodeWrapper(_document.CreateProcessingInstruction(target, data));
+        }
+
+        public IXmlElement CreateElement(string elementName)
+        {
+            return new XmlElementWrapper(_document.CreateElement(elementName));
+        }
+
+        public IXmlElement CreateElement(string qualifiedName, string namespaceUri)
+        {
+            return new XmlElementWrapper(_document.CreateElement(qualifiedName, namespaceUri));
+        }
+
+        public IXmlNode CreateAttribute(string name, string? value)
+        {
+            XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(name));
+            attribute.Value = value;
+
+            return attribute;
+        }
+
+        public IXmlNode CreateAttribute(string qualifiedName, string namespaceUri, string? value)
+        {
+            XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(qualifiedName, namespaceUri));
+            attribute.Value = value;
+
+            return attribute;
+        }
+
+        public IXmlElement? DocumentElement
+        {
+            get
+            {
+                if (_document.DocumentElement == null)
+                {
+                    return null;
+                }
+
+                return new XmlElementWrapper(_document.DocumentElement);
+            }
+        }
+    }
+
+    internal class XmlElementWrapper : XmlNodeWrapper, IXmlElement
+    {
+        private readonly XmlElement _element;
+
+        public XmlElementWrapper(XmlElement element)
+            : base(element)
+        {
+            _element = element;
+        }
+
+        public void SetAttributeNode(IXmlNode attribute)
+        {
+            XmlNodeWrapper xmlAttributeWrapper = (XmlNodeWrapper)attribute;
+
+            _element.SetAttributeNode((XmlAttribute)xmlAttributeWrapper.WrappedNode!);
+        }
+
+        public string GetPrefixOfNamespace(string namespaceUri)
+        {
+            return _element.GetPrefixOfNamespace(namespaceUri);
+        }
+
+        public bool IsEmpty => _element.IsEmpty;
+    }
+
+    internal class XmlDeclarationWrapper : XmlNodeWrapper, IXmlDeclaration
+    {
+        private readonly XmlDeclaration _declaration;
+
+        public XmlDeclarationWrapper(XmlDeclaration declaration)
+            : base(declaration)
+        {
+            _declaration = declaration;
+        }
+
+        public string Version => _declaration.Version;
+
+        public string Encoding
+        {
+            get => _declaration.Encoding;
+            set => _declaration.Encoding = value;
+        }
+
+        public string Standalone
+        {
+            get => _declaration.Standalone;
+            set => _declaration.Standalone = value;
+        }
+    }
+
+#if HAVE_XML_DOCUMENT_TYPE
+    internal class XmlDocumentTypeWrapper : XmlNodeWrapper, IXmlDocumentType
+    {
+        private readonly XmlDocumentType _documentType;
+
+        public XmlDocumentTypeWrapper(XmlDocumentType documentType)
+            : base(documentType)
+        {
+            _documentType = documentType;
+        }
+
+        public string Name => _documentType.Name;
+
+        public string System => _documentType.SystemId;
+
+        public string Public => _documentType.PublicId;
+
+        public string InternalSubset => _documentType.InternalSubset;
+
+        public override string? LocalName => "DOCTYPE";
+    }
+#endif
+
+    internal class XmlNodeWrapper : IXmlNode
+    {
+        private readonly XmlNode _node;
+        private List<IXmlNode>? _childNodes;
+        private List<IXmlNode>? _attributes;
+
+        public XmlNodeWrapper(XmlNode node)
+        {
+            _node = node;
+        }
+
+        public object? WrappedNode => _node;
+
+        public XmlNodeType NodeType => _node.NodeType;
+
+        public virtual string? LocalName => _node.LocalName;
+
+        public List<IXmlNode> ChildNodes
+        {
+            get
+            {
+                // childnodes is read multiple times
+                // cache results to prevent multiple reads which kills perf in large documents
+                if (_childNodes == null)
+                {
+                    if (!_node.HasChildNodes)
+                    {
+                        _childNodes = XmlNodeConverter.EmptyChildNodes;
+                    }
+                    else
+                    {
+                        _childNodes = new List<IXmlNode>(_node.ChildNodes.Count);
+                        foreach (XmlNode childNode in _node.ChildNodes)
+                        {
+                            _childNodes.Add(WrapNode(childNode));
+                        }
+                    }
+                }
+
+                return _childNodes;
+            }
+        }
+
+        protected virtual bool HasChildNodes => _node.HasChildNodes;
+
+        internal static IXmlNode WrapNode(XmlNode node)
+        {
+            switch (node.NodeType)
+            {
+                case XmlNodeType.Element:
+                    return new XmlElementWrapper((XmlElement)node);
+                case XmlNodeType.XmlDeclaration:
+                    return new XmlDeclarationWrapper((XmlDeclaration)node);
+#if HAVE_XML_DOCUMENT_TYPE
+                case XmlNodeType.DocumentType:
+                    return new XmlDocumentTypeWrapper((XmlDocumentType)node);
+#endif
+                default:
+                    return new XmlNodeWrapper(node);
+            }
+        }
+
+        public List<IXmlNode> Attributes
+        {
+            get
+            {
+                // attributes is read multiple times
+                // cache results to prevent multiple reads which kills perf in large documents
+                if (_attributes == null)
+                {
+                    if (!HasAttributes)
+                    {
+                        _attributes = XmlNodeConverter.EmptyChildNodes;
+                    }
+                    else
+                    {
+                        _attributes = new List<IXmlNode>(_node.Attributes.Count);
+                        foreach (XmlAttribute attribute in _node.Attributes)
+                        {
+                            _attributes.Add(WrapNode(attribute));
+                        }
+                    }
+                }
+
+                return _attributes;
+            }
+        }
+
+        private bool HasAttributes
+        {
+            get
+            {
+                if (_node is XmlElement element)
+                {
+                    return element.HasAttributes;
+                }
+
+                return _node.Attributes?.Count > 0;
+            }
+        }
+
+        public IXmlNode? ParentNode
+        {
+            get
+            {
+                XmlNode node = _node is XmlAttribute attribute ? attribute.OwnerElement : _node.ParentNode;
+
+                if (node == null)
+                {
+                    return null;
+                }
+
+                return WrapNode(node);
+            }
+        }
+
+        public string? Value
+        {
+            get => _node.Value;
+            set => _node.Value = value;
+        }
+
+        public IXmlNode AppendChild(IXmlNode newChild)
+        {
+            XmlNodeWrapper xmlNodeWrapper = (XmlNodeWrapper)newChild;
+            _node.AppendChild(xmlNodeWrapper._node);
+            _childNodes = null;
+            _attributes = null;
+
+            return newChild;
+        }
+
+        public string? NamespaceUri => _node.NamespaceURI;
+    }
+#endif
+#endregion
+
+#region Interfaces
+    internal interface IXmlDocument : IXmlNode
+    {
+        IXmlNode CreateComment(string? text);
+        IXmlNode CreateTextNode(string? text);
+        IXmlNode CreateCDataSection(string? data);
+        IXmlNode CreateWhitespace(string? text);
+        IXmlNode CreateSignificantWhitespace(string? text);
+        IXmlNode CreateXmlDeclaration(string? version, string? encoding, string? standalone);
+#if HAVE_XML_DOCUMENT_TYPE
+        IXmlNode CreateXmlDocumentType(string? name, string? publicId, string? systemId, string? internalSubset);
+#endif
+        IXmlNode CreateProcessingInstruction(string target, string? data);
+        IXmlElement CreateElement(string elementName);
+        IXmlElement CreateElement(string qualifiedName, string namespaceUri);
+        IXmlNode CreateAttribute(string name, string? value);
+        IXmlNode CreateAttribute(string qualifiedName, string namespaceUri, string? value);
+
+        IXmlElement? DocumentElement { get; }
+    }
+
+    internal interface IXmlDeclaration : IXmlNode
+    {
+        string Version { get; }
+        string Encoding { get; set; }
+        string Standalone { get; set; }
+    }
+
+    internal interface IXmlDocumentType : IXmlNode
+    {
+        string Name { get; }
+        string System { get; }
+        string Public { get; }
+        string InternalSubset { get; }
+    }
+
+    internal interface IXmlElement : IXmlNode
+    {
+        void SetAttributeNode(IXmlNode attribute);
+        string GetPrefixOfNamespace(string namespaceUri);
+        bool IsEmpty { get; }
+    }
+
+    internal interface IXmlNode
+    {
+        XmlNodeType NodeType { get; }
+        string? LocalName { get; }
+        List<IXmlNode> ChildNodes { get; }
+        List<IXmlNode> Attributes { get; }
+        IXmlNode? ParentNode { get; }
+        string? Value { get; set; }
+        IXmlNode AppendChild(IXmlNode newChild);
+        string? NamespaceUri { get; }
+        object? WrappedNode { get; }
+    }
+#endregion
+
+#region XNodeWrappers
+#if HAVE_XLINQ
+    internal class XDeclarationWrapper : XObjectWrapper, IXmlDeclaration
+    {
+        internal XDeclaration Declaration { get; }
+
+        public XDeclarationWrapper(XDeclaration declaration)
+            : base(null)
+        {
+            Declaration = declaration;
+        }
+
+        public override XmlNodeType NodeType => XmlNodeType.XmlDeclaration;
+
+        public string Version => Declaration.Version;
+
+        public string Encoding
+        {
+            get => Declaration.Encoding;
+            set => Declaration.Encoding = value;
+        }
+
+        public string Standalone
+        {
+            get => Declaration.Standalone;
+            set => Declaration.Standalone = value;
+        }
+    }
+
+    internal class XDocumentTypeWrapper : XObjectWrapper, IXmlDocumentType
+    {
+        private readonly XDocumentType _documentType;
+
+        public XDocumentTypeWrapper(XDocumentType documentType)
+            : base(documentType)
+        {
+            _documentType = documentType;
+        }
+
+        public string Name => _documentType.Name;
+
+        public string System => _documentType.SystemId;
+
+        public string Public => _documentType.PublicId;
+
+        public string InternalSubset => _documentType.InternalSubset;
+
+        public override string? LocalName => "DOCTYPE";
+    }
+
+    internal class XDocumentWrapper : XContainerWrapper, IXmlDocument
+    {
+        private XDocument Document => (XDocument)WrappedNode!;
+
+        public XDocumentWrapper(XDocument document)
+            : base(document)
+        {
+        }
+
+        public override List<IXmlNode> ChildNodes
+        {
+            get
+            {
+                List<IXmlNode> childNodes = base.ChildNodes;
+                if (Document.Declaration != null && (childNodes.Count == 0 || childNodes[0].NodeType != XmlNodeType.XmlDeclaration))
+                {
+                    childNodes.Insert(0, new XDeclarationWrapper(Document.Declaration));
+                }
+
+                return childNodes;
+            }
+        }
+
+        protected override bool HasChildNodes
+        {
+            get
+            {
+                if (base.HasChildNodes)
+                {
+                    return true;
+                }
+
+                return Document.Declaration != null;
+            }
+        }
+
+        public IXmlNode CreateComment(string? text)
+        {
+            return new XObjectWrapper(new XComment(text));
+        }
+
+        public IXmlNode CreateTextNode(string? text)
+        {
+            return new XObjectWrapper(new XText(text));
+        }
+
+        public IXmlNode CreateCDataSection(string? data)
+        {
+            return new XObjectWrapper(new XCData(data));
+        }
+
+        public IXmlNode CreateWhitespace(string? text)
+        {
+            return new XObjectWrapper(new XText(text));
+        }
+
+        public IXmlNode CreateSignificantWhitespace(string? text)
+        {
+            return new XObjectWrapper(new XText(text));
+        }
+
+        public IXmlNode CreateXmlDeclaration(string? version, string? encoding, string? standalone)
+        {
+            return new XDeclarationWrapper(new XDeclaration(version, encoding, standalone));
+        }
+
+        public IXmlNode CreateXmlDocumentType(string? name, string? publicId, string? systemId, string? internalSubset)
+        {
+            return new XDocumentTypeWrapper(new XDocumentType(name, publicId, systemId, internalSubset));
+        }
+
+        public IXmlNode CreateProcessingInstruction(string target, string? data)
+        {
+            return new XProcessingInstructionWrapper(new XProcessingInstruction(target, data));
+        }
+
+        public IXmlElement CreateElement(string elementName)
+        {
+            return new XElementWrapper(new XElement(elementName));
+        }
+
+        public IXmlElement CreateElement(string qualifiedName, string namespaceUri)
+        {
+            string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
+            return new XElementWrapper(new XElement(XName.Get(localName, namespaceUri)));
+        }
+
+        public IXmlNode CreateAttribute(string name, string? value)
+        {
+            return new XAttributeWrapper(new XAttribute(name, value));
+        }
+
+        public IXmlNode CreateAttribute(string qualifiedName, string namespaceUri, string? value)
+        {
+            string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
+            return new XAttributeWrapper(new XAttribute(XName.Get(localName, namespaceUri), value));
+        }
+
+        public IXmlElement? DocumentElement
+        {
+            get
+            {
+                if (Document.Root == null)
+                {
+                    return null;
+                }
+
+                return new XElementWrapper(Document.Root);
+            }
+        }
+
+        public override IXmlNode AppendChild(IXmlNode newChild)
+        {
+            if (newChild is XDeclarationWrapper declarationWrapper)
+            {
+                Document.Declaration = declarationWrapper.Declaration;
+                return declarationWrapper;
+            }
+            else
+            {
+                return base.AppendChild(newChild);
+            }
+        }
+    }
+
+    internal class XTextWrapper : XObjectWrapper
+    {
+        private XText Text => (XText)WrappedNode!;
+
+        public XTextWrapper(XText text)
+            : base(text)
+        {
+        }
+
+        public override string? Value
+        {
+            get => Text.Value;
+            set => Text.Value = value;
+        }
+
+        public override IXmlNode? ParentNode
+        {
+            get
+            {
+                if (Text.Parent == null)
+                {
+                    return null;
+                }
+
+                return XContainerWrapper.WrapNode(Text.Parent);
+            }
+        }
+    }
+
+    internal class XCommentWrapper : XObjectWrapper
+    {
+        private XComment Text => (XComment)WrappedNode!;
+
+        public XCommentWrapper(XComment text)
+            : base(text)
+        {
+        }
+
+        public override string? Value
+        {
+            get => Text.Value;
+            set => Text.Value = value;
+        }
+
+        public override IXmlNode? ParentNode
+        {
+            get
+            {
+                if (Text.Parent == null)
+                {
+                    return null;
+                }
+
+                return XContainerWrapper.WrapNode(Text.Parent);
+            }
+        }
+    }
+
+    internal class XProcessingInstructionWrapper : XObjectWrapper
+    {
+        private XProcessingInstruction ProcessingInstruction => (XProcessingInstruction)WrappedNode!;
+
+        public XProcessingInstructionWrapper(XProcessingInstruction processingInstruction)
+            : base(processingInstruction)
+        {
+        }
+
+        public override string? LocalName => ProcessingInstruction.Target;
+
+        public override string? Value
+        {
+            get => ProcessingInstruction.Data;
+            set => ProcessingInstruction.Data = value;
+        }
+    }
+
+    internal class XContainerWrapper : XObjectWrapper
+    {
+        private List<IXmlNode>? _childNodes;
+
+        private XContainer Container => (XContainer)WrappedNode!;
+
+        public XContainerWrapper(XContainer container)
+            : base(container)
+        {
+        }
+
+        public override List<IXmlNode> ChildNodes
+        {
+            get
+            {
+                // childnodes is read multiple times
+                // cache results to prevent multiple reads which kills perf in large documents
+                if (_childNodes == null)
+                {
+                    if (!HasChildNodes)
+                    {
+                        _childNodes = XmlNodeConverter.EmptyChildNodes;
+                    }
+                    else
+                    {
+                        _childNodes = new List<IXmlNode>();
+                        foreach (XNode node in Container.Nodes())
+                        {
+                            _childNodes.Add(WrapNode(node));
+                        }
+                    }
+                }
+
+                return _childNodes;
+            }
+        }
+
+        protected virtual bool HasChildNodes => Container.LastNode != null;
+
+        public override IXmlNode? ParentNode
+        {
+            get
+            {
+                if (Container.Parent == null)
+                {
+                    return null;
+                }
+
+                return WrapNode(Container.Parent);
+            }
+        }
+
+        internal static IXmlNode WrapNode(XObject node)
+        {
+            if (node is XDocument document)
+            {
+                return new XDocumentWrapper(document);
+            }
+
+            if (node is XElement element)
+            {
+                return new XElementWrapper(element);
+            }
+
+            if (node is XContainer container)
+            {
+                return new XContainerWrapper(container);
+            }
+
+            if (node is XProcessingInstruction pi)
+            {
+                return new XProcessingInstructionWrapper(pi);
+            }
+
+            if (node is XText text)
+            {
+                return new XTextWrapper(text);
+            }
+
+            if (node is XComment comment)
+            {
+                return new XCommentWrapper(comment);
+            }
+
+            if (node is XAttribute attribute)
+            {
+                return new XAttributeWrapper(attribute);
+            }
+
+            if (node is XDocumentType type)
+            {
+                return new XDocumentTypeWrapper(type);
+            }
+
+            return new XObjectWrapper(node);
+        }
+
+        public override IXmlNode AppendChild(IXmlNode newChild)
+        {
+            Container.Add(newChild.WrappedNode);
+            _childNodes = null;
+
+            return newChild;
+        }
+    }
+
+    internal class XObjectWrapper : IXmlNode
+    {
+        private readonly XObject? _xmlObject;
+
+        public XObjectWrapper(XObject? xmlObject)
+        {
+            _xmlObject = xmlObject;
+        }
+
+        public object? WrappedNode => _xmlObject;
+
+        public virtual XmlNodeType NodeType => _xmlObject?.NodeType ?? XmlNodeType.None;
+
+        public virtual string? LocalName => null;
+
+        public virtual List<IXmlNode> ChildNodes => XmlNodeConverter.EmptyChildNodes;
+
+        public virtual List<IXmlNode> Attributes => XmlNodeConverter.EmptyChildNodes;
+
+        public virtual IXmlNode? ParentNode => null;
+
+        public virtual string? Value
+        {
+            get => null;
+            set => throw new InvalidOperationException();
+        }
+
+        public virtual IXmlNode AppendChild(IXmlNode newChild)
+        {
+            throw new InvalidOperationException();
+        }
+
+        public virtual string? NamespaceUri => null;
+    }
+
+    internal class XAttributeWrapper : XObjectWrapper
+    {
+        private XAttribute Attribute => (XAttribute)WrappedNode!;
+
+        public XAttributeWrapper(XAttribute attribute)
+            : base(attribute)
+        {
+        }
+
+        public override string? Value
+        {
+            get => Attribute.Value;
+            set => Attribute.Value = value;
+        }
+
+        public override string? LocalName => Attribute.Name.LocalName;
+
+        public override string? NamespaceUri => Attribute.Name.NamespaceName;
+
+        public override IXmlNode? ParentNode
+        {
+            get
+            {
+                if (Attribute.Parent == null)
+                {
+                    return null;
+                }
+
+                return XContainerWrapper.WrapNode(Attribute.Parent);
+            }
+        }
+    }
+
+    internal class XElementWrapper : XContainerWrapper, IXmlElement
+    {
+        private List<IXmlNode>? _attributes;
+
+        private XElement Element => (XElement)WrappedNode!;
+
+        public XElementWrapper(XElement element)
+            : base(element)
+        {
+        }
+
+        public void SetAttributeNode(IXmlNode attribute)
+        {
+            XObjectWrapper wrapper = (XObjectWrapper)attribute;
+            Element.Add(wrapper.WrappedNode);
+            _attributes = null;
+        }
+
+        public override List<IXmlNode> Attributes
+        {
+            get
+            {
+                // attributes is read multiple times
+                // cache results to prevent multiple reads which kills perf in large documents
+                if (_attributes == null)
+                {
+                    if (!Element.HasAttributes && !HasImplicitNamespaceAttribute(NamespaceUri!))
+                    {
+                        _attributes = XmlNodeConverter.EmptyChildNodes;
+                    }
+                    else
+                    {
+                        _attributes = new List<IXmlNode>();
+                        foreach (XAttribute attribute in Element.Attributes())
+                        {
+                            _attributes.Add(new XAttributeWrapper(attribute));
+                        }
+
+                        // ensure elements created with a namespace but no namespace attribute are converted correctly
+                        // e.g. new XElement("{http://example.com}MyElement");
+                        string namespaceUri = NamespaceUri!;
+                        if (HasImplicitNamespaceAttribute(namespaceUri))
+                        {
+                            _attributes.Insert(0, new XAttributeWrapper(new XAttribute("xmlns", namespaceUri)));
+                        }
+                    }
+                }
+
+                return _attributes;
+            }
+        }
+
+        private bool HasImplicitNamespaceAttribute(string namespaceUri)
+        {
+            if (!StringUtils.IsNullOrEmpty(namespaceUri) && namespaceUri != ParentNode?.NamespaceUri)
+            {
+                if (StringUtils.IsNullOrEmpty(GetPrefixOfNamespace(namespaceUri)))
+                {
+                    bool namespaceDeclared = false;
+
+                    if (Element.HasAttributes)
+                    {
+                        foreach (XAttribute attribute in Element.Attributes())
+                        {
+                            if (attribute.Name.LocalName == "xmlns" && StringUtils.IsNullOrEmpty(attribute.Name.NamespaceName) && attribute.Value == namespaceUri)
+                            {
+                                namespaceDeclared = true;
+                            }
+                        }
+                    }
+
+                    if (!namespaceDeclared)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public override IXmlNode AppendChild(IXmlNode newChild)
+        {
+            IXmlNode result = base.AppendChild(newChild);
+            _attributes = null;
+            return result;
+        }
+
+        public override string? Value
+        {
+            get => Element.Value;
+            set => Element.Value = value;
+        }
+
+        public override string? LocalName => Element.Name.LocalName;
+
+        public override string? NamespaceUri => Element.Name.NamespaceName;
+
+        public string GetPrefixOfNamespace(string namespaceUri)
+        {
+            return Element.GetPrefixOfNamespace(namespaceUri);
+        }
+
+        public bool IsEmpty => Element.IsEmpty;
+    }
+#endif
+#endregion
+
+    /// <summary>
+    /// Converts XML to and from JSON.
+    /// </summary>
+    public class XmlNodeConverter : JsonConverter
+    {
+        internal static readonly List<IXmlNode> EmptyChildNodes = new List<IXmlNode>();
+
+        private const string TextName = "#text";
+        private const string CommentName = "#comment";
+        private const string CDataName = "#cdata-section";
+        private const string WhitespaceName = "#whitespace";
+        private const string SignificantWhitespaceName = "#significant-whitespace";
+        private const string DeclarationName = "?xml";
+        private const string JsonNamespaceUri = "http://james.newtonking.com/projects/json";
+
+        /// <summary>
+        /// Gets or sets the name of the root element to insert when deserializing to XML if the JSON structure has produced multiple root elements.
+        /// </summary>
+        /// <value>The name of the deserialized root element.</value>
+        public string? DeserializeRootElementName { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value to indicate whether to write the Json.NET array attribute.
+        /// This attribute helps preserve arrays when converting the written XML back to JSON.
+        /// </summary>
+        /// <value><c>true</c> if the array attribute is written to the XML; otherwise, <c>false</c>.</value>
+        public bool WriteArrayAttribute { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to write the root JSON object.
+        /// </summary>
+        /// <value><c>true</c> if the JSON root object is omitted; otherwise, <c>false</c>.</value>
+        public bool OmitRootObject { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to encode special characters when converting JSON to XML.
+        /// If <c>true</c>, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify
+        /// XML namespaces, attributes or processing directives. Instead special characters are encoded and written
+        /// as part of the XML element name.
+        /// </summary>
+        /// <value><c>true</c> if special characters are encoded; otherwise, <c>false</c>.</value>
+        public bool EncodeSpecialCharacters { get; set; }
+
+        #region Writing
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <param name="value">The value.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            IXmlNode node = WrapXml(value);
+
+            XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
+            PushParentNamespaces(node, manager);
+
+            if (!OmitRootObject)
+            {
+                writer.WriteStartObject();
+            }
+
+            SerializeNode(writer, node, manager, !OmitRootObject);
+
+            if (!OmitRootObject)
+            {
+                writer.WriteEndObject();
+            }
+        }
+
+        private IXmlNode WrapXml(object value)
+        {
+#if HAVE_XLINQ
+            if (value is XObject xObject)
+            {
+                return XContainerWrapper.WrapNode(xObject);
+            }
+#endif
+#if HAVE_XML_DOCUMENT
+            if (value is XmlNode node)
+            {
+                return XmlNodeWrapper.WrapNode(node);
+            }
+#endif
+
+            throw new ArgumentException("Value must be an XML object.", nameof(value));
+        }
+
+        private void PushParentNamespaces(IXmlNode node, XmlNamespaceManager manager)
+        {
+            List<IXmlNode>? parentElements = null;
+
+            IXmlNode? parent = node;
+            while ((parent = parent.ParentNode) != null)
+            {
+                if (parent.NodeType == XmlNodeType.Element)
+                {
+                    if (parentElements == null)
+                    {
+                        parentElements = new List<IXmlNode>();
+                    }
+
+                    parentElements.Add(parent);
+                }
+            }
+
+            if (parentElements != null)
+            {
+                parentElements.Reverse();
+
+                foreach (IXmlNode parentElement in parentElements)
+                {
+                    manager.PushScope();
+                    foreach (IXmlNode attribute in parentElement.Attributes)
+                    {
+                        if (attribute.NamespaceUri == "http://www.w3.org/2000/xmlns/" && attribute.LocalName != "xmlns")
+                        {
+                            manager.AddNamespace(attribute.LocalName, attribute.Value);
+                        }
+                    }
+                }
+            }
+        }
+
+        private string ResolveFullName(IXmlNode node, XmlNamespaceManager manager)
+        {
+            string? prefix = (node.NamespaceUri == null || (node.LocalName == "xmlns" && node.NamespaceUri == "http://www.w3.org/2000/xmlns/"))
+                ? null
+                : manager.LookupPrefix(node.NamespaceUri);
+
+            if (!StringUtils.IsNullOrEmpty(prefix))
+            {
+                return prefix + ":" + XmlConvert.DecodeName(node.LocalName);
+            }
+            else
+            {
+                return XmlConvert.DecodeName(node.LocalName);
+            }
+        }
+
+        private string GetPropertyName(IXmlNode node, XmlNamespaceManager manager)
+        {
+            switch (node.NodeType)
+            {
+                case XmlNodeType.Attribute:
+                    if (node.NamespaceUri == JsonNamespaceUri)
+                    {
+                        return "$" + node.LocalName;
+                    }
+                    else
+                    {
+                        return "@" + ResolveFullName(node, manager);
+                    }
+                case XmlNodeType.CDATA:
+                    return CDataName;
+                case XmlNodeType.Comment:
+                    return CommentName;
+                case XmlNodeType.Element:
+                    if (node.NamespaceUri == JsonNamespaceUri)
+                    {
+                        return "$" + node.LocalName;
+                    }
+                    else
+                    {
+                        return ResolveFullName(node, manager);
+                    }
+                case XmlNodeType.ProcessingInstruction:
+                    return "?" + ResolveFullName(node, manager);
+                case XmlNodeType.DocumentType:
+                    return "!" + ResolveFullName(node, manager);
+                case XmlNodeType.XmlDeclaration:
+                    return DeclarationName;
+                case XmlNodeType.SignificantWhitespace:
+                    return SignificantWhitespaceName;
+                case XmlNodeType.Text:
+                    return TextName;
+                case XmlNodeType.Whitespace:
+                    return WhitespaceName;
+                default:
+                    throw new JsonSerializationException("Unexpected XmlNodeType when getting node name: " + node.NodeType);
+            }
+        }
+
+        private bool IsArray(IXmlNode node)
+        {
+            foreach (IXmlNode attribute in node.Attributes)
+            {
+                if (attribute.LocalName == "Array" && attribute.NamespaceUri == JsonNamespaceUri)
+                {
+                    return XmlConvert.ToBoolean(attribute.Value);
+                }
+            }
+
+            return false;
+        }
+
+        private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
+        {
+            switch (node.ChildNodes.Count)
+            {
+                case 0:
+                {
+                    // nothing to serialize
+                    break;
+                }
+                case 1:
+                {
+                    // avoid grouping when there is only one node
+                    string nodeName = GetPropertyName(node.ChildNodes[0], manager);
+                    WriteGroupedNodes(writer, manager, writePropertyName, node.ChildNodes, nodeName);
+                    break;
+                }
+                default:
+                {
+                    // check whether nodes have the same name
+                    // if they don't then group into dictionary together by name
+
+                    // value of dictionary will be a single IXmlNode when there is one for a name,
+                    // or a List<IXmlNode> when there are multiple
+                    Dictionary<string, object>? nodesGroupedByName = null;
+
+                    string? nodeName = null;
+
+                    for (int i = 0; i < node.ChildNodes.Count; i++)
+                    {
+                        IXmlNode childNode = node.ChildNodes[i];
+                        string currentNodeName = GetPropertyName(childNode, manager);
+
+                        if (nodesGroupedByName == null)
+                        {
+                            if (nodeName == null)
+                            {
+                                nodeName = currentNodeName;
+                            }
+                            else if (currentNodeName == nodeName)
+                            {
+                                // current node name matches others
+                            }
+                            else
+                            {
+                                nodesGroupedByName = new Dictionary<string, object>();
+                                if (i > 1)
+                                {
+                                    List<IXmlNode> nodes = new List<IXmlNode>(i);
+                                    for (int j = 0; j < i; j++)
+                                    {
+                                        nodes.Add(node.ChildNodes[j]);
+                                    }
+                                    nodesGroupedByName.Add(nodeName, nodes);
+                                }
+                                else
+                                {
+                                    nodesGroupedByName.Add(nodeName, node.ChildNodes[0]);
+                                }
+                                nodesGroupedByName.Add(currentNodeName, childNode);
+                            }
+                        }
+                        else
+                        {
+                            if (!nodesGroupedByName.TryGetValue(currentNodeName, out object value))
+                            {
+                                nodesGroupedByName.Add(currentNodeName, childNode);
+                            }
+                            else
+                            {
+                                if (!(value is List<IXmlNode> nodes))
+                                {
+                                    nodes = new List<IXmlNode> {(IXmlNode)value!};
+                                    nodesGroupedByName[currentNodeName] = nodes;
+                                }
+
+                                nodes.Add(childNode);
+                            }
+                        }
+                    }
+
+                    if (nodesGroupedByName == null)
+                    {
+                        WriteGroupedNodes(writer, manager, writePropertyName, node.ChildNodes, nodeName!);
+                    }
+                    else
+                    {
+                        // loop through grouped nodes. write single name instances as normal,
+                        // write multiple names together in an array
+                        foreach (KeyValuePair<string, object> nodeNameGroup in nodesGroupedByName)
+                        {
+                            if (nodeNameGroup.Value is List<IXmlNode> nodes)
+                            {
+                                WriteGroupedNodes(writer, manager, writePropertyName, nodes, nodeNameGroup.Key);
+                            }
+                            else
+                            {
+                                WriteGroupedNodes(writer, manager, writePropertyName, (IXmlNode)nodeNameGroup.Value, nodeNameGroup.Key);
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+
+        private void WriteGroupedNodes(JsonWriter writer, XmlNamespaceManager manager, bool writePropertyName, List<IXmlNode> groupedNodes, string elementNames)
+        {
+            bool writeArray = groupedNodes.Count != 1 || IsArray(groupedNodes[0]);
+
+            if (!writeArray)
+            {
+                SerializeNode(writer, groupedNodes[0], manager, writePropertyName);
+            }
+            else
+            {
+                if (writePropertyName)
+                {
+                    writer.WritePropertyName(elementNames);
+                }
+
+                writer.WriteStartArray();
+
+                for (int i = 0; i < groupedNodes.Count; i++)
+                {
+                    SerializeNode(writer, groupedNodes[i], manager, false);
+                }
+
+                writer.WriteEndArray();
+            }
+        }
+
+        private void WriteGroupedNodes(JsonWriter writer, XmlNamespaceManager manager, bool writePropertyName, IXmlNode node, string elementNames)
+        {
+            bool writeArray = IsArray(node);
+
+            if (!writeArray)
+            {
+                SerializeNode(writer, node, manager, writePropertyName);
+            }
+            else
+            {
+                if (writePropertyName)
+                {
+                    writer.WritePropertyName(elementNames);
+                }
+
+                writer.WriteStartArray();
+
+                SerializeNode(writer, node, manager, false);
+
+                writer.WriteEndArray();
+            }
+        }
+
+        private void SerializeNode(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
+        {
+            switch (node.NodeType)
+            {
+                case XmlNodeType.Document:
+                case XmlNodeType.DocumentFragment:
+                    SerializeGroupedNodes(writer, node, manager, writePropertyName);
+                    break;
+                case XmlNodeType.Element:
+                    if (IsArray(node) && AllSameName(node) && node.ChildNodes.Count > 0)
+                    {
+                        SerializeGroupedNodes(writer, node, manager, false);
+                    }
+                    else
+                    {
+                        manager.PushScope();
+
+                        foreach (IXmlNode attribute in node.Attributes)
+                        {
+                            if (attribute.NamespaceUri == "http://www.w3.org/2000/xmlns/")
+                            {
+                                string namespacePrefix = (attribute.LocalName != "xmlns")
+                                    ? XmlConvert.DecodeName(attribute.LocalName)
+                                    : string.Empty;
+                                string? namespaceUri = attribute.Value;
+                                if (namespaceUri == null)
+                                {
+                                    throw new JsonSerializationException("Namespace attribute must have a value.");
+                                }
+
+                                manager.AddNamespace(namespacePrefix, namespaceUri);
+                            }
+                        }
+
+                        if (writePropertyName)
+                        {
+                            writer.WritePropertyName(GetPropertyName(node, manager));
+                        }
+
+                        if (!ValueAttributes(node.Attributes) && node.ChildNodes.Count == 1
+                            && node.ChildNodes[0].NodeType == XmlNodeType.Text)
+                        {
+                            // write elements with a single text child as a name value pair
+                            writer.WriteValue(node.ChildNodes[0].Value);
+                        }
+                        else if (node.ChildNodes.Count == 0 && node.Attributes.Count == 0)
+                        {
+                            IXmlElement element = (IXmlElement)node;
+
+                            // empty element
+                            if (element.IsEmpty)
+                            {
+                                writer.WriteNull();
+                            }
+                            else
+                            {
+                                writer.WriteValue(string.Empty);
+                            }
+                        }
+                        else
+                        {
+                            writer.WriteStartObject();
+
+                            for (int i = 0; i < node.Attributes.Count; i++)
+                            {
+                                SerializeNode(writer, node.Attributes[i], manager, true);
+                            }
+
+                            SerializeGroupedNodes(writer, node, manager, true);
+
+                            writer.WriteEndObject();
+                        }
+
+                        manager.PopScope();
+                    }
+
+                    break;
+                case XmlNodeType.Comment:
+                    if (writePropertyName)
+                    {
+                        writer.WriteComment(node.Value);
+                    }
+                    break;
+                case XmlNodeType.Attribute:
+                case XmlNodeType.Text:
+                case XmlNodeType.CDATA:
+                case XmlNodeType.ProcessingInstruction:
+                case XmlNodeType.Whitespace:
+                case XmlNodeType.SignificantWhitespace:
+                    if (node.NamespaceUri == "http://www.w3.org/2000/xmlns/" && node.Value == JsonNamespaceUri)
+                    {
+                        return;
+                    }
+
+                    if (node.NamespaceUri == JsonNamespaceUri)
+                    {
+                        if (node.LocalName == "Array")
+                        {
+                            return;
+                        }
+                    }
+
+                    if (writePropertyName)
+                    {
+                        writer.WritePropertyName(GetPropertyName(node, manager));
+                    }
+                    writer.WriteValue(node.Value);
+                    break;
+                case XmlNodeType.XmlDeclaration:
+                    IXmlDeclaration declaration = (IXmlDeclaration)node;
+                    writer.WritePropertyName(GetPropertyName(node, manager));
+                    writer.WriteStartObject();
+
+                    if (!StringUtils.IsNullOrEmpty(declaration.Version))
+                    {
+                        writer.WritePropertyName("@version");
+                        writer.WriteValue(declaration.Version);
+                    }
+                    if (!StringUtils.IsNullOrEmpty(declaration.Encoding))
+                    {
+                        writer.WritePropertyName("@encoding");
+                        writer.WriteValue(declaration.Encoding);
+                    }
+                    if (!StringUtils.IsNullOrEmpty(declaration.Standalone))
+                    {
+                        writer.WritePropertyName("@standalone");
+                        writer.WriteValue(declaration.Standalone);
+                    }
+
+                    writer.WriteEndObject();
+                    break;
+                case XmlNodeType.DocumentType:
+                    IXmlDocumentType documentType = (IXmlDocumentType)node;
+                    writer.WritePropertyName(GetPropertyName(node, manager));
+                    writer.WriteStartObject();
+
+                    if (!StringUtils.IsNullOrEmpty(documentType.Name))
+                    {
+                        writer.WritePropertyName("@name");
+                        writer.WriteValue(documentType.Name);
+                    }
+                    if (!StringUtils.IsNullOrEmpty(documentType.Public))
+                    {
+                        writer.WritePropertyName("@public");
+                        writer.WriteValue(documentType.Public);
+                    }
+                    if (!StringUtils.IsNullOrEmpty(documentType.System))
+                    {
+                        writer.WritePropertyName("@system");
+                        writer.WriteValue(documentType.System);
+                    }
+                    if (!StringUtils.IsNullOrEmpty(documentType.InternalSubset))
+                    {
+                        writer.WritePropertyName("@internalSubset");
+                        writer.WriteValue(documentType.InternalSubset);
+                    }
+
+                    writer.WriteEndObject();
+                    break;
+                default:
+                    throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
+            }
+        }
+
+        private static bool AllSameName(IXmlNode node)
+        {
+            foreach (IXmlNode childNode in node.ChildNodes)
+            {
+                if (childNode.LocalName != node.LocalName)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+#endregion
+
+        #region Reading
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            switch (reader.TokenType)
+            {
+                case JsonToken.Null:
+                    return null;
+                case JsonToken.StartObject:
+                    break;
+                default:
+                    throw JsonSerializationException.Create(reader, "XmlNodeConverter can only convert JSON that begins with an object.");
+            }
+
+            XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
+            IXmlDocument? document = null;
+            IXmlNode? rootNode = null;
+
+#if HAVE_XLINQ
+            if (typeof(XObject).IsAssignableFrom(objectType))
+            {
+                if (objectType != typeof(XContainer)
+                    && objectType != typeof(XDocument)
+                    && objectType != typeof(XElement)
+                    && objectType != typeof(XNode)
+                    && objectType != typeof(XObject))
+                {
+                    throw JsonSerializationException.Create(reader, "XmlNodeConverter only supports deserializing XDocument, XElement, XContainer, XNode or XObject.");
+                }
+
+                XDocument d = new XDocument();
+                document = new XDocumentWrapper(d);
+                rootNode = document;
+            }
+#endif
+#if HAVE_XML_DOCUMENT
+            if (typeof(XmlNode).IsAssignableFrom(objectType))
+            {
+                if (objectType != typeof(XmlDocument)
+                    && objectType != typeof(XmlElement)
+                    && objectType != typeof(XmlNode))
+                {
+                    throw JsonSerializationException.Create(reader, "XmlNodeConverter only supports deserializing XmlDocument, XmlElement or XmlNode.");
+                }
+
+                XmlDocument d = new XmlDocument();
+#if HAVE_XML_DOCUMENT_TYPE
+                // prevent http request when resolving any DTD references
+                d.XmlResolver = null;
+#endif
+
+                document = new XmlDocumentWrapper(d);
+                rootNode = document;
+            }
+#endif
+
+            if (document == null || rootNode == null)
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected type when converting XML: " + objectType);
+            }
+
+            if (!StringUtils.IsNullOrEmpty(DeserializeRootElementName))
+            {
+                ReadElement(reader, document, rootNode, DeserializeRootElementName, manager);
+            }
+            else
+            {
+                reader.ReadAndAssert();
+                DeserializeNode(reader, document, manager, rootNode);
+            }
+
+#if HAVE_XLINQ
+            if (objectType == typeof(XElement))
+            {
+                XElement element = (XElement)document.DocumentElement!.WrappedNode!;
+                element.Remove();
+
+                return element;
+            }
+#endif
+#if HAVE_XML_DOCUMENT
+            if (objectType == typeof(XmlElement))
+            {
+                return document.DocumentElement!.WrappedNode;
+            }
+#endif
+
+            return document.WrappedNode;
+        }
+
+        private void DeserializeValue(JsonReader reader, IXmlDocument document, XmlNamespaceManager manager, string propertyName, IXmlNode currentNode)
+        {
+            if (!EncodeSpecialCharacters)
+            {
+                switch (propertyName)
+                {
+                    case TextName:
+                        currentNode.AppendChild(document.CreateTextNode(ConvertTokenToXmlValue(reader)));
+                        return;
+                    case CDataName:
+                        currentNode.AppendChild(document.CreateCDataSection(ConvertTokenToXmlValue(reader)));
+                        return;
+                    case WhitespaceName:
+                        currentNode.AppendChild(document.CreateWhitespace(ConvertTokenToXmlValue(reader)));
+                        return;
+                    case SignificantWhitespaceName:
+                        currentNode.AppendChild(document.CreateSignificantWhitespace(ConvertTokenToXmlValue(reader)));
+                        return;
+                    default:
+                        // processing instructions and the xml declaration start with ?
+                        if (!StringUtils.IsNullOrEmpty(propertyName) && propertyName[0] == '?')
+                        {
+                            CreateInstruction(reader, document, currentNode, propertyName);
+                            return;
+                        }
+#if HAVE_XML_DOCUMENT_TYPE
+                        else if (string.Equals(propertyName, "!DOCTYPE", StringComparison.OrdinalIgnoreCase))
+                        {
+                            CreateDocumentType(reader, document, currentNode);
+                            return;
+                        }
+#endif
+                        break;
+                }
+            }
+
+            if (reader.TokenType == JsonToken.StartArray)
+            {
+                // handle nested arrays
+                ReadArrayElements(reader, document, propertyName, currentNode, manager);
+                return;
+            }
+
+            // have to wait until attributes have been parsed before creating element
+            // attributes may contain namespace info used by the element
+            ReadElement(reader, document, currentNode, propertyName, manager);
+        }
+
+        private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
+        {
+            if (StringUtils.IsNullOrEmpty(propertyName))
+            {
+                throw JsonSerializationException.Create(reader, "XmlNodeConverter cannot convert JSON with an empty property name to XML.");
+            }
+
+            Dictionary<string, string?>? attributeNameValues = null;
+            string? elementPrefix = null;
+
+            if (!EncodeSpecialCharacters)
+            {
+                attributeNameValues = ShouldReadInto(reader)
+                    ? ReadAttributeElements(reader, manager)
+                    : null;
+                elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);
+
+                if (propertyName.StartsWith('@'))
+                {
+                    string attributeName = propertyName.Substring(1);
+                    string? attributePrefix = MiscellaneousUtils.GetPrefix(attributeName);
+
+                    AddAttribute(reader, document, currentNode, propertyName, attributeName, manager, attributePrefix);
+                    return;
+                }
+
+                if (propertyName.StartsWith('$'))
+                {
+                    switch (propertyName)
+                    {
+                        case JsonTypeReflector.ArrayValuesPropertyName:
+                            propertyName = propertyName.Substring(1);
+                            elementPrefix = manager.LookupPrefix(JsonNamespaceUri);
+                            CreateElement(reader, document, currentNode, propertyName, manager, elementPrefix, attributeNameValues);
+                            return;
+                        case JsonTypeReflector.IdPropertyName:
+                        case JsonTypeReflector.RefPropertyName:
+                        case JsonTypeReflector.TypePropertyName:
+                        case JsonTypeReflector.ValuePropertyName:
+                            string attributeName = propertyName.Substring(1);
+                            string attributePrefix = manager.LookupPrefix(JsonNamespaceUri);
+                            AddAttribute(reader, document, currentNode, propertyName, attributeName, manager, attributePrefix);
+                            return;
+                    }
+                }
+            }
+            else
+            {
+                if (ShouldReadInto(reader))
+                {
+                    reader.ReadAndAssert();
+                }
+            }
+
+            CreateElement(reader, document, currentNode, propertyName, manager, elementPrefix, attributeNameValues);
+        }
+
+        private void CreateElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string elementName, XmlNamespaceManager manager, string? elementPrefix, Dictionary<string, string?>? attributeNameValues)
+        {
+            IXmlElement element = CreateElement(elementName, document, elementPrefix, manager);
+
+            currentNode.AppendChild(element);
+
+            if (attributeNameValues != null)
+            {
+                // add attributes to newly created element
+                foreach (KeyValuePair<string, string?> nameValue in attributeNameValues)
+                {
+                    string encodedName = XmlConvert.EncodeName(nameValue.Key);
+                    string? attributePrefix = MiscellaneousUtils.GetPrefix(nameValue.Key);
+
+                    IXmlNode attribute = (!StringUtils.IsNullOrEmpty(attributePrefix)) ? document.CreateAttribute(encodedName, manager.LookupNamespace(attributePrefix) ?? string.Empty, nameValue.Value) : document.CreateAttribute(encodedName, nameValue.Value);
+
+                    element.SetAttributeNode(attribute);
+                }
+            }
+
+            switch (reader.TokenType)
+            {
+                case JsonToken.String:
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.Boolean:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                    string? text = ConvertTokenToXmlValue(reader);
+                    if (text != null)
+                    {
+                        element.AppendChild(document.CreateTextNode(text));
+                    }
+                    break;
+                case JsonToken.Null:
+
+                    // empty element. do nothing
+                    break;
+                case JsonToken.EndObject:
+
+                    // finished element will have no children to deserialize
+                    manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
+                    break;
+                default:
+                    manager.PushScope();
+                    DeserializeNode(reader, document, manager, element);
+                    manager.PopScope();
+                    manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
+                    break;
+            }
+        }
+
+        private static void AddAttribute(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, string attributeName, XmlNamespaceManager manager, string? attributePrefix)
+        {
+            if (currentNode.NodeType == XmlNodeType.Document)
+            {
+                throw JsonSerializationException.Create(reader, "JSON root object has property '{0}' that will be converted to an attribute. A root object cannot have any attribute properties. Consider specifying a DeserializeRootElementName.".FormatWith(CultureInfo.InvariantCulture, propertyName));
+            }
+
+            string encodedName = XmlConvert.EncodeName(attributeName);
+            string? attributeValue = ConvertTokenToXmlValue(reader);
+
+            IXmlNode attribute = (!StringUtils.IsNullOrEmpty(attributePrefix))
+                ? document.CreateAttribute(encodedName, manager.LookupNamespace(attributePrefix), attributeValue)
+                : document.CreateAttribute(encodedName, attributeValue);
+
+            ((IXmlElement)currentNode).SetAttributeNode(attribute);
+        }
+
+        private static string? ConvertTokenToXmlValue(JsonReader reader)
+        {
+            switch (reader.TokenType)
+            {
+                case JsonToken.String:
+                    return reader.Value?.ToString();
+                case JsonToken.Integer:
+#if HAVE_BIG_INTEGER
+                    if (reader.Value is BigInteger i)
+                    {
+                        return i.ToString(CultureInfo.InvariantCulture);
+                    }
+#endif
+                    return XmlConvert.ToString(Convert.ToInt64(reader.Value, CultureInfo.InvariantCulture));
+                case JsonToken.Float:
+                {
+                    if (reader.Value is decimal d)
+                    {
+                        return XmlConvert.ToString(d);
+                    }
+
+                    if (reader.Value is float f)
+                    {
+                        return XmlConvert.ToString(f);
+                    }
+
+                    return XmlConvert.ToString(Convert.ToDouble(reader.Value, CultureInfo.InvariantCulture));
+                }
+                case JsonToken.Boolean:
+                    return XmlConvert.ToString(Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture));
+                case JsonToken.Date:
+                {
+#if HAVE_DATE_TIME_OFFSET
+                    if (reader.Value is DateTimeOffset offset)
+                    {
+                        return XmlConvert.ToString(offset);
+                    }
+
+#endif
+                    DateTime d = Convert.ToDateTime(reader.Value, CultureInfo.InvariantCulture);
+#if !PORTABLE || NETSTANDARD1_3
+                    return XmlConvert.ToString(d, DateTimeUtils.ToSerializationMode(d.Kind));
+#else
+                    return d.ToString(DateTimeUtils.ToDateTimeFormat(d.Kind), CultureInfo.InvariantCulture);
+#endif
+                }
+                case JsonToken.Bytes:
+                    return Convert.ToBase64String((byte[])reader.Value!);
+                case JsonToken.Null:
+                    return null;
+                default:
+                    throw JsonSerializationException.Create(reader, "Cannot get an XML string value from token type '{0}'.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+        }
+
+        private void ReadArrayElements(JsonReader reader, IXmlDocument document, string propertyName, IXmlNode currentNode, XmlNamespaceManager manager)
+        {
+            string? elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);
+
+            IXmlElement nestedArrayElement = CreateElement(propertyName, document, elementPrefix, manager);
+
+            currentNode.AppendChild(nestedArrayElement);
+
+            int count = 0;
+            while (reader.Read() && reader.TokenType != JsonToken.EndArray)
+            {
+                DeserializeValue(reader, document, manager, propertyName, nestedArrayElement);
+                count++;
+            }
+
+            if (WriteArrayAttribute)
+            {
+                AddJsonArrayAttribute(nestedArrayElement, document);
+            }
+
+            if (count == 1 && WriteArrayAttribute)
+            {
+                foreach (IXmlNode childNode in nestedArrayElement.ChildNodes)
+                {
+                    if (childNode is IXmlElement element && element.LocalName == propertyName)
+                    {
+                        AddJsonArrayAttribute(element, document);
+                        break;
+                    }
+                }
+            }
+        }
+
+        private void AddJsonArrayAttribute(IXmlElement element, IXmlDocument document)
+        {
+            element.SetAttributeNode(document.CreateAttribute("json:Array", JsonNamespaceUri, "true"));
+
+#if HAVE_XLINQ
+            // linq to xml doesn't automatically include prefixes via the namespace manager
+            if (element is XElementWrapper)
+            {
+                if (element.GetPrefixOfNamespace(JsonNamespaceUri) == null)
+                {
+                    element.SetAttributeNode(document.CreateAttribute("xmlns:json", "http://www.w3.org/2000/xmlns/", JsonNamespaceUri));
+                }
+            }
+#endif
+        }
+
+        private bool ShouldReadInto(JsonReader reader)
+        {
+            // a string token means the element only has a single text child
+            switch (reader.TokenType)
+            {
+                case JsonToken.String:
+                case JsonToken.Null:
+                case JsonToken.Boolean:
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                case JsonToken.StartConstructor:
+                    return false;
+            }
+
+            return true;
+        }
+
+        private Dictionary<string, string?>? ReadAttributeElements(JsonReader reader, XmlNamespaceManager manager)
+        {
+            Dictionary<string, string?>? attributeNameValues = null;
+            bool finished = false;
+
+            // read properties until first non-attribute is encountered
+            while (!finished && reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string attributeName = reader.Value!.ToString();
+
+                        if (!StringUtils.IsNullOrEmpty(attributeName))
+                        {
+                            char firstChar = attributeName[0];
+                            string? attributeValue;
+
+                            switch (firstChar)
+                            {
+                                case '@':
+                                    if (attributeNameValues == null)
+                                    {
+                                        attributeNameValues = new Dictionary<string, string?>();
+                                    }
+
+                                    attributeName = attributeName.Substring(1);
+                                    reader.ReadAndAssert();
+                                    attributeValue = ConvertTokenToXmlValue(reader);
+                                    attributeNameValues.Add(attributeName, attributeValue);
+
+                                    if (IsNamespaceAttribute(attributeName, out string? namespacePrefix))
+                                    {
+                                        manager.AddNamespace(namespacePrefix, attributeValue);
+                                    }
+                                    break;
+                                case '$':
+                                    switch (attributeName)
+                                    {
+                                        case JsonTypeReflector.ArrayValuesPropertyName:
+                                        case JsonTypeReflector.IdPropertyName:
+                                        case JsonTypeReflector.RefPropertyName:
+                                        case JsonTypeReflector.TypePropertyName:
+                                        case JsonTypeReflector.ValuePropertyName:
+                                            // check that JsonNamespaceUri is in scope
+                                            // if it isn't then add it to document and namespace manager
+                                            string jsonPrefix = manager.LookupPrefix(JsonNamespaceUri);
+                                            if (jsonPrefix == null)
+                                            {
+                                                if (attributeNameValues == null)
+                                                {
+                                                    attributeNameValues = new Dictionary<string, string?>();
+                                                }
+
+                                                // ensure that the prefix used is free
+                                                int? i = null;
+                                                while (manager.LookupNamespace("json" + i) != null)
+                                                {
+                                                    i = i.GetValueOrDefault() + 1;
+                                                }
+                                                jsonPrefix = "json" + i;
+
+                                                attributeNameValues.Add("xmlns:" + jsonPrefix, JsonNamespaceUri);
+                                                manager.AddNamespace(jsonPrefix, JsonNamespaceUri);
+                                            }
+
+                                            // special case $values, it will have a non-primitive value
+                                            if (attributeName == JsonTypeReflector.ArrayValuesPropertyName)
+                                            {
+                                                finished = true;
+                                                break;
+                                            }
+
+                                            attributeName = attributeName.Substring(1);
+                                            reader.ReadAndAssert();
+
+                                            if (!JsonTokenUtils.IsPrimitiveToken(reader.TokenType))
+                                            {
+                                                throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType);
+                                            }
+
+                                            if (attributeNameValues == null)
+                                            {
+                                                attributeNameValues = new Dictionary<string, string?>();
+                                            }
+
+                                            attributeValue = reader.Value?.ToString();
+                                            attributeNameValues.Add(jsonPrefix + ":" + attributeName, attributeValue);
+                                            break;
+                                        default:
+                                            finished = true;
+                                            break;
+                                    }
+                                    break;
+                                default:
+                                    finished = true;
+                                    break;
+                            }
+                        }
+                        else
+                        {
+                            finished = true;
+                        }
+
+                        break;
+                    case JsonToken.EndObject:
+                    case JsonToken.Comment:
+                        finished = true;
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType);
+                }
+            }
+
+            return attributeNameValues;
+        }
+
+        private void CreateInstruction(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName)
+        {
+            if (propertyName == DeclarationName)
+            {
+                string? version = null;
+                string? encoding = null;
+                string? standalone = null;
+                while (reader.Read() && reader.TokenType != JsonToken.EndObject)
+                {
+                    switch (reader.Value?.ToString())
+                    {
+                        case "@version":
+                            reader.ReadAndAssert();
+                            version = ConvertTokenToXmlValue(reader);
+                            break;
+                        case "@encoding":
+                            reader.ReadAndAssert();
+                            encoding = ConvertTokenToXmlValue(reader);
+                            break;
+                        case "@standalone":
+                            reader.ReadAndAssert();
+                            standalone = ConvertTokenToXmlValue(reader);
+                            break;
+                        default:
+                            throw JsonSerializationException.Create(reader, "Unexpected property name encountered while deserializing XmlDeclaration: " + reader.Value);
+                    }
+                }
+
+                IXmlNode declaration = document.CreateXmlDeclaration(version, encoding, standalone);
+                currentNode.AppendChild(declaration);
+            }
+            else
+            {
+                IXmlNode instruction = document.CreateProcessingInstruction(propertyName.Substring(1), ConvertTokenToXmlValue(reader));
+                currentNode.AppendChild(instruction);
+            }
+        }
+
+#if HAVE_XML_DOCUMENT_TYPE
+        private void CreateDocumentType(JsonReader reader, IXmlDocument document, IXmlNode currentNode)
+        {
+            string? name = null;
+            string? publicId = null;
+            string? systemId = null;
+            string? internalSubset = null;
+            while (reader.Read() && reader.TokenType != JsonToken.EndObject)
+            {
+                switch (reader.Value?.ToString())
+                {
+                    case "@name":
+                        reader.ReadAndAssert();
+                        name = ConvertTokenToXmlValue(reader);
+                        break;
+                    case "@public":
+                        reader.ReadAndAssert();
+                        publicId = ConvertTokenToXmlValue(reader);
+                        break;
+                    case "@system":
+                        reader.ReadAndAssert();
+                        systemId = ConvertTokenToXmlValue(reader);
+                        break;
+                    case "@internalSubset":
+                        reader.ReadAndAssert();
+                        internalSubset = ConvertTokenToXmlValue(reader);
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected property name encountered while deserializing XmlDeclaration: " + reader.Value);
+                }
+            }
+
+            IXmlNode documentType = document.CreateXmlDocumentType(name, publicId, systemId, internalSubset);
+            currentNode.AppendChild(documentType);
+        }
+#endif
+
+        private IXmlElement CreateElement(string elementName, IXmlDocument document, string? elementPrefix, XmlNamespaceManager manager)
+        {
+            string encodeName = EncodeSpecialCharacters ? XmlConvert.EncodeLocalName(elementName) : XmlConvert.EncodeName(elementName);
+            string ns = StringUtils.IsNullOrEmpty(elementPrefix) ? manager.DefaultNamespace : manager.LookupNamespace(elementPrefix);
+
+            IXmlElement element = (!StringUtils.IsNullOrEmpty(ns)) ? document.CreateElement(encodeName, ns) : document.CreateElement(encodeName);
+
+            return element;
+        }
+
+        private void DeserializeNode(JsonReader reader, IXmlDocument document, XmlNamespaceManager manager, IXmlNode currentNode)
+        {
+            do
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        if (currentNode.NodeType == XmlNodeType.Document && document.DocumentElement != null)
+                        {
+                            throw JsonSerializationException.Create(reader, "JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifying a DeserializeRootElementName.");
+                        }
+
+                        string propertyName = reader.Value!.ToString();
+                        reader.ReadAndAssert();
+
+                        if (reader.TokenType == JsonToken.StartArray)
+                        {
+                            int count = 0;
+                            while (reader.Read() && reader.TokenType != JsonToken.EndArray)
+                            {
+                                DeserializeValue(reader, document, manager, propertyName, currentNode);
+                                count++;
+                            }
+
+                            if (count == 1 && WriteArrayAttribute)
+                            {
+                                MiscellaneousUtils.GetQualifiedNameParts(propertyName, out string? elementPrefix, out string localName);
+                                string ns = StringUtils.IsNullOrEmpty(elementPrefix) ? manager.DefaultNamespace : manager.LookupNamespace(elementPrefix);
+
+                                foreach (IXmlNode childNode in currentNode.ChildNodes)
+                                {
+                                    if (childNode is IXmlElement element && element.LocalName == localName && element.NamespaceUri == ns)
+                                    {
+                                        AddJsonArrayAttribute(element, document);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        else
+                        {
+                            DeserializeValue(reader, document, manager, propertyName, currentNode);
+                        }
+                        continue;
+                    case JsonToken.StartConstructor:
+                        string constructorName = reader.Value!.ToString();
+
+                        while (reader.Read() && reader.TokenType != JsonToken.EndConstructor)
+                        {
+                            DeserializeValue(reader, document, manager, constructorName, currentNode);
+                        }
+                        break;
+                    case JsonToken.Comment:
+                        currentNode.AppendChild(document.CreateComment((string)reader.Value!));
+                        break;
+                    case JsonToken.EndObject:
+                    case JsonToken.EndArray:
+                        return;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected JsonToken when deserializing node: " + reader.TokenType);
+                }
+            } while (reader.Read());
+            // don't read if current token is a property. token was already read when parsing element attributes
+        }
+
+        /// <summary>
+        /// Checks if the <paramref name="attributeName"/> is a namespace attribute.
+        /// </summary>
+        /// <param name="attributeName">Attribute name to test.</param>
+        /// <param name="prefix">The attribute name prefix if it has one, otherwise an empty string.</param>
+        /// <returns><c>true</c> if attribute name is for a namespace attribute, otherwise <c>false</c>.</returns>
+        private bool IsNamespaceAttribute(string attributeName, [NotNullWhen(true)]out string? prefix)
+        {
+            if (attributeName.StartsWith("xmlns", StringComparison.Ordinal))
+            {
+                if (attributeName.Length == 5)
+                {
+                    prefix = string.Empty;
+                    return true;
+                }
+                else if (attributeName[5] == ':')
+                {
+                    prefix = attributeName.Substring(6, attributeName.Length - 6);
+                    return true;
+                }
+            }
+            prefix = null;
+            return false;
+        }
+
+        private bool ValueAttributes(List<IXmlNode> c)
+        {
+            foreach (IXmlNode xmlNode in c)
+            {
+                if (xmlNode.NamespaceUri == JsonNamespaceUri)
+                {
+                    continue;
+                }
+
+                if (xmlNode.NamespaceUri == "http://www.w3.org/2000/xmlns/" && xmlNode.Value == JsonNamespaceUri)
+                {
+                    continue;
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+#endregion
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified value type.
+        /// </summary>
+        /// <param name="valueType">Type of the value.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type valueType)
+        {
+#if HAVE_XLINQ
+            if (valueType.AssignableToTypeName("System.Xml.Linq.XObject", false))
+            {
+                return IsXObject(valueType);
+            }
+#endif
+#if HAVE_XML_DOCUMENT
+            if (valueType.AssignableToTypeName("System.Xml.XmlNode", false))
+            {
+                return IsXmlNode(valueType);
+            }
+#endif
+
+            return false;
+        }
+
+#if HAVE_XLINQ
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private bool IsXObject(Type valueType)
+        {
+            return typeof(XObject).IsAssignableFrom(valueType);
+        }
+#endif
+
+#if HAVE_XML_DOCUMENT
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private bool IsXmlNode(Type valueType)
+        {
+            return typeof(XmlNode).IsAssignableFrom(valueType);
+        }
+#endif
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/DateFormatHandling.cs b/Libs/Newtonsoft.Json/DateFormatHandling.cs
new file mode 100644
index 0000000..70b86f6
--- /dev/null
+++ b/Libs/Newtonsoft.Json/DateFormatHandling.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies how dates are formatted when writing JSON text.
+    /// </summary>
+    public enum DateFormatHandling
+    {
+        /// <summary>
+        /// Dates are written in the ISO 8601 format, e.g. <c>"2012-03-21T05:40Z"</c>.
+        /// </summary>
+        IsoDateFormat,
+
+        /// <summary>
+        /// Dates are written in the Microsoft JSON format, e.g. <c>"\/Date(1198908717056)\/"</c>.
+        /// </summary>
+        MicrosoftDateFormat
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/DateParseHandling.cs b/Libs/Newtonsoft.Json/DateParseHandling.cs
new file mode 100644
index 0000000..10bd229
--- /dev/null
+++ b/Libs/Newtonsoft.Json/DateParseHandling.cs
@@ -0,0 +1,49 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies how date formatted strings, e.g. <c>"\/Date(1198908717056)\/"</c> and <c>"2012-03-21T05:40Z"</c>, are parsed when reading JSON text.
+    /// </summary>
+    public enum DateParseHandling
+    {
+        /// <summary>
+        /// Date formatted strings are not parsed to a date type and are read as strings.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Date formatted strings, e.g. <c>"\/Date(1198908717056)\/"</c> and <c>"2012-03-21T05:40Z"</c>, are parsed to <see cref="System.DateTime"/>.
+        /// </summary>
+        DateTime = 1,
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Date formatted strings, e.g. <c>"\/Date(1198908717056)\/"</c> and <c>"2012-03-21T05:40Z"</c>, are parsed to <see cref="System.DateTimeOffset"/>.
+        /// </summary>
+        DateTimeOffset = 2
+#endif
+    }
+}
diff --git a/Libs/Newtonsoft.Json/DateTimeZoneHandling.cs b/Libs/Newtonsoft.Json/DateTimeZoneHandling.cs
new file mode 100644
index 0000000..c8f5c7a
--- /dev/null
+++ b/Libs/Newtonsoft.Json/DateTimeZoneHandling.cs
@@ -0,0 +1,56 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies how to treat the time value when converting between string and <see cref="DateTime"/>.
+    /// </summary>
+    public enum DateTimeZoneHandling
+    {
+        /// <summary>
+        /// Treat as local time. If the <see cref="DateTime"/> object represents a Coordinated Universal Time (UTC), it is converted to the local time.
+        /// </summary>
+        Local = 0,
+
+        /// <summary>
+        /// Treat as a UTC. If the <see cref="DateTime"/> object represents a local time, it is converted to a UTC.
+        /// </summary>
+        Utc = 1,
+
+        /// <summary>
+        /// Treat as a local time if a <see cref="DateTime"/> is being converted to a string.
+        /// If a string is being converted to <see cref="DateTime"/>, convert to a local time if a time zone is specified.
+        /// </summary>
+        Unspecified = 2,
+
+        /// <summary>
+        /// Time zone information should be preserved when converting.
+        /// </summary>
+        RoundtripKind = 3
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/DefaultJsonNameTable.cs b/Libs/Newtonsoft.Json/DefaultJsonNameTable.cs
new file mode 100644
index 0000000..9d56e0d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/DefaultJsonNameTable.cs
@@ -0,0 +1,197 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// The default JSON name table implementation.
+    /// </summary>
+    public class DefaultJsonNameTable : JsonNameTable
+    {
+        // used to defeat hashtable DoS attack where someone passes in lots of strings that hash to the same hash code
+        private static readonly int HashCodeRandomizer;
+
+        private int _count;
+        private Entry[] _entries;
+        private int _mask = 31;
+
+        static DefaultJsonNameTable()
+        {
+            HashCodeRandomizer = Environment.TickCount;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultJsonNameTable"/> class.
+        /// </summary>
+        public DefaultJsonNameTable()
+        {
+            _entries = new Entry[_mask + 1];
+        }
+
+        /// <summary>
+        /// Gets a string containing the same characters as the specified range of characters in the given array.
+        /// </summary>
+        /// <param name="key">The character array containing the name to find.</param>
+        /// <param name="start">The zero-based index into the array specifying the first character of the name.</param>
+        /// <param name="length">The number of characters in the name.</param>
+        /// <returns>A string containing the same characters as the specified range of characters in the given array.</returns>
+        public override string? Get(char[] key, int start, int length)
+        {
+            if (length == 0)
+            {
+                return string.Empty;
+            }
+
+            int hashCode = length + HashCodeRandomizer;
+            hashCode += (hashCode << 7) ^ key[start];
+            int end = start + length;
+            for (int i = start + 1; i < end; i++)
+            {
+                hashCode += (hashCode << 7) ^ key[i];
+            }
+            hashCode -= hashCode >> 17;
+            hashCode -= hashCode >> 11;
+            hashCode -= hashCode >> 5;
+
+            // make sure index is evaluated before accessing _entries, otherwise potential race condition causing IndexOutOfRangeException
+            var index = hashCode & _mask;
+            var entries = _entries;
+
+            for (Entry entry = entries[index]; entry != null; entry = entry.Next)
+            {
+                if (entry.HashCode == hashCode && TextEquals(entry.Value, key, start, length))
+                {
+                    return entry.Value;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Adds the specified string into name table.
+        /// </summary>
+        /// <param name="key">The string to add.</param>
+        /// <remarks>This method is not thread-safe.</remarks>
+        /// <returns>The resolved string.</returns>
+        public string Add(string key)
+        {
+            if (key == null)
+            {
+                throw new ArgumentNullException(nameof(key));
+            }
+
+            int length = key.Length;
+            if (length == 0)
+            {
+                return string.Empty;
+            }
+
+            int hashCode = length + HashCodeRandomizer;
+            for (int i = 0; i < key.Length; i++)
+            {
+                hashCode += (hashCode << 7) ^ key[i];
+            }
+            hashCode -= hashCode >> 17;
+            hashCode -= hashCode >> 11;
+            hashCode -= hashCode >> 5;
+            for (Entry entry = _entries[hashCode & _mask]; entry != null; entry = entry.Next)
+            {
+                if (entry.HashCode == hashCode && entry.Value.Equals(key, StringComparison.Ordinal))
+                {
+                    return entry.Value;
+                }
+            }
+
+            return AddEntry(key, hashCode);
+        }
+
+        private string AddEntry(string str, int hashCode)
+        {
+            int index = hashCode & _mask;
+            Entry entry = new Entry(str, hashCode, _entries[index]);
+            _entries[index] = entry;
+            if (_count++ == _mask)
+            {
+                Grow();
+            }
+            return entry.Value;
+        }
+
+        private void Grow()
+        {
+            Entry[] entries = _entries;
+            int newMask = (_mask * 2) + 1;
+            Entry[] newEntries = new Entry[newMask + 1];
+
+            for (int i = 0; i < entries.Length; i++)
+            {
+                Entry next;
+                for (Entry entry = entries[i]; entry != null; entry = next)
+                {
+                    int index = entry.HashCode & newMask;
+                    next = entry.Next;
+                    entry.Next = newEntries[index];
+                    newEntries[index] = entry;
+                }
+            }
+            _entries = newEntries;
+            _mask = newMask;
+        }
+
+        private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length)
+        {
+            if (str1.Length != str2Length)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < str1.Length; i++)
+            {
+                if (str1[i] != str2[str2Start + i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private class Entry
+        {
+            internal readonly string Value;
+            internal readonly int HashCode;
+            internal Entry Next;
+
+            internal Entry(string value, int hashCode, Entry next)
+            {
+                Value = value;
+                HashCode = hashCode;
+                Next = next;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/DefaultValueHandling.cs b/Libs/Newtonsoft.Json/DefaultValueHandling.cs
new file mode 100644
index 0000000..b00ea10
--- /dev/null
+++ b/Libs/Newtonsoft.Json/DefaultValueHandling.cs
@@ -0,0 +1,67 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.ComponentModel;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies default value handling options for the <see cref="JsonSerializer"/>.
+    /// </summary>
+    /// <example>
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="ReducingSerializedJsonSizeDefaultValueHandlingObject" title="DefaultValueHandling Class" />
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="ReducingSerializedJsonSizeDefaultValueHandlingExample" title="DefaultValueHandling Ignore Example" />
+    /// </example>
+    [Flags]
+    public enum DefaultValueHandling
+    {
+        /// <summary>
+        /// Include members where the member value is the same as the member's default value when serializing objects.
+        /// Included members are written to JSON. Has no effect when deserializing.
+        /// </summary>
+        Include = 0,
+
+        /// <summary>
+        /// Ignore members where the member value is the same as the member's default value when serializing objects
+        /// so that it is not written to JSON.
+        /// This option will ignore all default values (e.g. <c>null</c> for objects and nullable types; <c>0</c> for integers,
+        /// decimals and floating point numbers; and <c>false</c> for booleans). The default value ignored can be changed by
+        /// placing the <see cref="DefaultValueAttribute"/> on the property.
+        /// </summary>
+        Ignore = 1,
+
+        /// <summary>
+        /// Members with a default value but no JSON will be set to their default value when deserializing.
+        /// </summary>
+        Populate = 2,
+
+        /// <summary>
+        /// Ignore members where the member value is the same as the member's default value when serializing objects
+        /// and set members to their default value when deserializing.
+        /// </summary>
+        IgnoreAndPopulate = Ignore | Populate
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Dynamic.snk b/Libs/Newtonsoft.Json/Dynamic.snk
new file mode 100644
index 0000000..2225208
Binary files /dev/null and b/Libs/Newtonsoft.Json/Dynamic.snk differ
diff --git a/Libs/Newtonsoft.Json/FloatFormatHandling.cs b/Libs/Newtonsoft.Json/FloatFormatHandling.cs
new file mode 100644
index 0000000..aa8ef75
--- /dev/null
+++ b/Libs/Newtonsoft.Json/FloatFormatHandling.cs
@@ -0,0 +1,52 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies float format handling options when writing special floating point numbers, e.g. <see cref="Double.NaN"/>,
+    /// <see cref="Double.PositiveInfinity"/> and <see cref="Double.NegativeInfinity"/> with <see cref="JsonWriter"/>.
+    /// </summary>
+    public enum FloatFormatHandling
+    {
+        /// <summary>
+        /// Write special floating point values as strings in JSON, e.g. <c>"NaN"</c>, <c>"Infinity"</c>, <c>"-Infinity"</c>.
+        /// </summary>
+        String = 0,
+
+        /// <summary>
+        /// Write special floating point values as symbols in JSON, e.g. <c>NaN</c>, <c>Infinity</c>, <c>-Infinity</c>.
+        /// Note that this will produce non-valid JSON.
+        /// </summary>
+        Symbol = 1,
+
+        /// <summary>
+        /// Write special floating point values as the property's default value in JSON, e.g. 0.0 for a <see cref="Double"/> property, <c>null</c> for a <see cref="Nullable{T}"/> of <see cref="Double"/> property.
+        /// </summary>
+        DefaultValue = 2
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/FloatParseHandling.cs b/Libs/Newtonsoft.Json/FloatParseHandling.cs
new file mode 100644
index 0000000..3d2f263
--- /dev/null
+++ b/Libs/Newtonsoft.Json/FloatParseHandling.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
+    /// </summary>
+    public enum FloatParseHandling
+    {
+        /// <summary>
+        /// Floating point numbers are parsed to <see cref="Double"/>.
+        /// </summary>
+        Double = 0,
+
+        /// <summary>
+        /// Floating point numbers are parsed to <see cref="Decimal"/>.
+        /// </summary>
+        Decimal = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/FormatterAssemblyStyle.cs b/Libs/Newtonsoft.Json/FormatterAssemblyStyle.cs
new file mode 100644
index 0000000..d03a269
--- /dev/null
+++ b/Libs/Newtonsoft.Json/FormatterAssemblyStyle.cs
@@ -0,0 +1,24 @@
+
+#if HAVE_OBSOLETE_FORMATTER_ASSEMBLY_STYLE
+
+namespace System.Runtime.Serialization.Formatters
+{
+    /// <summary>
+    /// Indicates the method that will be used during deserialization for locating and loading assemblies.
+    /// </summary>
+    [Obsolete("FormatterAssemblyStyle is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
+    public enum FormatterAssemblyStyle
+    {
+        /// <summary>
+        /// In simple mode, the assembly used during deserialization need not match exactly the assembly used during serialization. Specifically, the version numbers need not match as the <see cref="M:System.Reflection.Assembly.LoadWithPartialName(String)"/> method is used to load the assembly.
+        /// </summary>
+        Simple = 0,
+
+        /// <summary>
+        /// In full mode, the assembly used during deserialization must match exactly the assembly used during serialization. The <see cref="System.Reflection.Assembly.Load"/> is used to load the assembly.
+        /// </summary>
+        Full = 1
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Formatting.cs b/Libs/Newtonsoft.Json/Formatting.cs
new file mode 100644
index 0000000..0b03ef4
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Formatting.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies formatting options for the <see cref="JsonTextWriter"/>.
+    /// </summary>
+    public enum Formatting
+    {
+        /// <summary>
+        /// No special formatting is applied. This is the default.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Causes child objects to be indented according to the <see cref="JsonTextWriter.Indentation"/> and <see cref="JsonTextWriter.IndentChar"/> settings.
+        /// </summary>
+        Indented = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/IArrayPool.cs b/Libs/Newtonsoft.Json/IArrayPool.cs
new file mode 100644
index 0000000..b641274
--- /dev/null
+++ b/Libs/Newtonsoft.Json/IArrayPool.cs
@@ -0,0 +1,22 @@
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Provides an interface for using pooled arrays.
+    /// </summary>
+    /// <typeparam name="T">The array type content.</typeparam>
+    public interface IArrayPool<T>
+    {
+        /// <summary>
+        /// Rent an array from the pool. This array must be returned when it is no longer needed.
+        /// </summary>
+        /// <param name="minimumLength">The minimum required length of the array. The returned array may be longer.</param>
+        /// <returns>The rented array from the pool. This array must be returned when it is no longer needed.</returns>
+        T[] Rent(int minimumLength);
+
+        /// <summary>
+        /// Return an array to the pool.
+        /// </summary>
+        /// <param name="array">The array that is being returned.</param>
+        void Return(T[]? array);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/IJsonLineInfo.cs b/Libs/Newtonsoft.Json/IJsonLineInfo.cs
new file mode 100644
index 0000000..05cc80e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/IJsonLineInfo.cs
@@ -0,0 +1,53 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Provides an interface to enable a class to return line and position information.
+    /// </summary>
+    public interface IJsonLineInfo
+    {
+        /// <summary>
+        /// Gets a value indicating whether the class can return line information.
+        /// </summary>
+        /// <returns>
+        /// 	<c>true</c> if <see cref="LineNumber"/> and <see cref="LinePosition"/> can be provided; otherwise, <c>false</c>.
+        /// </returns>
+        bool HasLineInfo();
+
+        /// <summary>
+        /// Gets the current line number.
+        /// </summary>
+        /// <value>The current line number or 0 if no line information is available (for example, when <see cref="HasLineInfo"/> returns <c>false</c>).</value>
+        int LineNumber { get; }
+
+        /// <summary>
+        /// Gets the current line position.
+        /// </summary>
+        /// <value>The current line position or 0 if no line information is available (for example, when <see cref="HasLineInfo"/> returns <c>false</c>).</value>
+        int LinePosition { get; }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonArrayAttribute.cs b/Libs/Newtonsoft.Json/JsonArrayAttribute.cs
new file mode 100644
index 0000000..eeaa67c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonArrayAttribute.cs
@@ -0,0 +1,73 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> how to serialize the collection.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
+    public sealed class JsonArrayAttribute : JsonContainerAttribute
+    {
+        private bool _allowNullItems;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether null items are allowed in the collection.
+        /// </summary>
+        /// <value><c>true</c> if null items are allowed in the collection; otherwise, <c>false</c>.</value>
+        public bool AllowNullItems
+        {
+            get => _allowNullItems;
+            set => _allowNullItems = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonArrayAttribute"/> class.
+        /// </summary>
+        public JsonArrayAttribute()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonObjectAttribute"/> class with a flag indicating whether the array can contain null items.
+        /// </summary>
+        /// <param name="allowNullItems">A flag indicating whether the array can contain null items.</param>
+        public JsonArrayAttribute(bool allowNullItems)
+        {
+            _allowNullItems = allowNullItems;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonArrayAttribute"/> class with the specified container Id.
+        /// </summary>
+        /// <param name="id">The container Id.</param>
+        public JsonArrayAttribute(string id)
+            : base(id)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonConstructorAttribute.cs b/Libs/Newtonsoft.Json/JsonConstructorAttribute.cs
new file mode 100644
index 0000000..f05c0da
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonConstructorAttribute.cs
@@ -0,0 +1,37 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> to use the specified constructor when deserializing that object.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
+    public sealed class JsonConstructorAttribute : Attribute
+    {
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonContainerAttribute.cs b/Libs/Newtonsoft.Json/JsonContainerAttribute.cs
new file mode 100644
index 0000000..e4e29d4
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonContainerAttribute.cs
@@ -0,0 +1,180 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> how to serialize the object.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
+    public abstract class JsonContainerAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets or sets the id.
+        /// </summary>
+        /// <value>The id.</value>
+        public string? Id { get; set; }
+
+        /// <summary>
+        /// Gets or sets the title.
+        /// </summary>
+        /// <value>The title.</value>
+        public string? Title { get; set; }
+
+        /// <summary>
+        /// Gets or sets the description.
+        /// </summary>
+        /// <value>The description.</value>
+        public string? Description { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection's items converter.
+        /// </summary>
+        /// <value>The collection's items converter.</value>
+        public Type? ItemConverterType { get; set; }
+
+        /// <summary>
+        /// The parameter list to use when constructing the <see cref="JsonConverter"/> described by <see cref="ItemConverterType"/>.
+        /// If <c>null</c>, the default constructor is used.
+        /// When non-<c>null</c>, there must be a constructor defined in the <see cref="JsonConverter"/> that exactly matches the number,
+        /// order, and type of these parameters.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// [JsonContainer(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })]
+        /// </code>
+        /// </example>
+        public object[]? ItemConverterParameters { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Type"/> of the <see cref="NamingStrategy"/>.
+        /// </summary>
+        /// <value>The <see cref="Type"/> of the <see cref="NamingStrategy"/>.</value>
+        public Type? NamingStrategyType
+        {
+            get => _namingStrategyType;
+            set
+            {
+                _namingStrategyType = value;
+                NamingStrategyInstance = null;
+            }
+        }
+
+        /// <summary>
+        /// The parameter list to use when constructing the <see cref="NamingStrategy"/> described by <see cref="NamingStrategyType"/>.
+        /// If <c>null</c>, the default constructor is used.
+        /// When non-<c>null</c>, there must be a constructor defined in the <see cref="NamingStrategy"/> that exactly matches the number,
+        /// order, and type of these parameters.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// [JsonContainer(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })]
+        /// </code>
+        /// </example>
+        public object[]? NamingStrategyParameters
+        {
+            get => _namingStrategyParameters;
+            set
+            {
+                _namingStrategyParameters = value;
+                NamingStrategyInstance = null;
+            }
+        }
+
+        internal NamingStrategy? NamingStrategyInstance { get; set; }
+
+        // yuck. can't set nullable properties on an attribute in C#
+        // have to use this approach to get an unset default state
+        internal bool? _isReference;
+        internal bool? _itemIsReference;
+        internal ReferenceLoopHandling? _itemReferenceLoopHandling;
+        internal TypeNameHandling? _itemTypeNameHandling;
+        private Type? _namingStrategyType;
+        private object[]? _namingStrategyParameters;
+
+        /// <summary>
+        /// Gets or sets a value that indicates whether to preserve object references.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> to keep object reference; otherwise, <c>false</c>. The default is <c>false</c>.
+        /// </value>
+        public bool IsReference
+        {
+            get => _isReference ?? default;
+            set => _isReference = value;
+        }
+
+        /// <summary>
+        /// Gets or sets a value that indicates whether to preserve collection's items references.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> to keep collection's items object references; otherwise, <c>false</c>. The default is <c>false</c>.
+        /// </value>
+        public bool ItemIsReference
+        {
+            get => _itemIsReference ?? default;
+            set => _itemIsReference = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the reference loop handling used when serializing the collection's items.
+        /// </summary>
+        /// <value>The reference loop handling.</value>
+        public ReferenceLoopHandling ItemReferenceLoopHandling
+        {
+            get => _itemReferenceLoopHandling ?? default;
+            set => _itemReferenceLoopHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the type name handling used when serializing the collection's items.
+        /// </summary>
+        /// <value>The type name handling.</value>
+        public TypeNameHandling ItemTypeNameHandling
+        {
+            get => _itemTypeNameHandling ?? default;
+            set => _itemTypeNameHandling = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonContainerAttribute"/> class.
+        /// </summary>
+        protected JsonContainerAttribute()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonContainerAttribute"/> class with the specified container Id.
+        /// </summary>
+        /// <param name="id">The container Id.</param>
+        protected JsonContainerAttribute(string id)
+        {
+            Id = id;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonConvert.cs b/Libs/Newtonsoft.Json/JsonConvert.cs
new file mode 100644
index 0000000..639a169
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonConvert.cs
@@ -0,0 +1,1085 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.IO;
+using System.Globalization;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+using System.Xml;
+using LC.Newtonsoft.Json.Converters;
+using LC.Newtonsoft.Json.Serialization;
+using System.Text;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if HAVE_XLINQ
+using System.Xml.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Provides methods for converting between .NET types and JSON types.
+    /// </summary>
+    /// <example>
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="SerializeObject" title="Serializing and Deserializing JSON with JsonConvert" />
+    /// </example>
+    public static class JsonConvert
+    {
+        /// <summary>
+        /// Gets or sets a function that creates default <see cref="JsonSerializerSettings"/>.
+        /// Default settings are automatically used by serialization methods on <see cref="JsonConvert"/>,
+        /// and <see cref="JToken.ToObject{T}()"/> and <see cref="JToken.FromObject(object)"/> on <see cref="JToken"/>.
+        /// To serialize without using any default settings create a <see cref="JsonSerializer"/> with
+        /// <see cref="JsonSerializer.Create()"/>.
+        /// </summary>
+        public static Func<JsonSerializerSettings>? DefaultSettings { get; set; }
+
+        /// <summary>
+        /// Represents JavaScript's boolean value <c>true</c> as a string. This field is read-only.
+        /// </summary>
+        public static readonly string True = "true";
+
+        /// <summary>
+        /// Represents JavaScript's boolean value <c>false</c> as a string. This field is read-only.
+        /// </summary>
+        public static readonly string False = "false";
+
+        /// <summary>
+        /// Represents JavaScript's <c>null</c> as a string. This field is read-only.
+        /// </summary>
+        public static readonly string Null = "null";
+
+        /// <summary>
+        /// Represents JavaScript's <c>undefined</c> as a string. This field is read-only.
+        /// </summary>
+        public static readonly string Undefined = "undefined";
+
+        /// <summary>
+        /// Represents JavaScript's positive infinity as a string. This field is read-only.
+        /// </summary>
+        public static readonly string PositiveInfinity = "Infinity";
+
+        /// <summary>
+        /// Represents JavaScript's negative infinity as a string. This field is read-only.
+        /// </summary>
+        public static readonly string NegativeInfinity = "-Infinity";
+
+        /// <summary>
+        /// Represents JavaScript's <c>NaN</c> as a string. This field is read-only.
+        /// </summary>
+        public static readonly string NaN = "NaN";
+
+        /// <summary>
+        /// Converts the <see cref="DateTime"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="DateTime"/>.</returns>
+        public static string ToString(DateTime value)
+        {
+            return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="DateTime"/> to its JSON string representation using the <see cref="DateFormatHandling"/> specified.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <param name="format">The format the date will be converted to.</param>
+        /// <param name="timeZoneHandling">The time zone handling when the date is converted to a string.</param>
+        /// <returns>A JSON string representation of the <see cref="DateTime"/>.</returns>
+        public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
+        {
+            DateTime updatedDateTime = DateTimeUtils.EnsureDateTime(value, timeZoneHandling);
+
+            using (StringWriter writer = StringUtils.CreateStringWriter(64))
+            {
+                writer.Write('"');
+                DateTimeUtils.WriteDateTimeString(writer, updatedDateTime, format, null, CultureInfo.InvariantCulture);
+                writer.Write('"');
+                return writer.ToString();
+            }
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Converts the <see cref="DateTimeOffset"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="DateTimeOffset"/>.</returns>
+        public static string ToString(DateTimeOffset value)
+        {
+            return ToString(value, DateFormatHandling.IsoDateFormat);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="DateTimeOffset"/> to its JSON string representation using the <see cref="DateFormatHandling"/> specified.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <param name="format">The format the date will be converted to.</param>
+        /// <returns>A JSON string representation of the <see cref="DateTimeOffset"/>.</returns>
+        public static string ToString(DateTimeOffset value, DateFormatHandling format)
+        {
+            using (StringWriter writer = StringUtils.CreateStringWriter(64))
+            {
+                writer.Write('"');
+                DateTimeUtils.WriteDateTimeOffsetString(writer, value, format, null, CultureInfo.InvariantCulture);
+                writer.Write('"');
+                return writer.ToString();
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Converts the <see cref="Boolean"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Boolean"/>.</returns>
+        public static string ToString(bool value)
+        {
+            return (value) ? True : False;
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Char"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Char"/>.</returns>
+        public static string ToString(char value)
+        {
+            return ToString(char.ToString(value));
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Enum"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Enum"/>.</returns>
+        public static string ToString(Enum value)
+        {
+            return value.ToString("D");
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Int32"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Int32"/>.</returns>
+        public static string ToString(int value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Int16"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Int16"/>.</returns>
+        public static string ToString(short value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="UInt16"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="UInt16"/>.</returns>
+        [CLSCompliant(false)]
+        public static string ToString(ushort value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="UInt32"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="UInt32"/>.</returns>
+        [CLSCompliant(false)]
+        public static string ToString(uint value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Int64"/>  to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Int64"/>.</returns>
+        public static string ToString(long value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+#if HAVE_BIG_INTEGER
+        private static string ToStringInternal(BigInteger value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+#endif
+
+        /// <summary>
+        /// Converts the <see cref="UInt64"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="UInt64"/>.</returns>
+        [CLSCompliant(false)]
+        public static string ToString(ulong value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Single"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Single"/>.</returns>
+        public static string ToString(float value)
+        {
+            return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
+        }
+
+        internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
+        {
+            return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
+        }
+
+        private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
+        {
+            if (floatFormatHandling == FloatFormatHandling.Symbol || !(double.IsInfinity(value) || double.IsNaN(value)))
+            {
+                return text;
+            }
+
+            if (floatFormatHandling == FloatFormatHandling.DefaultValue)
+            {
+                return (!nullable) ? "0.0" : Null;
+            }
+
+            return quoteChar + text + quoteChar;
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Double"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Double"/>.</returns>
+        public static string ToString(double value)
+        {
+            return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
+        }
+
+        internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
+        {
+            return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
+        }
+
+        private static string EnsureDecimalPlace(double value, string text)
+        {
+            if (double.IsNaN(value) || double.IsInfinity(value) || text.IndexOf('.') != -1 || text.IndexOf('E') != -1 || text.IndexOf('e') != -1)
+            {
+                return text;
+            }
+
+            return text + ".0";
+        }
+
+        private static string EnsureDecimalPlace(string text)
+        {
+            if (text.IndexOf('.') != -1)
+            {
+                return text;
+            }
+
+            return text + ".0";
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Byte"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Byte"/>.</returns>
+        public static string ToString(byte value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="SByte"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="SByte"/>.</returns>
+        [CLSCompliant(false)]
+        public static string ToString(sbyte value)
+        {
+            return value.ToString(null, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Decimal"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Decimal"/>.</returns>
+        public static string ToString(decimal value)
+        {
+            return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Guid"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Guid"/>.</returns>
+        public static string ToString(Guid value)
+        {
+            return ToString(value, '"');
+        }
+
+        internal static string ToString(Guid value, char quoteChar)
+        {
+            string text;
+            string qc;
+#if HAVE_CHAR_TO_STRING_WITH_CULTURE
+            text = value.ToString("D", CultureInfo.InvariantCulture);
+            qc = quoteChar.ToString(CultureInfo.InvariantCulture);
+#else
+            text = value.ToString("D");
+            qc = quoteChar.ToString();
+#endif
+
+            return qc + text + qc;
+        }
+
+        /// <summary>
+        /// Converts the <see cref="TimeSpan"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="TimeSpan"/>.</returns>
+        public static string ToString(TimeSpan value)
+        {
+            return ToString(value, '"');
+        }
+
+        internal static string ToString(TimeSpan value, char quoteChar)
+        {
+            return ToString(value.ToString(), quoteChar);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Uri"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Uri"/>.</returns>
+        public static string ToString(Uri? value)
+        {
+            if (value == null)
+            {
+                return Null;
+            }
+
+            return ToString(value, '"');
+        }
+
+        internal static string ToString(Uri value, char quoteChar)
+        {
+            return ToString(value.OriginalString, quoteChar);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="String"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="String"/>.</returns>
+        public static string ToString(string? value)
+        {
+            return ToString(value, '"');
+        }
+
+        /// <summary>
+        /// Converts the <see cref="String"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <param name="delimiter">The string delimiter character.</param>
+        /// <returns>A JSON string representation of the <see cref="String"/>.</returns>
+        public static string ToString(string? value, char delimiter)
+        {
+            return ToString(value, delimiter, StringEscapeHandling.Default);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="String"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <param name="delimiter">The string delimiter character.</param>
+        /// <param name="stringEscapeHandling">The string escape handling.</param>
+        /// <returns>A JSON string representation of the <see cref="String"/>.</returns>
+        public static string ToString(string? value, char delimiter, StringEscapeHandling stringEscapeHandling)
+        {
+            if (delimiter != '"' && delimiter != '\'')
+            {
+                throw new ArgumentException("Delimiter must be a single or double quote.", nameof(delimiter));
+            }
+
+            return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, true, stringEscapeHandling);
+        }
+
+        /// <summary>
+        /// Converts the <see cref="Object"/> to its JSON string representation.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A JSON string representation of the <see cref="Object"/>.</returns>
+        public static string ToString(object? value)
+        {
+            if (value == null)
+            {
+                return Null;
+            }
+
+            PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(value.GetType());
+
+            switch (typeCode)
+            {
+                case PrimitiveTypeCode.String:
+                    return ToString((string)value);
+                case PrimitiveTypeCode.Char:
+                    return ToString((char)value);
+                case PrimitiveTypeCode.Boolean:
+                    return ToString((bool)value);
+                case PrimitiveTypeCode.SByte:
+                    return ToString((sbyte)value);
+                case PrimitiveTypeCode.Int16:
+                    return ToString((short)value);
+                case PrimitiveTypeCode.UInt16:
+                    return ToString((ushort)value);
+                case PrimitiveTypeCode.Int32:
+                    return ToString((int)value);
+                case PrimitiveTypeCode.Byte:
+                    return ToString((byte)value);
+                case PrimitiveTypeCode.UInt32:
+                    return ToString((uint)value);
+                case PrimitiveTypeCode.Int64:
+                    return ToString((long)value);
+                case PrimitiveTypeCode.UInt64:
+                    return ToString((ulong)value);
+                case PrimitiveTypeCode.Single:
+                    return ToString((float)value);
+                case PrimitiveTypeCode.Double:
+                    return ToString((double)value);
+                case PrimitiveTypeCode.DateTime:
+                    return ToString((DateTime)value);
+                case PrimitiveTypeCode.Decimal:
+                    return ToString((decimal)value);
+#if HAVE_DB_NULL_TYPE_CODE
+                case PrimitiveTypeCode.DBNull:
+                    return Null;
+#endif
+#if HAVE_DATE_TIME_OFFSET
+                case PrimitiveTypeCode.DateTimeOffset:
+                    return ToString((DateTimeOffset)value);
+#endif
+                case PrimitiveTypeCode.Guid:
+                    return ToString((Guid)value);
+                case PrimitiveTypeCode.Uri:
+                    return ToString((Uri)value);
+                case PrimitiveTypeCode.TimeSpan:
+                    return ToString((TimeSpan)value);
+#if HAVE_BIG_INTEGER
+                case PrimitiveTypeCode.BigInteger:
+                    return ToStringInternal((BigInteger)value);
+#endif
+            }
+
+            throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
+        }
+
+        #region Serialize
+        /// <summary>
+        /// Serializes the specified object to a JSON string.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <returns>A JSON string representation of the object.</returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value)
+        {
+            return SerializeObject(value, null, (JsonSerializerSettings?)null);
+        }
+
+        /// <summary>
+        /// Serializes the specified object to a JSON string using formatting.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <returns>
+        /// A JSON string representation of the object.
+        /// </returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value, Formatting formatting)
+        {
+            return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
+        }
+
+        /// <summary>
+        /// Serializes the specified object to a JSON string using a collection of <see cref="JsonConverter"/>.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <param name="converters">A collection of converters used while serializing.</param>
+        /// <returns>A JSON string representation of the object.</returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value, params JsonConverter[] converters)
+        {
+            JsonSerializerSettings? settings = (converters != null && converters.Length > 0)
+                ? new JsonSerializerSettings { Converters = converters }
+                : null;
+
+            return SerializeObject(value, null, settings);
+        }
+
+        /// <summary>
+        /// Serializes the specified object to a JSON string using formatting and a collection of <see cref="JsonConverter"/>.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <param name="converters">A collection of converters used while serializing.</param>
+        /// <returns>A JSON string representation of the object.</returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value, Formatting formatting, params JsonConverter[] converters)
+        {
+            JsonSerializerSettings? settings = (converters != null && converters.Length > 0)
+                ? new JsonSerializerSettings { Converters = converters }
+                : null;
+
+            return SerializeObject(value, null, formatting, settings);
+        }
+
+        /// <summary>
+        /// Serializes the specified object to a JSON string using <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <param name="settings">The <see cref="JsonSerializerSettings"/> used to serialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.</param>
+        /// <returns>
+        /// A JSON string representation of the object.
+        /// </returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value, JsonSerializerSettings? settings)
+        {
+            return SerializeObject(value, null, settings);
+        }
+
+        /// <summary>
+        /// Serializes the specified object to a JSON string using a type, formatting and <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <param name="settings">The <see cref="JsonSerializerSettings"/> used to serialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.</param>
+        /// <param name="type">
+        /// The type of the value being serialized.
+        /// This parameter is used when <see cref="JsonSerializer.TypeNameHandling"/> is <see cref="TypeNameHandling.Auto"/> to write out the type name if the type of the value does not match.
+        /// Specifying the type is optional.
+        /// </param>
+        /// <returns>
+        /// A JSON string representation of the object.
+        /// </returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
+        {
+            JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
+
+            return SerializeObjectInternal(value, type, jsonSerializer);
+        }
+
+        /// <summary>
+        /// Serializes the specified object to a JSON string using formatting and <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <param name="settings">The <see cref="JsonSerializerSettings"/> used to serialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.</param>
+        /// <returns>
+        /// A JSON string representation of the object.
+        /// </returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
+        {
+            return SerializeObject(value, null, formatting, settings);
+        }
+
+        /// <summary>
+        /// Serializes the specified object to a JSON string using a type, formatting and <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="value">The object to serialize.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <param name="settings">The <see cref="JsonSerializerSettings"/> used to serialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.</param>
+        /// <param name="type">
+        /// The type of the value being serialized.
+        /// This parameter is used when <see cref="JsonSerializer.TypeNameHandling"/> is <see cref="TypeNameHandling.Auto"/> to write out the type name if the type of the value does not match.
+        /// Specifying the type is optional.
+        /// </param>
+        /// <returns>
+        /// A JSON string representation of the object.
+        /// </returns>
+        [DebuggerStepThrough]
+        public static string SerializeObject(object? value, Type? type, Formatting formatting, JsonSerializerSettings? settings)
+        {
+            JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
+            jsonSerializer.Formatting = formatting;
+
+            return SerializeObjectInternal(value, type, jsonSerializer);
+        }
+
+        private static string SerializeObjectInternal(object? value, Type? type, JsonSerializer jsonSerializer)
+        {
+            StringBuilder sb = new StringBuilder(256);
+            StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);
+            using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
+            {
+                jsonWriter.Formatting = jsonSerializer.Formatting;
+
+                jsonSerializer.Serialize(jsonWriter, value, type);
+            }
+
+            return sw.ToString();
+        }
+        #endregion
+
+        #region Deserialize
+        /// <summary>
+        /// Deserializes the JSON to a .NET object.
+        /// </summary>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static object? DeserializeObject(string value)
+        {
+            return DeserializeObject(value, null, (JsonSerializerSettings?)null);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to a .NET object using <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <param name="settings">
+        /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.
+        /// </param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static object? DeserializeObject(string value, JsonSerializerSettings settings)
+        {
+            return DeserializeObject(value, null, settings);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the specified .NET type.
+        /// </summary>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <param name="type">The <see cref="Type"/> of object being deserialized.</param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static object? DeserializeObject(string value, Type type)
+        {
+            return DeserializeObject(value, type, (JsonSerializerSettings?)null);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the specified .NET type.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to deserialize to.</typeparam>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static T? DeserializeObject<T>(string value)
+        {
+            return DeserializeObject<T>(value, (JsonSerializerSettings?)null);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the given anonymous type.
+        /// </summary>
+        /// <typeparam name="T">
+        /// The anonymous type to deserialize to. This can't be specified
+        /// traditionally and must be inferred from the anonymous type passed
+        /// as a parameter.
+        /// </typeparam>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <param name="anonymousTypeObject">The anonymous type object.</param>
+        /// <returns>The deserialized anonymous type from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
+        {
+            return DeserializeObject<T>(value);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the given anonymous type using <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <typeparam name="T">
+        /// The anonymous type to deserialize to. This can't be specified
+        /// traditionally and must be inferred from the anonymous type passed
+        /// as a parameter.
+        /// </typeparam>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <param name="anonymousTypeObject">The anonymous type object.</param>
+        /// <param name="settings">
+        /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.
+        /// </param>
+        /// <returns>The deserialized anonymous type from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
+        {
+            return DeserializeObject<T>(value, settings);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the specified .NET type using a collection of <see cref="JsonConverter"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to deserialize to.</typeparam>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <param name="converters">Converters to use while deserializing.</param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static T? DeserializeObject<T>(string value, params JsonConverter[] converters)
+        {
+            return (T?)DeserializeObject(value, typeof(T), converters);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the specified .NET type using <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to deserialize to.</typeparam>
+        /// <param name="value">The object to deserialize.</param>
+        /// <param name="settings">
+        /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.
+        /// </param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static T? DeserializeObject<T>(string value, JsonSerializerSettings? settings)
+        {
+            return (T?)DeserializeObject(value, typeof(T), settings);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the specified .NET type using a collection of <see cref="JsonConverter"/>.
+        /// </summary>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <param name="type">The type of the object to deserialize.</param>
+        /// <param name="converters">Converters to use while deserializing.</param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        [DebuggerStepThrough]
+        public static object? DeserializeObject(string value, Type type, params JsonConverter[] converters)
+        {
+            JsonSerializerSettings? settings = (converters != null && converters.Length > 0)
+                ? new JsonSerializerSettings { Converters = converters }
+                : null;
+
+            return DeserializeObject(value, type, settings);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON to the specified .NET type using <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="value">The JSON to deserialize.</param>
+        /// <param name="type">The type of the object to deserialize to.</param>
+        /// <param name="settings">
+        /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.
+        /// </param>
+        /// <returns>The deserialized object from the JSON string.</returns>
+        public static object? DeserializeObject(string value, Type? type, JsonSerializerSettings? settings)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+
+            JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
+
+            // by default DeserializeObject should check for additional content
+            if (!jsonSerializer.IsCheckAdditionalContentSet())
+            {
+                jsonSerializer.CheckAdditionalContent = true;
+            }
+
+            using (JsonTextReader reader = new JsonTextReader(new StringReader(value)))
+            {
+                return jsonSerializer.Deserialize(reader, type);
+            }
+        }
+        #endregion
+
+        #region Populate
+        /// <summary>
+        /// Populates the object with values from the JSON string.
+        /// </summary>
+        /// <param name="value">The JSON to populate values from.</param>
+        /// <param name="target">The target object to populate values onto.</param>
+        [DebuggerStepThrough]
+        public static void PopulateObject(string value, object target)
+        {
+            PopulateObject(value, target, null);
+        }
+
+        /// <summary>
+        /// Populates the object with values from the JSON string using <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="value">The JSON to populate values from.</param>
+        /// <param name="target">The target object to populate values onto.</param>
+        /// <param name="settings">
+        /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
+        /// If this is <c>null</c>, default serialization settings will be used.
+        /// </param>
+        public static void PopulateObject(string value, object target, JsonSerializerSettings? settings)
+        {
+            JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
+
+            using (JsonReader jsonReader = new JsonTextReader(new StringReader(value)))
+            {
+                jsonSerializer.Populate(jsonReader, target);
+
+                if (settings != null && settings.CheckAdditionalContent)
+                {
+                    while (jsonReader.Read())
+                    {
+                        if (jsonReader.TokenType != JsonToken.Comment)
+                        {
+                            throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
+                        }
+                    }
+                }
+            }
+        }
+        #endregion
+
+        #region Xml
+#if HAVE_XML_DOCUMENT
+        /// <summary>
+        /// Serializes the <see cref="XmlNode"/> to a JSON string.
+        /// </summary>
+        /// <param name="node">The node to serialize.</param>
+        /// <returns>A JSON string of the <see cref="XmlNode"/>.</returns>
+        public static string SerializeXmlNode(XmlNode? node)
+        {
+            return SerializeXmlNode(node, Formatting.None);
+        }
+
+        /// <summary>
+        /// Serializes the <see cref="XmlNode"/> to a JSON string using formatting.
+        /// </summary>
+        /// <param name="node">The node to serialize.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <returns>A JSON string of the <see cref="XmlNode"/>.</returns>
+        public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
+        {
+            XmlNodeConverter converter = new XmlNodeConverter();
+
+            return SerializeObject(node, formatting, converter);
+        }
+
+        /// <summary>
+        /// Serializes the <see cref="XmlNode"/> to a JSON string using formatting and omits the root object if <paramref name="omitRootObject"/> is <c>true</c>.
+        /// </summary>
+        /// <param name="node">The node to serialize.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <param name="omitRootObject">Omits writing the root object.</param>
+        /// <returns>A JSON string of the <see cref="XmlNode"/>.</returns>
+        public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
+        {
+            XmlNodeConverter converter = new XmlNodeConverter { OmitRootObject = omitRootObject };
+
+            return SerializeObject(node, formatting, converter);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XmlNode"/> from a JSON string.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <returns>The deserialized <see cref="XmlNode"/>.</returns>
+        public static XmlDocument? DeserializeXmlNode(string value)
+        {
+            return DeserializeXmlNode(value, null);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XmlNode"/> from a JSON string nested in a root element specified by <paramref name="deserializeRootElementName"/>.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
+        /// <returns>The deserialized <see cref="XmlNode"/>.</returns>
+        public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
+        {
+            return DeserializeXmlNode(value, deserializeRootElementName, false);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XmlNode"/> from a JSON string nested in a root element specified by <paramref name="deserializeRootElementName"/>
+        /// and writes a Json.NET array attribute for collections.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
+        /// <param name="writeArrayAttribute">
+        /// A value to indicate whether to write the Json.NET array attribute.
+        /// This attribute helps preserve arrays when converting the written XML back to JSON.
+        /// </param>
+        /// <returns>The deserialized <see cref="XmlNode"/>.</returns>
+        public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
+        {
+            return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, false);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XmlNode"/> from a JSON string nested in a root element specified by <paramref name="deserializeRootElementName"/>,
+        /// writes a Json.NET array attribute for collections, and encodes special characters.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
+        /// <param name="writeArrayAttribute">
+        /// A value to indicate whether to write the Json.NET array attribute.
+        /// This attribute helps preserve arrays when converting the written XML back to JSON.
+        /// </param>
+        /// <param name="encodeSpecialCharacters">
+        /// A value to indicate whether to encode special characters when converting JSON to XML.
+        /// If <c>true</c>, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify
+        /// XML namespaces, attributes or processing directives. Instead special characters are encoded and written
+        /// as part of the XML element name.
+        /// </param>
+        /// <returns>The deserialized <see cref="XmlNode"/>.</returns>
+        public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
+        {
+            XmlNodeConverter converter = new XmlNodeConverter();
+            converter.DeserializeRootElementName = deserializeRootElementName;
+            converter.WriteArrayAttribute = writeArrayAttribute;
+            converter.EncodeSpecialCharacters = encodeSpecialCharacters;
+
+            return (XmlDocument?)DeserializeObject(value, typeof(XmlDocument), converter);
+        }
+#endif
+
+#if HAVE_XLINQ
+        /// <summary>
+        /// Serializes the <see cref="XNode"/> to a JSON string.
+        /// </summary>
+        /// <param name="node">The node to convert to JSON.</param>
+        /// <returns>A JSON string of the <see cref="XNode"/>.</returns>
+        public static string SerializeXNode(XObject? node)
+        {
+            return SerializeXNode(node, Formatting.None);
+        }
+
+        /// <summary>
+        /// Serializes the <see cref="XNode"/> to a JSON string using formatting.
+        /// </summary>
+        /// <param name="node">The node to convert to JSON.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <returns>A JSON string of the <see cref="XNode"/>.</returns>
+        public static string SerializeXNode(XObject? node, Formatting formatting)
+        {
+            return SerializeXNode(node, formatting, false);
+        }
+
+        /// <summary>
+        /// Serializes the <see cref="XNode"/> to a JSON string using formatting and omits the root object if <paramref name="omitRootObject"/> is <c>true</c>.
+        /// </summary>
+        /// <param name="node">The node to serialize.</param>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <param name="omitRootObject">Omits writing the root object.</param>
+        /// <returns>A JSON string of the <see cref="XNode"/>.</returns>
+        public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
+        {
+            XmlNodeConverter converter = new XmlNodeConverter { OmitRootObject = omitRootObject };
+
+            return SerializeObject(node, formatting, converter);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XNode"/> from a JSON string.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <returns>The deserialized <see cref="XNode"/>.</returns>
+        public static XDocument? DeserializeXNode(string value)
+        {
+            return DeserializeXNode(value, null);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XNode"/> from a JSON string nested in a root element specified by <paramref name="deserializeRootElementName"/>.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
+        /// <returns>The deserialized <see cref="XNode"/>.</returns>
+        public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
+        {
+            return DeserializeXNode(value, deserializeRootElementName, false);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XNode"/> from a JSON string nested in a root element specified by <paramref name="deserializeRootElementName"/>
+        /// and writes a Json.NET array attribute for collections.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
+        /// <param name="writeArrayAttribute">
+        /// A value to indicate whether to write the Json.NET array attribute.
+        /// This attribute helps preserve arrays when converting the written XML back to JSON.
+        /// </param>
+        /// <returns>The deserialized <see cref="XNode"/>.</returns>
+        public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
+        {
+            return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, false);
+        }
+
+        /// <summary>
+        /// Deserializes the <see cref="XNode"/> from a JSON string nested in a root element specified by <paramref name="deserializeRootElementName"/>,
+        /// writes a Json.NET array attribute for collections, and encodes special characters.
+        /// </summary>
+        /// <param name="value">The JSON string.</param>
+        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
+        /// <param name="writeArrayAttribute">
+        /// A value to indicate whether to write the Json.NET array attribute.
+        /// This attribute helps preserve arrays when converting the written XML back to JSON.
+        /// </param>
+        /// <param name="encodeSpecialCharacters">
+        /// A value to indicate whether to encode special characters when converting JSON to XML.
+        /// If <c>true</c>, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify
+        /// XML namespaces, attributes or processing directives. Instead special characters are encoded and written
+        /// as part of the XML element name.
+        /// </param>
+        /// <returns>The deserialized <see cref="XNode"/>.</returns>
+        public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
+        {
+            XmlNodeConverter converter = new XmlNodeConverter();
+            converter.DeserializeRootElementName = deserializeRootElementName;
+            converter.WriteArrayAttribute = writeArrayAttribute;
+            converter.EncodeSpecialCharacters = encodeSpecialCharacters;
+
+            return (XDocument?)DeserializeObject(value, typeof(XDocument), converter);
+        }
+#endif
+        #endregion
+    }
+}
diff --git a/Libs/Newtonsoft.Json/JsonConverter.cs b/Libs/Newtonsoft.Json/JsonConverter.cs
new file mode 100644
index 0000000..9f5ff5d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonConverter.cs
@@ -0,0 +1,149 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Converts an object to and from JSON.
+    /// </summary>
+    public abstract class JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer);
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer);
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public abstract bool CanConvert(Type objectType);
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="JsonConverter"/> can read JSON.
+        /// </summary>
+        /// <value><c>true</c> if this <see cref="JsonConverter"/> can read JSON; otherwise, <c>false</c>.</value>
+        public virtual bool CanRead => true;
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.
+        /// </summary>
+        /// <value><c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.</value>
+        public virtual bool CanWrite => true;
+    }
+
+    /// <summary>
+    /// Converts an object to and from JSON.
+    /// </summary>
+    /// <typeparam name="T">The object type to convert.</typeparam>
+    public abstract class JsonConverter<T> : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (!(value != null ? value is T : ReflectionUtils.IsNullable(typeof(T))))
+            {
+                throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
+            }
+            WriteJson(writer, (T?)value, serializer);
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public abstract void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer);
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public sealed override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            bool existingIsNull = existingValue == null;
+            if (!(existingIsNull || existingValue is T))
+            {
+                throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
+            }
+            return ReadJson(reader, objectType, existingIsNull ? default : (T?)existingValue, !existingIsNull, serializer);
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read. If there is no existing value then <c>null</c> will be used.</param>
+        /// <param name="hasExistingValue">The existing value has a value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public abstract T? ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer);
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public sealed override bool CanConvert(Type objectType)
+        {
+            return typeof(T).IsAssignableFrom(objectType);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonConverterAttribute.cs b/Libs/Newtonsoft.Json/JsonConverterAttribute.cs
new file mode 100644
index 0000000..51d12bd
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonConverterAttribute.cs
@@ -0,0 +1,77 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> to use the specified <see cref="JsonConverter"/> when serializing the member or class.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Parameter, AllowMultiple = false)]
+    public sealed class JsonConverterAttribute : Attribute
+    {
+        private readonly Type _converterType;
+
+        /// <summary>
+        /// Gets the <see cref="Type"/> of the <see cref="JsonConverter"/>.
+        /// </summary>
+        /// <value>The <see cref="Type"/> of the <see cref="JsonConverter"/>.</value>
+        public Type ConverterType => _converterType;
+
+        /// <summary>
+        /// The parameter list to use when constructing the <see cref="JsonConverter"/> described by <see cref="ConverterType"/>.
+        /// If <c>null</c>, the default constructor is used.
+        /// </summary>
+        public object[]? ConverterParameters { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonConverterAttribute"/> class.
+        /// </summary>
+        /// <param name="converterType">Type of the <see cref="JsonConverter"/>.</param>
+        public JsonConverterAttribute(Type converterType)
+        {
+            if (converterType == null)
+            {
+                throw new ArgumentNullException(nameof(converterType));
+            }
+
+            _converterType = converterType;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonConverterAttribute"/> class.
+        /// </summary>
+        /// <param name="converterType">Type of the <see cref="JsonConverter"/>.</param>
+        /// <param name="converterParameters">Parameter list to use when constructing the <see cref="JsonConverter"/>. Can be <c>null</c>.</param>
+        public JsonConverterAttribute(Type converterType, params object[] converterParameters)
+            : this(converterType)
+        {
+            ConverterParameters = converterParameters;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonConverterCollection.cs b/Libs/Newtonsoft.Json/JsonConverterCollection.cs
new file mode 100644
index 0000000..a77b25d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonConverterCollection.cs
@@ -0,0 +1,39 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Represents a collection of <see cref="JsonConverter"/>.
+    /// </summary>
+    public class JsonConverterCollection : Collection<JsonConverter>
+    {
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonDictionaryAttribute.cs b/Libs/Newtonsoft.Json/JsonDictionaryAttribute.cs
new file mode 100644
index 0000000..bb5023d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonDictionaryAttribute.cs
@@ -0,0 +1,52 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> how to serialize the collection.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
+    public sealed class JsonDictionaryAttribute : JsonContainerAttribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonDictionaryAttribute"/> class.
+        /// </summary>
+        public JsonDictionaryAttribute()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonDictionaryAttribute"/> class with the specified container Id.
+        /// </summary>
+        /// <param name="id">The container Id.</param>
+        public JsonDictionaryAttribute(string id)
+            : base(id)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonException.cs b/Libs/Newtonsoft.Json/JsonException.cs
new file mode 100644
index 0000000..9907d05
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonException.cs
@@ -0,0 +1,92 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Runtime.Serialization;
+using System.Text;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// The exception thrown when an error occurs during JSON serialization or deserialization.
+    /// </summary>
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+    [Serializable]
+#endif
+    public class JsonException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonException"/> class.
+        /// </summary>
+        public JsonException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonException"/> class
+        /// with a specified error message.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public JsonException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonException"/> class
+        /// with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonException(string message, Exception? innerException)
+            : base(message, innerException)
+        {
+        }
+
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="info"/> parameter is <c>null</c>.</exception>
+        /// <exception cref="SerializationException">The class name is <c>null</c> or <see cref="Exception.HResult"/> is zero (0).</exception>
+        public JsonException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+
+        internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message)
+        {
+            message = JsonPosition.FormatMessage(lineInfo, path, message);
+
+            return new JsonException(message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonExtensionDataAttribute.cs b/Libs/Newtonsoft.Json/JsonExtensionDataAttribute.cs
new file mode 100644
index 0000000..c66ecfe
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonExtensionDataAttribute.cs
@@ -0,0 +1,37 @@
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> to deserialize properties with no matching class member into the specified collection
+    /// and write values during serialization.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
+    public class JsonExtensionDataAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets or sets a value that indicates whether to write extension data when serializing the object.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> to write extension data when serializing the object; otherwise, <c>false</c>. The default is <c>true</c>.
+        /// </value>
+        public bool WriteData { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value that indicates whether to read extension data when deserializing the object.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> to read extension data when deserializing the object; otherwise, <c>false</c>. The default is <c>true</c>.
+        /// </value>
+        public bool ReadData { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonExtensionDataAttribute"/> class.
+        /// </summary>
+        public JsonExtensionDataAttribute()
+        {
+            WriteData = true;
+            ReadData = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonIgnoreAttribute.cs b/Libs/Newtonsoft.Json/JsonIgnoreAttribute.cs
new file mode 100644
index 0000000..fd6a243
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonIgnoreAttribute.cs
@@ -0,0 +1,39 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> not to serialize the public field or public read/write property value.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
+    public sealed class JsonIgnoreAttribute : Attribute
+    {
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonNameTable.cs b/Libs/Newtonsoft.Json/JsonNameTable.cs
new file mode 100644
index 0000000..01c5ceb
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonNameTable.cs
@@ -0,0 +1,17 @@
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Base class for a table of atomized string objects.
+    /// </summary>
+    public abstract class JsonNameTable
+    {
+        /// <summary>
+        /// Gets a string containing the same characters as the specified range of characters in the given array.
+        /// </summary>
+        /// <param name="key">The character array containing the name to find.</param>
+        /// <param name="start">The zero-based index into the array specifying the first character of the name.</param>
+        /// <param name="length">The number of characters in the name.</param>
+        /// <returns>A string containing the same characters as the specified range of characters in the given array.</returns>
+        public abstract string? Get(char[] key, int start, int length);
+    }
+}
diff --git a/Libs/Newtonsoft.Json/JsonObjectAttribute.cs b/Libs/Newtonsoft.Json/JsonObjectAttribute.cs
new file mode 100644
index 0000000..4b87ba5
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonObjectAttribute.cs
@@ -0,0 +1,111 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> how to serialize the object.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
+    public sealed class JsonObjectAttribute : JsonContainerAttribute
+    {
+        private MemberSerialization _memberSerialization = MemberSerialization.OptOut;
+        internal MissingMemberHandling? _missingMemberHandling;
+
+        // yuck. can't set nullable properties on an attribute in C#
+        // have to use this approach to get an unset default state
+        internal Required? _itemRequired;
+        internal NullValueHandling? _itemNullValueHandling;
+
+        /// <summary>
+        /// Gets or sets the member serialization.
+        /// </summary>
+        /// <value>The member serialization.</value>
+        public MemberSerialization MemberSerialization
+        {
+            get => _memberSerialization;
+            set => _memberSerialization = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the missing member handling used when deserializing this object.
+        /// </summary>
+        /// <value>The missing member handling.</value>
+        public MissingMemberHandling MissingMemberHandling
+        {
+            get => _missingMemberHandling ?? default;
+            set => _missingMemberHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how the object's properties with null values are handled during serialization and deserialization.
+        /// </summary>
+        /// <value>How the object's properties with null values are handled during serialization and deserialization.</value>
+        public NullValueHandling ItemNullValueHandling
+        {
+            get => _itemNullValueHandling ?? default;
+            set => _itemNullValueHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets a value that indicates whether the object's properties are required.
+        /// </summary>
+        /// <value>
+        /// 	A value indicating whether the object's properties are required.
+        /// </value>
+        public Required ItemRequired
+        {
+            get => _itemRequired ?? default;
+            set => _itemRequired = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonObjectAttribute"/> class.
+        /// </summary>
+        public JsonObjectAttribute()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonObjectAttribute"/> class with the specified member serialization.
+        /// </summary>
+        /// <param name="memberSerialization">The member serialization.</param>
+        public JsonObjectAttribute(MemberSerialization memberSerialization)
+        {
+            MemberSerialization = memberSerialization;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonObjectAttribute"/> class with the specified container Id.
+        /// </summary>
+        /// <param name="id">The container Id.</param>
+        public JsonObjectAttribute(string id)
+            : base(id)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonPosition.cs b/Libs/Newtonsoft.Json/JsonPosition.cs
new file mode 100644
index 0000000..ba9ed25
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonPosition.cs
@@ -0,0 +1,177 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json
+{
+    internal enum JsonContainerType
+    {
+        None = 0,
+        Object = 1,
+        Array = 2,
+        Constructor = 3
+    }
+
+    internal struct JsonPosition
+    {
+        private static readonly char[] SpecialCharacters = { '.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t', '\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029' };
+
+        internal JsonContainerType Type;
+        internal int Position;
+        internal string? PropertyName;
+        internal bool HasIndex;
+
+        public JsonPosition(JsonContainerType type)
+        {
+            Type = type;
+            HasIndex = TypeHasIndex(type);
+            Position = -1;
+            PropertyName = null;
+        }
+
+        internal int CalculateLength()
+        {
+            switch (Type)
+            {
+                case JsonContainerType.Object:
+                    return PropertyName!.Length + 5;
+                case JsonContainerType.Array:
+                case JsonContainerType.Constructor:
+                    return MathUtils.IntLength((ulong)Position) + 2;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(Type));
+            }
+        }
+
+        internal void WriteTo(StringBuilder sb, ref StringWriter? writer, ref char[]? buffer)
+        {
+            switch (Type)
+            {
+                case JsonContainerType.Object:
+                    string propertyName = PropertyName!;
+                    if (propertyName.IndexOfAny(SpecialCharacters) != -1)
+                    {
+                        sb.Append(@"['");
+
+                        if (writer == null)
+                        {
+                            writer = new StringWriter(sb);
+                        }
+
+                        JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer);
+
+                        sb.Append(@"']");
+                    }
+                    else
+                    {
+                        if (sb.Length > 0)
+                        {
+                            sb.Append('.');
+                        }
+
+                        sb.Append(propertyName);
+                    }
+                    break;
+                case JsonContainerType.Array:
+                case JsonContainerType.Constructor:
+                    sb.Append('[');
+                    sb.Append(Position);
+                    sb.Append(']');
+                    break;
+            }
+        }
+
+        internal static bool TypeHasIndex(JsonContainerType type)
+        {
+            return (type == JsonContainerType.Array || type == JsonContainerType.Constructor);
+        }
+
+        internal static string BuildPath(List<JsonPosition> positions, JsonPosition? currentPosition)
+        {
+            int capacity = 0;
+            if (positions != null)
+            {
+                for (int i = 0; i < positions.Count; i++)
+                {
+                    capacity += positions[i].CalculateLength();
+                }
+            }
+            if (currentPosition != null)
+            {
+                capacity += currentPosition.GetValueOrDefault().CalculateLength();
+            }
+
+            StringBuilder sb = new StringBuilder(capacity);
+            StringWriter? writer = null;
+            char[]? buffer = null;
+            if (positions != null)
+            {
+                foreach (JsonPosition state in positions)
+                {
+                    state.WriteTo(sb, ref writer, ref buffer);
+                }
+            }
+            if (currentPosition != null)
+            {
+                currentPosition.GetValueOrDefault().WriteTo(sb, ref writer, ref buffer);
+            }
+
+            return sb.ToString();
+        }
+
+        internal static string FormatMessage(IJsonLineInfo? lineInfo, string path, string message)
+        {
+            // don't add a fullstop and space when message ends with a new line
+            if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
+            {
+                message = message.Trim();
+
+                if (!message.EndsWith('.'))
+                {
+                    message += ".";
+                }
+
+                message += " ";
+            }
+
+            message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
+
+            if (lineInfo != null && lineInfo.HasLineInfo())
+            {
+                message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
+            }
+
+            message += ".";
+
+            return message;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonPropertyAttribute.cs b/Libs/Newtonsoft.Json/JsonPropertyAttribute.cs
new file mode 100644
index 0000000..4faf778
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonPropertyAttribute.cs
@@ -0,0 +1,223 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> to always serialize the member with the specified name.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false)]
+    public sealed class JsonPropertyAttribute : Attribute
+    {
+        // yuck. can't set nullable properties on an attribute in C#
+        // have to use this approach to get an unset default state
+        internal NullValueHandling? _nullValueHandling;
+        internal DefaultValueHandling? _defaultValueHandling;
+        internal ReferenceLoopHandling? _referenceLoopHandling;
+        internal ObjectCreationHandling? _objectCreationHandling;
+        internal TypeNameHandling? _typeNameHandling;
+        internal bool? _isReference;
+        internal int? _order;
+        internal Required? _required;
+        internal bool? _itemIsReference;
+        internal ReferenceLoopHandling? _itemReferenceLoopHandling;
+        internal TypeNameHandling? _itemTypeNameHandling;
+
+        /// <summary>
+        /// Gets or sets the <see cref="JsonConverter"/> type used when serializing the property's collection items.
+        /// </summary>
+        /// <value>The collection's items <see cref="JsonConverter"/> type.</value>
+        public Type? ItemConverterType { get; set; }
+
+        /// <summary>
+        /// The parameter list to use when constructing the <see cref="JsonConverter"/> described by <see cref="ItemConverterType"/>.
+        /// If <c>null</c>, the default constructor is used.
+        /// When non-<c>null</c>, there must be a constructor defined in the <see cref="JsonConverter"/> that exactly matches the number,
+        /// order, and type of these parameters.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// [JsonProperty(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })]
+        /// </code>
+        /// </example>
+        public object[]? ItemConverterParameters { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Type"/> of the <see cref="NamingStrategy"/>.
+        /// </summary>
+        /// <value>The <see cref="Type"/> of the <see cref="NamingStrategy"/>.</value>
+        public Type? NamingStrategyType { get; set; }
+
+        /// <summary>
+        /// The parameter list to use when constructing the <see cref="NamingStrategy"/> described by <see cref="JsonPropertyAttribute.NamingStrategyType"/>.
+        /// If <c>null</c>, the default constructor is used.
+        /// When non-<c>null</c>, there must be a constructor defined in the <see cref="NamingStrategy"/> that exactly matches the number,
+        /// order, and type of these parameters.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// [JsonProperty(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })]
+        /// </code>
+        /// </example>
+        public object[]? NamingStrategyParameters { get; set; }
+
+        /// <summary>
+        /// Gets or sets the null value handling used when serializing this property.
+        /// </summary>
+        /// <value>The null value handling.</value>
+        public NullValueHandling NullValueHandling
+        {
+            get => _nullValueHandling ?? default;
+            set => _nullValueHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the default value handling used when serializing this property.
+        /// </summary>
+        /// <value>The default value handling.</value>
+        public DefaultValueHandling DefaultValueHandling
+        {
+            get => _defaultValueHandling ?? default;
+            set => _defaultValueHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the reference loop handling used when serializing this property.
+        /// </summary>
+        /// <value>The reference loop handling.</value>
+        public ReferenceLoopHandling ReferenceLoopHandling
+        {
+            get => _referenceLoopHandling ?? default;
+            set => _referenceLoopHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the object creation handling used when deserializing this property.
+        /// </summary>
+        /// <value>The object creation handling.</value>
+        public ObjectCreationHandling ObjectCreationHandling
+        {
+            get => _objectCreationHandling ?? default;
+            set => _objectCreationHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the type name handling used when serializing this property.
+        /// </summary>
+        /// <value>The type name handling.</value>
+        public TypeNameHandling TypeNameHandling
+        {
+            get => _typeNameHandling ?? default;
+            set => _typeNameHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets whether this property's value is serialized as a reference.
+        /// </summary>
+        /// <value>Whether this property's value is serialized as a reference.</value>
+        public bool IsReference
+        {
+            get => _isReference ?? default;
+            set => _isReference = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the order of serialization of a member.
+        /// </summary>
+        /// <value>The numeric order of serialization.</value>
+        public int Order
+        {
+            get => _order ?? default;
+            set => _order = value;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this property is required.
+        /// </summary>
+        /// <value>
+        /// 	A value indicating whether this property is required.
+        /// </value>
+        public Required Required
+        {
+            get => _required ?? Required.Default;
+            set => _required = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the property.
+        /// </summary>
+        /// <value>The name of the property.</value>
+        public string? PropertyName { get; set; }
+
+        /// <summary>
+        /// Gets or sets the reference loop handling used when serializing the property's collection items.
+        /// </summary>
+        /// <value>The collection's items reference loop handling.</value>
+        public ReferenceLoopHandling ItemReferenceLoopHandling
+        {
+            get => _itemReferenceLoopHandling ?? default;
+            set => _itemReferenceLoopHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the type name handling used when serializing the property's collection items.
+        /// </summary>
+        /// <value>The collection's items type name handling.</value>
+        public TypeNameHandling ItemTypeNameHandling
+        {
+            get => _itemTypeNameHandling ?? default;
+            set => _itemTypeNameHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets whether this property's collection items are serialized as a reference.
+        /// </summary>
+        /// <value>Whether this property's collection items are serialized as a reference.</value>
+        public bool ItemIsReference
+        {
+            get => _itemIsReference ?? default;
+            set => _itemIsReference = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPropertyAttribute"/> class.
+        /// </summary>
+        public JsonPropertyAttribute()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPropertyAttribute"/> class with the specified name.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        public JsonPropertyAttribute(string propertyName)
+        {
+            PropertyName = propertyName;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonReader.Async.cs b/Libs/Newtonsoft.Json/JsonReader.Async.cs
new file mode 100644
index 0000000..a97ec69
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonReader.Async.cs
@@ -0,0 +1,246 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json
+{
+    public abstract partial class JsonReader
+    {
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns <c>true</c> if the next token was read successfully; <c>false</c> if there are no more tokens to read.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
+        }
+
+        /// <summary>
+        /// Asynchronously skips the children of the current token.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public async Task SkipAsync(CancellationToken cancellationToken = default)
+        {
+            if (TokenType == JsonToken.PropertyName)
+            {
+                await ReadAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            if (JsonTokenUtils.IsStartToken(TokenType))
+            {
+                int depth = Depth;
+
+                while (await ReadAsync(cancellationToken).ConfigureAwait(false) && depth < Depth)
+                {
+                }
+            }
+        }
+
+        internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
+        {
+            if (!await ReadAsync(cancellationToken).ConfigureAwait(false))
+            {
+                throw CreateUnexpectedEndException();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="bool"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="bool"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="byte"/>[].
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="byte"/>[]. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<byte[]?>() ?? Task.FromResult(ReadAsBytes());
+        }
+
+        internal async Task<byte[]?> ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken)
+        {
+            List<byte> buffer = new List<byte>();
+
+            while (true)
+            {
+                if (!await ReadAsync(cancellationToken).ConfigureAwait(false))
+                {
+                    SetToken(JsonToken.None);
+                }
+
+                if (ReadArrayElementIntoByteArrayReportDone(buffer))
+                {
+                    byte[] d = buffer.ToArray();
+                    SetToken(JsonToken.Bytes, d, false);
+                    return d;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="DateTime"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="DateTime"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="decimal"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="double"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="double"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(ReadAsDouble());
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="int"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="int"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="string"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="string"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default)
+        {
+            return cancellationToken.CancelIfRequestedAsync<string?>() ?? Task.FromResult(ReadAsString());
+        }
+
+        internal async Task<bool> ReadAndMoveToContentAsync(CancellationToken cancellationToken)
+        {
+            return await ReadAsync(cancellationToken).ConfigureAwait(false) && await MoveToContentAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
+        {
+            switch (TokenType)
+            {
+                case JsonToken.None:
+                case JsonToken.Comment:
+                    return MoveToContentFromNonContentAsync(cancellationToken);
+                default:
+                    return AsyncUtils.True;
+            }
+        }
+
+        private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
+        {
+            while (true)
+            {
+                if (!await ReadAsync(cancellationToken).ConfigureAwait(false))
+                {
+                    return false;
+                }
+
+                switch (TokenType)
+                {
+                    case JsonToken.None:
+                    case JsonToken.Comment:
+                        break;
+                    default:
+                        return true;
+                }
+            }
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/JsonReader.cs b/Libs/Newtonsoft.Json/JsonReader.cs
new file mode 100644
index 0000000..bea7c47
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonReader.cs
@@ -0,0 +1,1278 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Globalization;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using LC.Newtonsoft.Json.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data.
+    /// </summary>
+    public abstract partial class JsonReader : IDisposable
+    {
+        /// <summary>
+        /// Specifies the state of the reader.
+        /// </summary>
+        protected internal enum State
+        {
+            /// <summary>
+            /// A <see cref="JsonReader"/> read method has not been called.
+            /// </summary>
+            Start,
+
+            /// <summary>
+            /// The end of the file has been reached successfully.
+            /// </summary>
+            Complete,
+
+            /// <summary>
+            /// Reader is at a property.
+            /// </summary>
+            Property,
+
+            /// <summary>
+            /// Reader is at the start of an object.
+            /// </summary>
+            ObjectStart,
+
+            /// <summary>
+            /// Reader is in an object.
+            /// </summary>
+            Object,
+
+            /// <summary>
+            /// Reader is at the start of an array.
+            /// </summary>
+            ArrayStart,
+
+            /// <summary>
+            /// Reader is in an array.
+            /// </summary>
+            Array,
+
+            /// <summary>
+            /// The <see cref="JsonReader.Close()"/> method has been called.
+            /// </summary>
+            Closed,
+
+            /// <summary>
+            /// Reader has just read a value.
+            /// </summary>
+            PostValue,
+
+            /// <summary>
+            /// Reader is at the start of a constructor.
+            /// </summary>
+            ConstructorStart,
+
+            /// <summary>
+            /// Reader is in a constructor.
+            /// </summary>
+            Constructor,
+
+            /// <summary>
+            /// An error occurred that prevents the read operation from continuing.
+            /// </summary>
+            Error,
+
+            /// <summary>
+            /// The end of the file has been reached successfully.
+            /// </summary>
+            Finished
+        }
+
+        // current Token data
+        private JsonToken _tokenType;
+        private object? _value;
+        internal char _quoteChar;
+        internal State _currentState;
+        private JsonPosition _currentPosition;
+        private CultureInfo? _culture;
+        private DateTimeZoneHandling _dateTimeZoneHandling;
+        private int? _maxDepth;
+        private bool _hasExceededMaxDepth;
+        internal DateParseHandling _dateParseHandling;
+        internal FloatParseHandling _floatParseHandling;
+        private string? _dateFormatString;
+        private List<JsonPosition>? _stack;
+
+        /// <summary>
+        /// Gets the current reader state.
+        /// </summary>
+        /// <value>The current reader state.</value>
+        protected State CurrentState => _currentState;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the source should be closed when this reader is closed.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> to close the source when this reader is closed; otherwise <c>false</c>. The default is <c>true</c>.
+        /// </value>
+        public bool CloseInput { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether multiple pieces of JSON content can
+        /// be read from a continuous stream without erroring.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> to support reading multiple pieces of JSON content; otherwise <c>false</c>.
+        /// The default is <c>false</c>.
+        /// </value>
+        public bool SupportMultipleContent { get; set; }
+
+        /// <summary>
+        /// Gets the quotation mark character used to enclose the value of a string.
+        /// </summary>
+        public virtual char QuoteChar
+        {
+            get => _quoteChar;
+            protected internal set => _quoteChar = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how <see cref="DateTime"/> time zones are handled when reading JSON.
+        /// </summary>
+        public DateTimeZoneHandling DateTimeZoneHandling
+        {
+            get => _dateTimeZoneHandling;
+            set
+            {
+                if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _dateTimeZoneHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON.
+        /// </summary>
+        public DateParseHandling DateParseHandling
+        {
+            get => _dateParseHandling;
+            set
+            {
+                if (value < DateParseHandling.None ||
+#if HAVE_DATE_TIME_OFFSET
+                    value > DateParseHandling.DateTimeOffset
+#else
+                    value > DateParseHandling.DateTime
+#endif
+                    )
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _dateParseHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
+        /// </summary>
+        public FloatParseHandling FloatParseHandling
+        {
+            get => _floatParseHandling;
+            set
+            {
+                if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _floatParseHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how custom date formatted strings are parsed when reading JSON.
+        /// </summary>
+        public string? DateFormatString
+        {
+            get => _dateFormatString;
+            set => _dateFormatString = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a <see cref="JsonReaderException"/>.
+        /// A null value means there is no maximum. 
+        /// The default value is <c>128</c>.
+        /// </summary>
+        public int? MaxDepth
+        {
+            get => _maxDepth;
+            set
+            {
+                if (value <= 0)
+                {
+                    throw new ArgumentException("Value must be positive.", nameof(value));
+                }
+
+                _maxDepth = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the type of the current JSON token. 
+        /// </summary>
+        public virtual JsonToken TokenType => _tokenType;
+
+        /// <summary>
+        /// Gets the text value of the current JSON token.
+        /// </summary>
+        public virtual object? Value => _value;
+
+        /// <summary>
+        /// Gets the .NET type for the current JSON token.
+        /// </summary>
+        public virtual Type? ValueType => _value?.GetType();
+
+        /// <summary>
+        /// Gets the depth of the current token in the JSON document.
+        /// </summary>
+        /// <value>The depth of the current token in the JSON document.</value>
+        public virtual int Depth
+        {
+            get
+            {
+                int depth = _stack?.Count ?? 0;
+                if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None)
+                {
+                    return depth;
+                }
+                else
+                {
+                    return depth + 1;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the path of the current JSON token. 
+        /// </summary>
+        public virtual string Path
+        {
+            get
+            {
+                if (_currentPosition.Type == JsonContainerType.None)
+                {
+                    return string.Empty;
+                }
+
+                bool insideContainer = (_currentState != State.ArrayStart
+                                        && _currentState != State.ConstructorStart
+                                        && _currentState != State.ObjectStart);
+
+                JsonPosition? current = insideContainer ? (JsonPosition?)_currentPosition : null;
+
+                return JsonPosition.BuildPath(_stack!, current);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the culture used when reading JSON. Defaults to <see cref="CultureInfo.InvariantCulture"/>.
+        /// </summary>
+        public CultureInfo Culture
+        {
+            get => _culture ?? CultureInfo.InvariantCulture;
+            set => _culture = value;
+        }
+
+        internal JsonPosition GetPosition(int depth)
+        {
+            if (_stack != null && depth < _stack.Count)
+            {
+                return _stack[depth];
+            }
+
+            return _currentPosition;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonReader"/> class.
+        /// </summary>
+        protected JsonReader()
+        {
+            _currentState = State.Start;
+            _dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
+            _dateParseHandling = DateParseHandling.DateTime;
+            _floatParseHandling = FloatParseHandling.Double;
+            _maxDepth = 64;
+
+            CloseInput = true;
+        }
+
+        private void Push(JsonContainerType value)
+        {
+            UpdateScopeWithFinishedValue();
+
+            if (_currentPosition.Type == JsonContainerType.None)
+            {
+                _currentPosition = new JsonPosition(value);
+            }
+            else
+            {
+                if (_stack == null)
+                {
+                    _stack = new List<JsonPosition>();
+                }
+
+                _stack.Add(_currentPosition);
+                _currentPosition = new JsonPosition(value);
+
+                // this is a little hacky because Depth increases when first property/value is written but only testing here is faster/simpler
+                if (_maxDepth != null && Depth + 1 > _maxDepth && !_hasExceededMaxDepth)
+                {
+                    _hasExceededMaxDepth = true;
+                    throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
+                }
+            }
+        }
+
+        private JsonContainerType Pop()
+        {
+            JsonPosition oldPosition;
+            if (_stack != null && _stack.Count > 0)
+            {
+                oldPosition = _currentPosition;
+                _currentPosition = _stack[_stack.Count - 1];
+                _stack.RemoveAt(_stack.Count - 1);
+            }
+            else
+            {
+                oldPosition = _currentPosition;
+                _currentPosition = new JsonPosition();
+            }
+
+            if (_maxDepth != null && Depth <= _maxDepth)
+            {
+                _hasExceededMaxDepth = false;
+            }
+
+            return oldPosition.Type;
+        }
+
+        private JsonContainerType Peek()
+        {
+            return _currentPosition.Type;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the source.
+        /// </summary>
+        /// <returns><c>true</c> if the next token was read successfully; <c>false</c> if there are no more tokens to read.</returns>
+        public abstract bool Read();
+
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="Int32"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Int32"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual int? ReadAsInt32()
+        {
+            JsonToken t = GetContentToken();
+
+            switch (t)
+            {
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                    object v = Value!;
+                    if (v is int i)
+                    {
+                        return i;
+                    }
+
+#if HAVE_BIG_INTEGER
+                    if (v is BigInteger value)
+                    {
+                        i = (int)value;
+                    }
+                    else
+#endif
+                    {
+                        try
+                        {
+                            i = Convert.ToInt32(v, CultureInfo.InvariantCulture);
+                        }
+                        catch (Exception ex)
+                        {
+                            // handle error for large integer overflow exceptions
+                            throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, v), ex);
+                        }
+                    }
+
+                    SetToken(JsonToken.Integer, i, false);
+                    return i;
+                case JsonToken.String:
+                    string? s = (string?)Value;
+                    return ReadInt32String(s);
+            }
+
+            throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
+        }
+
+        internal int? ReadInt32String(string? s)
+        {
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                SetToken(JsonToken.Null, null, false);
+                return null;
+            }
+
+            if (int.TryParse(s, NumberStyles.Integer, Culture, out int i))
+            {
+                SetToken(JsonToken.Integer, i, false);
+                return i;
+            }
+            else
+            {
+                SetToken(JsonToken.String, s, false);
+                throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
+            }
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="String"/>.
+        /// </summary>
+        /// <returns>A <see cref="String"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual string? ReadAsString()
+        {
+            JsonToken t = GetContentToken();
+
+            switch (t)
+            {
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.String:
+                    return (string?)Value;
+            }
+
+            if (JsonTokenUtils.IsPrimitiveToken(t))
+            {
+                object? v = Value;
+                if (v != null)
+                {
+                    string s;
+                    if (v is IFormattable formattable)
+                    {
+                        s = formattable.ToString(null, Culture);
+                    }
+                    else
+                    {
+                        s = v is Uri uri ? uri.OriginalString : v.ToString();
+                    }
+
+                    SetToken(JsonToken.String, s, false);
+                    return s;
+                }
+            }
+
+            throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="Byte"/>[].
+        /// </summary>
+        /// <returns>A <see cref="Byte"/>[] or <c>null</c> if the next JSON token is null. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual byte[]? ReadAsBytes()
+        {
+            JsonToken t = GetContentToken();
+
+            switch (t)
+            {
+                case JsonToken.StartObject:
+                {
+                    ReadIntoWrappedTypeObject();
+
+                    byte[]? data = ReadAsBytes();
+                    ReaderReadAndAssert();
+
+                    if (TokenType != JsonToken.EndObject)
+                    {
+                        throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
+                    }
+
+                    SetToken(JsonToken.Bytes, data, false);
+                    return data;
+                }
+                case JsonToken.String:
+                {
+                    // attempt to convert possible base 64 or GUID string to bytes
+                    // GUID has to have format 00000000-0000-0000-0000-000000000000
+                    string s = (string)Value!;
+
+                    byte[] data;
+
+                    if (s.Length == 0)
+                    {
+                        data = CollectionUtils.ArrayEmpty<byte>();
+                    }
+                    else if (ConvertUtils.TryConvertGuid(s, out Guid g1))
+                    {
+                        data = g1.ToByteArray();
+                    }
+                    else
+                    {
+                        data = Convert.FromBase64String(s);
+                    }
+
+                    SetToken(JsonToken.Bytes, data, false);
+                    return data;
+                }
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.Bytes:
+                    if (Value is Guid g2)
+                    {
+                        byte[] data = g2.ToByteArray();
+                        SetToken(JsonToken.Bytes, data, false);
+                        return data;
+                    }
+
+                    return (byte[]?)Value;
+                case JsonToken.StartArray:
+                    return ReadArrayIntoByteArray();
+            }
+
+            throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
+        }
+
+        internal byte[] ReadArrayIntoByteArray()
+        {
+            List<byte> buffer = new List<byte>();
+
+            while (true)
+            {
+                if (!Read())
+                {
+                    SetToken(JsonToken.None);
+                }
+
+                if (ReadArrayElementIntoByteArrayReportDone(buffer))
+                {
+                    byte[] d = buffer.ToArray();
+                    SetToken(JsonToken.Bytes, d, false);
+                    return d;
+                }
+            }
+        }
+
+        private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer)
+        {
+            switch (TokenType)
+            {
+                case JsonToken.None:
+                    throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
+                case JsonToken.Integer:
+                    buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
+                    return false;
+                case JsonToken.EndArray:
+                    return true;
+                case JsonToken.Comment:
+                    return false;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
+            }
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="Double"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Double"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual double? ReadAsDouble()
+        {
+            JsonToken t = GetContentToken();
+
+            switch (t)
+            {
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                    object v = Value!;
+                    if (v is double d)
+                    {
+                        return d;
+                    }
+
+#if HAVE_BIG_INTEGER
+                    if (v is BigInteger value)
+                    {
+                        d = (double)value;
+                    }
+                    else
+#endif
+                    {
+                        d = Convert.ToDouble(v, CultureInfo.InvariantCulture);
+                    }
+
+                    SetToken(JsonToken.Float, d, false);
+
+                    return (double)d;
+                case JsonToken.String:
+                    return ReadDoubleString((string?)Value);
+            }
+
+            throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
+        }
+
+        internal double? ReadDoubleString(string? s)
+        {
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                SetToken(JsonToken.Null, null, false);
+                return null;
+            }
+
+            if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out double d))
+            {
+                SetToken(JsonToken.Float, d, false);
+                return d;
+            }
+            else
+            {
+                SetToken(JsonToken.String, s, false);
+                throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
+            }
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="Boolean"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Boolean"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual bool? ReadAsBoolean()
+        {
+            JsonToken t = GetContentToken();
+
+            switch (t)
+            {
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                    bool b;
+#if HAVE_BIG_INTEGER
+                    if (Value is BigInteger integer)
+                    {
+                        b = integer != 0;
+                    }
+                    else
+#endif
+                    {
+                        b = Convert.ToBoolean(Value, CultureInfo.InvariantCulture);
+                    }
+
+                    SetToken(JsonToken.Boolean, b, false);
+                    return b;
+                case JsonToken.String:
+                    return ReadBooleanString((string?)Value);
+                case JsonToken.Boolean:
+                    return (bool)Value!;
+            }
+
+            throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
+        }
+
+        internal bool? ReadBooleanString(string? s)
+        {
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                SetToken(JsonToken.Null, null, false);
+                return null;
+            }
+
+            if (bool.TryParse(s, out bool b))
+            {
+                SetToken(JsonToken.Boolean, b, false);
+                return b;
+            }
+            else
+            {
+                SetToken(JsonToken.String, s, false);
+                throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
+            }
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="Decimal"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Decimal"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual decimal? ReadAsDecimal()
+        {
+            JsonToken t = GetContentToken();
+
+            switch (t)
+            {
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                    object v = Value!;
+                    
+                    if (v is decimal d)
+                    {
+                        return d;
+                    }
+
+#if HAVE_BIG_INTEGER
+                    if (v is BigInteger value)
+                    {
+                        d = (decimal)value;
+                    }
+                    else
+#endif
+                    {
+                        try
+                        {
+                            d = Convert.ToDecimal(v, CultureInfo.InvariantCulture);
+                        }
+                        catch (Exception ex)
+                        {
+                            // handle error for large integer overflow exceptions
+                            throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, v), ex);
+                        }
+                    }
+
+                    SetToken(JsonToken.Float, d, false);
+                    return d;
+                case JsonToken.String:
+                    return ReadDecimalString((string?)Value);
+            }
+
+            throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
+        }
+
+        internal decimal? ReadDecimalString(string? s)
+        {
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                SetToken(JsonToken.Null, null, false);
+                return null;
+            }
+
+            if (decimal.TryParse(s, NumberStyles.Number, Culture, out decimal d))
+            {
+                SetToken(JsonToken.Float, d, false);
+                return d;
+            }
+            else if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out d) == ParseResult.Success)
+            {
+                // This is to handle strings like "96.014e-05" that are not supported by traditional decimal.TryParse
+                SetToken(JsonToken.Float, d, false);
+                return d;
+            }
+            else
+            {
+                SetToken(JsonToken.String, s, false);
+                throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
+            }
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="DateTime"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="DateTime"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual DateTime? ReadAsDateTime()
+        {
+            switch (GetContentToken())
+            {
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.Date:
+#if HAVE_DATE_TIME_OFFSET
+                    if (Value is DateTimeOffset offset)
+                    {
+                        SetToken(JsonToken.Date, offset.DateTime, false);
+                    }
+#endif
+
+                    return (DateTime)Value!;
+                case JsonToken.String:
+                    return ReadDateTimeString((string?)Value);
+            }
+
+            throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
+        }
+
+        internal DateTime? ReadDateTimeString(string? s)
+        {
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                SetToken(JsonToken.Null, null, false);
+                return null;
+            }
+
+            if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out DateTime dt))
+            {
+                dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
+                SetToken(JsonToken.Date, dt, false);
+                return dt;
+            }
+
+            if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
+            {
+                dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
+                SetToken(JsonToken.Date, dt, false);
+                return dt;
+            }
+
+            throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public virtual DateTimeOffset? ReadAsDateTimeOffset()
+        {
+            JsonToken t = GetContentToken();
+
+            switch (t)
+            {
+                case JsonToken.None:
+                case JsonToken.Null:
+                case JsonToken.EndArray:
+                    return null;
+                case JsonToken.Date:
+                    if (Value is DateTime time)
+                    {
+                        SetToken(JsonToken.Date, new DateTimeOffset(time), false);
+                    }
+
+                    return (DateTimeOffset)Value!;
+                case JsonToken.String:
+                    string? s = (string?)Value;
+                    return ReadDateTimeOffsetString(s);
+                default:
+                    throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
+            }
+        }
+
+        internal DateTimeOffset? ReadDateTimeOffsetString(string? s)
+        {
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                SetToken(JsonToken.Null, null, false);
+                return null;
+            }
+
+            if (DateTimeUtils.TryParseDateTimeOffset(s, _dateFormatString, Culture, out DateTimeOffset dt))
+            {
+                SetToken(JsonToken.Date, dt, false);
+                return dt;
+            }
+
+            if (DateTimeOffset.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
+            {
+                SetToken(JsonToken.Date, dt, false);
+                return dt;
+            }
+
+            SetToken(JsonToken.String, s, false);
+            throw JsonReaderException.Create(this, "Could not convert string to DateTimeOffset: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
+        }
+#endif
+
+        internal void ReaderReadAndAssert()
+        {
+            if (!Read())
+            {
+                throw CreateUnexpectedEndException();
+            }
+        }
+
+        internal JsonReaderException CreateUnexpectedEndException()
+        {
+            return JsonReaderException.Create(this, "Unexpected end when reading JSON.");
+        }
+
+        internal void ReadIntoWrappedTypeObject()
+        {
+            ReaderReadAndAssert();
+            if (Value != null && Value.ToString() == JsonTypeReflector.TypePropertyName)
+            {
+                ReaderReadAndAssert();
+                if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal))
+                {
+                    ReaderReadAndAssert();
+                    if (Value.ToString() == JsonTypeReflector.ValuePropertyName)
+                    {
+                        return;
+                    }
+                }
+            }
+
+            throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
+        }
+
+        /// <summary>
+        /// Skips the children of the current token.
+        /// </summary>
+        public void Skip()
+        {
+            if (TokenType == JsonToken.PropertyName)
+            {
+                Read();
+            }
+
+            if (JsonTokenUtils.IsStartToken(TokenType))
+            {
+                int depth = Depth;
+
+                while (Read() && (depth < Depth))
+                {
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sets the current token.
+        /// </summary>
+        /// <param name="newToken">The new token.</param>
+        protected void SetToken(JsonToken newToken)
+        {
+            SetToken(newToken, null, true);
+        }
+
+        /// <summary>
+        /// Sets the current token and value.
+        /// </summary>
+        /// <param name="newToken">The new token.</param>
+        /// <param name="value">The value.</param>
+        protected void SetToken(JsonToken newToken, object? value)
+        {
+            SetToken(newToken, value, true);
+        }
+
+        /// <summary>
+        /// Sets the current token and value.
+        /// </summary>
+        /// <param name="newToken">The new token.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="updateIndex">A flag indicating whether the position index inside an array should be updated.</param>
+        protected void SetToken(JsonToken newToken, object? value, bool updateIndex)
+        {
+            _tokenType = newToken;
+            _value = value;
+
+            switch (newToken)
+            {
+                case JsonToken.StartObject:
+                    _currentState = State.ObjectStart;
+                    Push(JsonContainerType.Object);
+                    break;
+                case JsonToken.StartArray:
+                    _currentState = State.ArrayStart;
+                    Push(JsonContainerType.Array);
+                    break;
+                case JsonToken.StartConstructor:
+                    _currentState = State.ConstructorStart;
+                    Push(JsonContainerType.Constructor);
+                    break;
+                case JsonToken.EndObject:
+                    ValidateEnd(JsonToken.EndObject);
+                    break;
+                case JsonToken.EndArray:
+                    ValidateEnd(JsonToken.EndArray);
+                    break;
+                case JsonToken.EndConstructor:
+                    ValidateEnd(JsonToken.EndConstructor);
+                    break;
+                case JsonToken.PropertyName:
+                    _currentState = State.Property;
+
+                    _currentPosition.PropertyName = (string)value!;
+                    break;
+                case JsonToken.Undefined:
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.Boolean:
+                case JsonToken.Null:
+                case JsonToken.Date:
+                case JsonToken.String:
+                case JsonToken.Raw:
+                case JsonToken.Bytes:
+                    SetPostValueState(updateIndex);
+                    break;
+            }
+        }
+
+        internal void SetPostValueState(bool updateIndex)
+        {
+            if (Peek() != JsonContainerType.None || SupportMultipleContent)
+            {
+                _currentState = State.PostValue;
+            }
+            else
+            {
+                SetFinished();
+            }
+
+            if (updateIndex)
+            {
+                UpdateScopeWithFinishedValue();
+            }
+        }
+
+        private void UpdateScopeWithFinishedValue()
+        {
+            if (_currentPosition.HasIndex)
+            {
+                _currentPosition.Position++;
+            }
+        }
+
+        private void ValidateEnd(JsonToken endToken)
+        {
+            JsonContainerType currentObject = Pop();
+
+            if (GetTypeForCloseToken(endToken) != currentObject)
+            {
+                throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, currentObject));
+            }
+
+            if (Peek() != JsonContainerType.None || SupportMultipleContent)
+            {
+                _currentState = State.PostValue;
+            }
+            else
+            {
+                SetFinished();
+            }
+        }
+
+        /// <summary>
+        /// Sets the state based on current token type.
+        /// </summary>
+        protected void SetStateBasedOnCurrent()
+        {
+            JsonContainerType currentObject = Peek();
+
+            switch (currentObject)
+            {
+                case JsonContainerType.Object:
+                    _currentState = State.Object;
+                    break;
+                case JsonContainerType.Array:
+                    _currentState = State.Array;
+                    break;
+                case JsonContainerType.Constructor:
+                    _currentState = State.Constructor;
+                    break;
+                case JsonContainerType.None:
+                    SetFinished();
+                    break;
+                default:
+                    throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, currentObject));
+            }
+        }
+
+        private void SetFinished()
+        {
+            _currentState = SupportMultipleContent ? State.Start : State.Finished;
+        }
+
+        private JsonContainerType GetTypeForCloseToken(JsonToken token)
+        {
+            switch (token)
+            {
+                case JsonToken.EndObject:
+                    return JsonContainerType.Object;
+                case JsonToken.EndArray:
+                    return JsonContainerType.Array;
+                case JsonToken.EndConstructor:
+                    return JsonContainerType.Constructor;
+                default:
+                    throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token));
+            }
+        }
+
+        void IDisposable.Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_currentState != State.Closed && disposing)
+            {
+                Close();
+            }
+        }
+
+        /// <summary>
+        /// Changes the reader's state to <see cref="JsonReader.State.Closed"/>.
+        /// If <see cref="JsonReader.CloseInput"/> is set to <c>true</c>, the source is also closed.
+        /// </summary>
+        public virtual void Close()
+        {
+            _currentState = State.Closed;
+            _tokenType = JsonToken.None;
+            _value = null;
+        }
+
+        internal void ReadAndAssert()
+        {
+            if (!Read())
+            {
+                throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
+            }
+        }
+
+        internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter)
+        {
+            if (!ReadForType(contract, hasConverter))
+            {
+                throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
+            }
+        }
+
+        internal bool ReadForType(JsonContract? contract, bool hasConverter)
+        {
+            // don't read properties with converters as a specific value
+            // the value might be a string which will then get converted which will error if read as date for example
+            if (hasConverter)
+            {
+                return Read();
+            }
+
+            ReadType t = contract?.InternalReadType ?? ReadType.Read;
+
+            switch (t)
+            {
+                case ReadType.Read:
+                    return ReadAndMoveToContent();
+                case ReadType.ReadAsInt32:
+                    ReadAsInt32();
+                    break;
+                case ReadType.ReadAsInt64:
+                    bool result = ReadAndMoveToContent();
+                    if (TokenType == JsonToken.Undefined)
+                    {
+                        throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long)));
+                    }
+                    return result;
+                case ReadType.ReadAsDecimal:
+                    ReadAsDecimal();
+                    break;
+                case ReadType.ReadAsDouble:
+                    ReadAsDouble();
+                    break;
+                case ReadType.ReadAsBytes:
+                    ReadAsBytes();
+                    break;
+                case ReadType.ReadAsBoolean:
+                    ReadAsBoolean();
+                    break;
+                case ReadType.ReadAsString:
+                    ReadAsString();
+                    break;
+                case ReadType.ReadAsDateTime:
+                    ReadAsDateTime();
+                    break;
+#if HAVE_DATE_TIME_OFFSET
+                case ReadType.ReadAsDateTimeOffset:
+                    ReadAsDateTimeOffset();
+                    break;
+#endif
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            return (TokenType != JsonToken.None);
+        }
+
+        internal bool ReadAndMoveToContent()
+        {
+            return Read() && MoveToContent();
+        }
+
+        internal bool MoveToContent()
+        {
+            JsonToken t = TokenType;
+            while (t == JsonToken.None || t == JsonToken.Comment)
+            {
+                if (!Read())
+                {
+                    return false;
+                }
+
+                t = TokenType;
+            }
+
+            return true;
+        }
+
+        private JsonToken GetContentToken()
+        {
+            JsonToken t;
+            do
+            {
+                if (!Read())
+                {
+                    SetToken(JsonToken.None);
+                    return JsonToken.None;
+                }
+                else
+                {
+                    t = TokenType;
+                }
+            } while (t == JsonToken.Comment);
+
+            return t;
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/JsonReaderException.cs b/Libs/Newtonsoft.Json/JsonReaderException.cs
new file mode 100644
index 0000000..8a0ec38
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonReaderException.cs
@@ -0,0 +1,148 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.Runtime.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// The exception thrown when an error occurs while reading JSON text.
+    /// </summary>
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+    [Serializable]
+#endif
+    public class JsonReaderException : JsonException
+    {
+        /// <summary>
+        /// Gets the line number indicating where the error occurred.
+        /// </summary>
+        /// <value>The line number indicating where the error occurred.</value>
+        public int LineNumber { get; }
+
+        /// <summary>
+        /// Gets the line position indicating where the error occurred.
+        /// </summary>
+        /// <value>The line position indicating where the error occurred.</value>
+        public int LinePosition { get; }
+
+        /// <summary>
+        /// Gets the path to the JSON where the error occurred.
+        /// </summary>
+        /// <value>The path to the JSON where the error occurred.</value>
+        public string? Path { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonReaderException"/> class.
+        /// </summary>
+        public JsonReaderException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonReaderException"/> class
+        /// with a specified error message.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public JsonReaderException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonReaderException"/> class
+        /// with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonReaderException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonReaderException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="info"/> parameter is <c>null</c>.</exception>
+        /// <exception cref="SerializationException">The class name is <c>null</c> or <see cref="Exception.HResult"/> is zero (0).</exception>
+        public JsonReaderException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonReaderException"/> class
+        /// with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="path">The path to the JSON where the error occurred.</param>
+        /// <param name="lineNumber">The line number indicating where the error occurred.</param>
+        /// <param name="linePosition">The line position indicating where the error occurred.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
+            : base(message, innerException)
+        {
+            Path = path;
+            LineNumber = lineNumber;
+            LinePosition = linePosition;
+        }
+
+        internal static JsonReaderException Create(JsonReader reader, string message)
+        {
+            return Create(reader, message, null);
+        }
+
+        internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex)
+        {
+            return Create(reader as IJsonLineInfo, reader.Path, message, ex);
+        }
+
+        internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
+        {
+            message = JsonPosition.FormatMessage(lineInfo, path, message);
+
+            int lineNumber;
+            int linePosition;
+            if (lineInfo != null && lineInfo.HasLineInfo())
+            {
+                lineNumber = lineInfo.LineNumber;
+                linePosition = lineInfo.LinePosition;
+            }
+            else
+            {
+                lineNumber = 0;
+                linePosition = 0;
+            }
+
+            return new JsonReaderException(message, path, lineNumber, linePosition, ex);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonRequiredAttribute.cs b/Libs/Newtonsoft.Json/JsonRequiredAttribute.cs
new file mode 100644
index 0000000..98606b7
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonRequiredAttribute.cs
@@ -0,0 +1,39 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Instructs the <see cref="JsonSerializer"/> to always serialize the member, and to require that the member has a value.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
+    public sealed class JsonRequiredAttribute : Attribute
+    {
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonSerializationException.cs b/Libs/Newtonsoft.Json/JsonSerializationException.cs
new file mode 100644
index 0000000..8c44980
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonSerializationException.cs
@@ -0,0 +1,148 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// The exception thrown when an error occurs during JSON serialization or deserialization.
+    /// </summary>
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+    [Serializable]
+#endif
+    public class JsonSerializationException : JsonException
+    {
+        /// <summary>
+        /// Gets the line number indicating where the error occurred.
+        /// </summary>
+        /// <value>The line number indicating where the error occurred.</value>
+        public int LineNumber { get; }
+
+        /// <summary>
+        /// Gets the line position indicating where the error occurred.
+        /// </summary>
+        /// <value>The line position indicating where the error occurred.</value>
+        public int LinePosition { get; }
+
+        /// <summary>
+        /// Gets the path to the JSON where the error occurred.
+        /// </summary>
+        /// <value>The path to the JSON where the error occurred.</value>
+        public string? Path { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSerializationException"/> class.
+        /// </summary>
+        public JsonSerializationException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSerializationException"/> class
+        /// with a specified error message.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public JsonSerializationException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSerializationException"/> class
+        /// with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonSerializationException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSerializationException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="info"/> parameter is <c>null</c>.</exception>
+        /// <exception cref="SerializationException">The class name is <c>null</c> or <see cref="Exception.HResult"/> is zero (0).</exception>
+        public JsonSerializationException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSerializationException"/> class
+        /// with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="path">The path to the JSON where the error occurred.</param>
+        /// <param name="lineNumber">The line number indicating where the error occurred.</param>
+        /// <param name="linePosition">The line position indicating where the error occurred.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
+            : base(message, innerException)
+        {
+            Path = path;
+            LineNumber = lineNumber;
+            LinePosition = linePosition;
+        }
+
+        internal static JsonSerializationException Create(JsonReader reader, string message)
+        {
+            return Create(reader, message, null);
+        }
+
+        internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex)
+        {
+            return Create(reader as IJsonLineInfo, reader.Path, message, ex);
+        }
+
+        internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
+        {
+            message = JsonPosition.FormatMessage(lineInfo, path, message);
+
+            int lineNumber;
+            int linePosition;
+            if (lineInfo != null && lineInfo.HasLineInfo())
+            {
+                lineNumber = lineInfo.LineNumber;
+                linePosition = lineInfo.LinePosition;
+            }
+            else
+            {
+                lineNumber = 0;
+                linePosition = 0;
+            }
+
+            return new JsonSerializationException(message, path, lineNumber, linePosition, ex);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonSerializer.cs b/Libs/Newtonsoft.Json/JsonSerializer.cs
new file mode 100644
index 0000000..aab727f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonSerializer.cs
@@ -0,0 +1,1226 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Runtime.Serialization.Formatters;
+using LC.Newtonsoft.Json.Converters;
+using LC.Newtonsoft.Json.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+using System.Runtime.Serialization;
+using ErrorEventArgs = LC.Newtonsoft.Json.Serialization.ErrorEventArgs;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Serializes and deserializes objects into and from the JSON format.
+    /// The <see cref="JsonSerializer"/> enables you to control how objects are encoded into JSON.
+    /// </summary>
+    public class JsonSerializer
+    {
+        internal TypeNameHandling _typeNameHandling;
+        internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling;
+        internal PreserveReferencesHandling _preserveReferencesHandling;
+        internal ReferenceLoopHandling _referenceLoopHandling;
+        internal MissingMemberHandling _missingMemberHandling;
+        internal ObjectCreationHandling _objectCreationHandling;
+        internal NullValueHandling _nullValueHandling;
+        internal DefaultValueHandling _defaultValueHandling;
+        internal ConstructorHandling _constructorHandling;
+        internal MetadataPropertyHandling _metadataPropertyHandling;
+        internal JsonConverterCollection? _converters;
+        internal IContractResolver _contractResolver;
+        internal ITraceWriter? _traceWriter;
+        internal IEqualityComparer? _equalityComparer;
+        internal ISerializationBinder _serializationBinder;
+        internal StreamingContext _context;
+        private IReferenceResolver? _referenceResolver;
+
+        private Formatting? _formatting;
+        private DateFormatHandling? _dateFormatHandling;
+        private DateTimeZoneHandling? _dateTimeZoneHandling;
+        private DateParseHandling? _dateParseHandling;
+        private FloatFormatHandling? _floatFormatHandling;
+        private FloatParseHandling? _floatParseHandling;
+        private StringEscapeHandling? _stringEscapeHandling;
+        private CultureInfo _culture;
+        private int? _maxDepth;
+        private bool _maxDepthSet;
+        private bool? _checkAdditionalContent;
+        private string? _dateFormatString;
+        private bool _dateFormatStringSet;
+
+        /// <summary>
+        /// Occurs when the <see cref="JsonSerializer"/> errors during serialization and deserialization.
+        /// </summary>
+        public virtual event EventHandler<ErrorEventArgs>? Error;
+
+        /// <summary>
+        /// Gets or sets the <see cref="IReferenceResolver"/> used by the serializer when resolving references.
+        /// </summary>
+        public virtual IReferenceResolver? ReferenceResolver
+        {
+            get => GetReferenceResolver();
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value), "Reference resolver cannot be null.");
+                }
+
+                _referenceResolver = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="SerializationBinder"/> used by the serializer when resolving type names.
+        /// </summary>
+        [Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
+        public virtual SerializationBinder Binder
+        {
+            get
+            {
+                if (_serializationBinder is SerializationBinder legacySerializationBinder)
+                {
+                    return legacySerializationBinder;
+                }
+
+                if (_serializationBinder is SerializationBinderAdapter adapter)
+                {
+                    return adapter.SerializationBinder;
+                }
+
+                throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
+            }
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value), "Serialization binder cannot be null.");
+                }
+
+                _serializationBinder = value as ISerializationBinder ?? new SerializationBinderAdapter(value);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ISerializationBinder"/> used by the serializer when resolving type names.
+        /// </summary>
+        public virtual ISerializationBinder SerializationBinder
+        {
+            get => _serializationBinder;
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value), "Serialization binder cannot be null.");
+                }
+
+                _serializationBinder = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ITraceWriter"/> used by the serializer when writing trace messages.
+        /// </summary>
+        /// <value>The trace writer.</value>
+        public virtual ITraceWriter? TraceWriter
+        {
+            get => _traceWriter;
+            set => _traceWriter = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the equality comparer used by the serializer when comparing references.
+        /// </summary>
+        /// <value>The equality comparer.</value>
+        public virtual IEqualityComparer? EqualityComparer
+        {
+            get => _equalityComparer;
+            set => _equalityComparer = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how type name writing and reading is handled by the serializer.
+        /// The default value is <see cref="Json.TypeNameHandling.None" />.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="JsonSerializer.TypeNameHandling"/> should be used with caution when your application deserializes JSON from an external source.
+        /// Incoming types should be validated with a custom <see cref="JsonSerializer.SerializationBinder"/>
+        /// when deserializing with a value other than <see cref="TypeNameHandling.None"/>.
+        /// </remarks>
+        public virtual TypeNameHandling TypeNameHandling
+        {
+            get => _typeNameHandling;
+            set
+            {
+                if (value < TypeNameHandling.None || value > TypeNameHandling.Auto)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _typeNameHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how a type name assembly is written and resolved by the serializer.
+        /// The default value is <see cref="FormatterAssemblyStyle.Simple" />.
+        /// </summary>
+        /// <value>The type name assembly format.</value>
+        [Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
+        public virtual FormatterAssemblyStyle TypeNameAssemblyFormat
+        {
+            get => (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling;
+            set
+            {
+                if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how a type name assembly is written and resolved by the serializer.
+        /// The default value is <see cref="Json.TypeNameAssemblyFormatHandling.Simple" />.
+        /// </summary>
+        /// <value>The type name assembly format.</value>
+        public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
+        {
+            get => _typeNameAssemblyFormatHandling;
+            set
+            {
+                if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _typeNameAssemblyFormatHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how object references are preserved by the serializer.
+        /// The default value is <see cref="Json.PreserveReferencesHandling.None" />.
+        /// </summary>
+        public virtual PreserveReferencesHandling PreserveReferencesHandling
+        {
+            get => _preserveReferencesHandling;
+            set
+            {
+                if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _preserveReferencesHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how reference loops (e.g. a class referencing itself) is handled.
+        /// The default value is <see cref="Json.ReferenceLoopHandling.Error" />.
+        /// </summary>
+        public virtual ReferenceLoopHandling ReferenceLoopHandling
+        {
+            get => _referenceLoopHandling;
+            set
+            {
+                if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _referenceLoopHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization.
+        /// The default value is <see cref="Json.MissingMemberHandling.Ignore" />.
+        /// </summary>
+        public virtual MissingMemberHandling MissingMemberHandling
+        {
+            get => _missingMemberHandling;
+            set
+            {
+                if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _missingMemberHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how null values are handled during serialization and deserialization.
+        /// The default value is <see cref="Json.NullValueHandling.Include" />.
+        /// </summary>
+        public virtual NullValueHandling NullValueHandling
+        {
+            get => _nullValueHandling;
+            set
+            {
+                if (value < NullValueHandling.Include || value > NullValueHandling.Ignore)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _nullValueHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how default values are handled during serialization and deserialization.
+        /// The default value is <see cref="Json.DefaultValueHandling.Include" />.
+        /// </summary>
+        public virtual DefaultValueHandling DefaultValueHandling
+        {
+            get => _defaultValueHandling;
+            set
+            {
+                if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _defaultValueHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how objects are created during deserialization.
+        /// The default value is <see cref="Json.ObjectCreationHandling.Auto" />.
+        /// </summary>
+        /// <value>The object creation handling.</value>
+        public virtual ObjectCreationHandling ObjectCreationHandling
+        {
+            get => _objectCreationHandling;
+            set
+            {
+                if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _objectCreationHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how constructors are used during deserialization.
+        /// The default value is <see cref="Json.ConstructorHandling.Default" />.
+        /// </summary>
+        /// <value>The constructor handling.</value>
+        public virtual ConstructorHandling ConstructorHandling
+        {
+            get => _constructorHandling;
+            set
+            {
+                if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _constructorHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how metadata properties are used during deserialization.
+        /// The default value is <see cref="Json.MetadataPropertyHandling.Default" />.
+        /// </summary>
+        /// <value>The metadata properties handling.</value>
+        public virtual MetadataPropertyHandling MetadataPropertyHandling
+        {
+            get => _metadataPropertyHandling;
+            set
+            {
+                if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _metadataPropertyHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection <see cref="JsonConverter"/> that will be used during serialization.
+        /// </summary>
+        /// <value>Collection <see cref="JsonConverter"/> that will be used during serialization.</value>
+        public virtual JsonConverterCollection Converters
+        {
+            get
+            {
+                if (_converters == null)
+                {
+                    _converters = new JsonConverterCollection();
+                }
+
+                return _converters;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the contract resolver used by the serializer when
+        /// serializing .NET objects to JSON and vice versa.
+        /// </summary>
+        public virtual IContractResolver ContractResolver
+        {
+            get => _contractResolver;
+            set => _contractResolver = value ?? DefaultContractResolver.Instance;
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="StreamingContext"/> used by the serializer when invoking serialization callback methods.
+        /// </summary>
+        /// <value>The context.</value>
+        public virtual StreamingContext Context
+        {
+            get => _context;
+            set => _context = value;
+        }
+
+        /// <summary>
+        /// Indicates how JSON text output is formatted.
+        /// The default value is <see cref="Json.Formatting.None" />.
+        /// </summary>
+        public virtual Formatting Formatting
+        {
+            get => _formatting ?? JsonSerializerSettings.DefaultFormatting;
+            set => _formatting = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how dates are written to JSON text.
+        /// The default value is <see cref="Json.DateFormatHandling.IsoDateFormat" />.
+        /// </summary>
+        public virtual DateFormatHandling DateFormatHandling
+        {
+            get => _dateFormatHandling ?? JsonSerializerSettings.DefaultDateFormatHandling;
+            set => _dateFormatHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how <see cref="DateTime"/> time zones are handled during serialization and deserialization.
+        /// The default value is <see cref="Json.DateTimeZoneHandling.RoundtripKind" />.
+        /// </summary>
+        public virtual DateTimeZoneHandling DateTimeZoneHandling
+        {
+            get => _dateTimeZoneHandling ?? JsonSerializerSettings.DefaultDateTimeZoneHandling;
+            set => _dateTimeZoneHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how date formatted strings, e.g. <c>"\/Date(1198908717056)\/"</c> and <c>"2012-03-21T05:40Z"</c>, are parsed when reading JSON.
+        /// The default value is <see cref="Json.DateParseHandling.DateTime" />.
+        /// </summary>
+        public virtual DateParseHandling DateParseHandling
+        {
+            get => _dateParseHandling ?? JsonSerializerSettings.DefaultDateParseHandling;
+            set => _dateParseHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
+        /// The default value is <see cref="Json.FloatParseHandling.Double" />.
+        /// </summary>
+        public virtual FloatParseHandling FloatParseHandling
+        {
+            get => _floatParseHandling ?? JsonSerializerSettings.DefaultFloatParseHandling;
+            set => _floatParseHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how special floating point numbers, e.g. <see cref="Double.NaN"/>,
+        /// <see cref="Double.PositiveInfinity"/> and <see cref="Double.NegativeInfinity"/>,
+        /// are written as JSON text.
+        /// The default value is <see cref="Json.FloatFormatHandling.String" />.
+        /// </summary>
+        public virtual FloatFormatHandling FloatFormatHandling
+        {
+            get => _floatFormatHandling ?? JsonSerializerSettings.DefaultFloatFormatHandling;
+            set => _floatFormatHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how strings are escaped when writing JSON text.
+        /// The default value is <see cref="Json.StringEscapeHandling.Default" />.
+        /// </summary>
+        public virtual StringEscapeHandling StringEscapeHandling
+        {
+            get => _stringEscapeHandling ?? JsonSerializerSettings.DefaultStringEscapeHandling;
+            set => _stringEscapeHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how <see cref="DateTime"/> and <see cref="DateTimeOffset"/> values are formatted when writing JSON text,
+        /// and the expected date format when reading JSON text.
+        /// The default value is <c>"yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"</c>.
+        /// </summary>
+        public virtual string DateFormatString
+        {
+            get => _dateFormatString ?? JsonSerializerSettings.DefaultDateFormatString;
+            set
+            {
+                _dateFormatString = value;
+                _dateFormatStringSet = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the culture used when reading JSON.
+        /// The default value is <see cref="CultureInfo.InvariantCulture"/>.
+        /// </summary>
+        public virtual CultureInfo Culture
+        {
+            get => _culture ?? JsonSerializerSettings.DefaultCulture;
+            set => _culture = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a <see cref="JsonReaderException"/>.
+        /// A null value means there is no maximum.
+        /// The default value is <c>128</c>.
+        /// </summary>
+        public virtual int? MaxDepth
+        {
+            get => _maxDepth;
+            set
+            {
+                if (value <= 0)
+                {
+                    throw new ArgumentException("Value must be positive.", nameof(value));
+                }
+
+                _maxDepth = value;
+                _maxDepthSet = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether there will be a check for additional JSON content after deserializing an object.
+        /// The default value is <c>false</c>.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if there will be a check for additional JSON content after deserializing an object; otherwise, <c>false</c>.
+        /// </value>
+        public virtual bool CheckAdditionalContent
+        {
+            get => _checkAdditionalContent ?? JsonSerializerSettings.DefaultCheckAdditionalContent;
+            set => _checkAdditionalContent = value;
+        }
+
+        internal bool IsCheckAdditionalContentSet()
+        {
+            return (_checkAdditionalContent != null);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSerializer"/> class.
+        /// </summary>
+        public JsonSerializer()
+        {
+            _referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
+            _missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
+            _nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
+            _defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
+            _objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
+            _preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
+            _constructorHandling = JsonSerializerSettings.DefaultConstructorHandling;
+            _typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
+            _metadataPropertyHandling = JsonSerializerSettings.DefaultMetadataPropertyHandling;
+            _context = JsonSerializerSettings.DefaultContext;
+            _serializationBinder = DefaultSerializationBinder.Instance;
+
+            _culture = JsonSerializerSettings.DefaultCulture;
+            _contractResolver = DefaultContractResolver.Instance;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="JsonSerializer"/> instance.
+        /// The <see cref="JsonSerializer"/> will not use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/>.
+        /// </summary>
+        /// <returns>
+        /// A new <see cref="JsonSerializer"/> instance.
+        /// The <see cref="JsonSerializer"/> will not use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/>.
+        /// </returns>
+        public static JsonSerializer Create()
+        {
+            return new JsonSerializer();
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="JsonSerializer"/> instance using the specified <see cref="JsonSerializerSettings"/>.
+        /// The <see cref="JsonSerializer"/> will not use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/>.
+        /// </summary>
+        /// <param name="settings">The settings to be applied to the <see cref="JsonSerializer"/>.</param>
+        /// <returns>
+        /// A new <see cref="JsonSerializer"/> instance using the specified <see cref="JsonSerializerSettings"/>.
+        /// The <see cref="JsonSerializer"/> will not use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/>.
+        /// </returns>
+        public static JsonSerializer Create(JsonSerializerSettings? settings)
+        {
+            JsonSerializer serializer = Create();
+
+            if (settings != null)
+            {
+                ApplySerializerSettings(serializer, settings);
+            }
+
+            return serializer;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="JsonSerializer"/> instance.
+        /// The <see cref="JsonSerializer"/> will use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/>.
+        /// </summary>
+        /// <returns>
+        /// A new <see cref="JsonSerializer"/> instance.
+        /// The <see cref="JsonSerializer"/> will use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/>.
+        /// </returns>
+        public static JsonSerializer CreateDefault()
+        {
+            // copy static to local variable to avoid concurrency issues
+            JsonSerializerSettings? defaultSettings = JsonConvert.DefaultSettings?.Invoke();
+
+            return Create(defaultSettings);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="JsonSerializer"/> instance using the specified <see cref="JsonSerializerSettings"/>.
+        /// The <see cref="JsonSerializer"/> will use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/> as well as the specified <see cref="JsonSerializerSettings"/>.
+        /// </summary>
+        /// <param name="settings">The settings to be applied to the <see cref="JsonSerializer"/>.</param>
+        /// <returns>
+        /// A new <see cref="JsonSerializer"/> instance using the specified <see cref="JsonSerializerSettings"/>.
+        /// The <see cref="JsonSerializer"/> will use default settings 
+        /// from <see cref="JsonConvert.DefaultSettings"/> as well as the specified <see cref="JsonSerializerSettings"/>.
+        /// </returns>
+        public static JsonSerializer CreateDefault(JsonSerializerSettings? settings)
+        {
+            JsonSerializer serializer = CreateDefault();
+            if (settings != null)
+            {
+                ApplySerializerSettings(serializer, settings);
+            }
+
+            return serializer;
+        }
+
+        private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings)
+        {
+            if (!CollectionUtils.IsNullOrEmpty(settings.Converters))
+            {
+                // insert settings converters at the beginning so they take precedence
+                // if user wants to remove one of the default converters they will have to do it manually
+                for (int i = 0; i < settings.Converters.Count; i++)
+                {
+                    serializer.Converters.Insert(i, settings.Converters[i]);
+                }
+            }
+
+            // serializer specific
+            if (settings._typeNameHandling != null)
+            {
+                serializer.TypeNameHandling = settings.TypeNameHandling;
+            }
+            if (settings._metadataPropertyHandling != null)
+            {
+                serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling;
+            }
+            if (settings._typeNameAssemblyFormatHandling != null)
+            {
+                serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling;
+            }
+            if (settings._preserveReferencesHandling != null)
+            {
+                serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
+            }
+            if (settings._referenceLoopHandling != null)
+            {
+                serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
+            }
+            if (settings._missingMemberHandling != null)
+            {
+                serializer.MissingMemberHandling = settings.MissingMemberHandling;
+            }
+            if (settings._objectCreationHandling != null)
+            {
+                serializer.ObjectCreationHandling = settings.ObjectCreationHandling;
+            }
+            if (settings._nullValueHandling != null)
+            {
+                serializer.NullValueHandling = settings.NullValueHandling;
+            }
+            if (settings._defaultValueHandling != null)
+            {
+                serializer.DefaultValueHandling = settings.DefaultValueHandling;
+            }
+            if (settings._constructorHandling != null)
+            {
+                serializer.ConstructorHandling = settings.ConstructorHandling;
+            }
+            if (settings._context != null)
+            {
+                serializer.Context = settings.Context;
+            }
+            if (settings._checkAdditionalContent != null)
+            {
+                serializer._checkAdditionalContent = settings._checkAdditionalContent;
+            }
+
+            if (settings.Error != null)
+            {
+                serializer.Error += settings.Error;
+            }
+
+            if (settings.ContractResolver != null)
+            {
+                serializer.ContractResolver = settings.ContractResolver;
+            }
+            if (settings.ReferenceResolverProvider != null)
+            {
+                serializer.ReferenceResolver = settings.ReferenceResolverProvider();
+            }
+            if (settings.TraceWriter != null)
+            {
+                serializer.TraceWriter = settings.TraceWriter;
+            }
+            if (settings.EqualityComparer != null)
+            {
+                serializer.EqualityComparer = settings.EqualityComparer;
+            }
+            if (settings.SerializationBinder != null)
+            {
+                serializer.SerializationBinder = settings.SerializationBinder;
+            }
+
+            // reader/writer specific
+            // unset values won't override reader/writer set values
+            if (settings._formatting != null)
+            {
+                serializer._formatting = settings._formatting;
+            }
+            if (settings._dateFormatHandling != null)
+            {
+                serializer._dateFormatHandling = settings._dateFormatHandling;
+            }
+            if (settings._dateTimeZoneHandling != null)
+            {
+                serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
+            }
+            if (settings._dateParseHandling != null)
+            {
+                serializer._dateParseHandling = settings._dateParseHandling;
+            }
+            if (settings._dateFormatStringSet)
+            {
+                serializer._dateFormatString = settings._dateFormatString;
+                serializer._dateFormatStringSet = settings._dateFormatStringSet;
+            }
+            if (settings._floatFormatHandling != null)
+            {
+                serializer._floatFormatHandling = settings._floatFormatHandling;
+            }
+            if (settings._floatParseHandling != null)
+            {
+                serializer._floatParseHandling = settings._floatParseHandling;
+            }
+            if (settings._stringEscapeHandling != null)
+            {
+                serializer._stringEscapeHandling = settings._stringEscapeHandling;
+            }
+            if (settings._culture != null)
+            {
+                serializer._culture = settings._culture;
+            }
+            if (settings._maxDepthSet)
+            {
+                serializer._maxDepth = settings._maxDepth;
+                serializer._maxDepthSet = settings._maxDepthSet;
+            }
+        }
+
+        /// <summary>
+        /// Populates the JSON values onto the target object.
+        /// </summary>
+        /// <param name="reader">The <see cref="TextReader"/> that contains the JSON structure to read values from.</param>
+        /// <param name="target">The target object to populate values onto.</param>
+        [DebuggerStepThrough]
+        public void Populate(TextReader reader, object target)
+        {
+            Populate(new JsonTextReader(reader), target);
+        }
+
+        /// <summary>
+        /// Populates the JSON values onto the target object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> that contains the JSON structure to read values from.</param>
+        /// <param name="target">The target object to populate values onto.</param>
+        [DebuggerStepThrough]
+        public void Populate(JsonReader reader, object target)
+        {
+            PopulateInternal(reader, target);
+        }
+
+        internal virtual void PopulateInternal(JsonReader reader, object target)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+            ValidationUtils.ArgumentNotNull(target, nameof(target));
+
+            SetupReader(
+                reader,
+                out CultureInfo? previousCulture,
+                out DateTimeZoneHandling? previousDateTimeZoneHandling,
+                out DateParseHandling? previousDateParseHandling,
+                out FloatParseHandling? previousFloatParseHandling,
+                out int? previousMaxDepth,
+                out string? previousDateFormatString);
+
+            TraceJsonReader? traceJsonReader = (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                ? CreateTraceJsonReader(reader)
+                : null;
+
+            JsonSerializerInternalReader serializerReader = new JsonSerializerInternalReader(this);
+            serializerReader.Populate(traceJsonReader ?? reader, target);
+
+            if (traceJsonReader != null)
+            {
+                TraceWriter!.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
+            }
+
+            ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON structure contained by the specified <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> that contains the JSON structure to deserialize.</param>
+        /// <returns>The <see cref="Object"/> being deserialized.</returns>
+        [DebuggerStepThrough]
+        public object? Deserialize(JsonReader reader)
+        {
+            return Deserialize(reader, null);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON structure contained by the specified <see cref="TextReader"/>
+        /// into an instance of the specified type.
+        /// </summary>
+        /// <param name="reader">The <see cref="TextReader"/> containing the object.</param>
+        /// <param name="objectType">The <see cref="Type"/> of object being deserialized.</param>
+        /// <returns>The instance of <paramref name="objectType"/> being deserialized.</returns>
+        [DebuggerStepThrough]
+        public object? Deserialize(TextReader reader, Type objectType)
+        {
+            return Deserialize(new JsonTextReader(reader), objectType);
+        }
+
+        /// <summary>
+        /// Deserializes the JSON structure contained by the specified <see cref="JsonReader"/>
+        /// into an instance of the specified type.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> containing the object.</param>
+        /// <typeparam name="T">The type of the object to deserialize.</typeparam>
+        /// <returns>The instance of <typeparamref name="T"/> being deserialized.</returns>
+        [DebuggerStepThrough]
+        public T? Deserialize<T>(JsonReader reader)
+        {
+            return (T?)Deserialize(reader, typeof(T));
+        }
+
+        /// <summary>
+        /// Deserializes the JSON structure contained by the specified <see cref="JsonReader"/>
+        /// into an instance of the specified type.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> containing the object.</param>
+        /// <param name="objectType">The <see cref="Type"/> of object being deserialized.</param>
+        /// <returns>The instance of <paramref name="objectType"/> being deserialized.</returns>
+        [DebuggerStepThrough]
+        public object? Deserialize(JsonReader reader, Type? objectType)
+        {
+            return DeserializeInternal(reader, objectType);
+        }
+
+        internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            SetupReader(
+                reader,
+                out CultureInfo? previousCulture,
+                out DateTimeZoneHandling? previousDateTimeZoneHandling,
+                out DateParseHandling? previousDateParseHandling,
+                out FloatParseHandling? previousFloatParseHandling,
+                out int? previousMaxDepth,
+                out string? previousDateFormatString);
+
+            TraceJsonReader? traceJsonReader = (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                ? CreateTraceJsonReader(reader)
+                : null;
+
+            JsonSerializerInternalReader serializerReader = new JsonSerializerInternalReader(this);
+            object? value = serializerReader.Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent);
+
+            if (traceJsonReader != null)
+            {
+                TraceWriter!.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
+            }
+
+            ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
+
+            return value;
+        }
+
+        private void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString)
+        {
+            if (_culture != null && !_culture.Equals(reader.Culture))
+            {
+                previousCulture = reader.Culture;
+                reader.Culture = _culture;
+            }
+            else
+            {
+                previousCulture = null;
+            }
+
+            if (_dateTimeZoneHandling != null && reader.DateTimeZoneHandling != _dateTimeZoneHandling)
+            {
+                previousDateTimeZoneHandling = reader.DateTimeZoneHandling;
+                reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
+            }
+            else
+            {
+                previousDateTimeZoneHandling = null;
+            }
+
+            if (_dateParseHandling != null && reader.DateParseHandling != _dateParseHandling)
+            {
+                previousDateParseHandling = reader.DateParseHandling;
+                reader.DateParseHandling = _dateParseHandling.GetValueOrDefault();
+            }
+            else
+            {
+                previousDateParseHandling = null;
+            }
+
+            if (_floatParseHandling != null && reader.FloatParseHandling != _floatParseHandling)
+            {
+                previousFloatParseHandling = reader.FloatParseHandling;
+                reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault();
+            }
+            else
+            {
+                previousFloatParseHandling = null;
+            }
+
+            if (_maxDepthSet && reader.MaxDepth != _maxDepth)
+            {
+                previousMaxDepth = reader.MaxDepth;
+                reader.MaxDepth = _maxDepth;
+            }
+            else
+            {
+                previousMaxDepth = null;
+            }
+
+            if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString)
+            {
+                previousDateFormatString = reader.DateFormatString;
+                reader.DateFormatString = _dateFormatString;
+            }
+            else
+            {
+                previousDateFormatString = null;
+            }
+
+            if (reader is JsonTextReader textReader)
+            {
+                if (textReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver resolver)
+                {
+                    textReader.PropertyNameTable = resolver.GetNameTable();
+                }
+            }
+        }
+
+        private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString)
+        {
+            // reset reader back to previous options
+            if (previousCulture != null)
+            {
+                reader.Culture = previousCulture;
+            }
+            if (previousDateTimeZoneHandling != null)
+            {
+                reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
+            }
+            if (previousDateParseHandling != null)
+            {
+                reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault();
+            }
+            if (previousFloatParseHandling != null)
+            {
+                reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault();
+            }
+            if (_maxDepthSet)
+            {
+                reader.MaxDepth = previousMaxDepth;
+            }
+            if (_dateFormatStringSet)
+            {
+                reader.DateFormatString = previousDateFormatString;
+            }
+
+            if (reader is JsonTextReader textReader && textReader.PropertyNameTable != null &&
+                _contractResolver is DefaultContractResolver resolver && textReader.PropertyNameTable == resolver.GetNameTable())
+            {
+                textReader.PropertyNameTable = null;
+            }
+        }
+
+        /// <summary>
+        /// Serializes the specified <see cref="Object"/> and writes the JSON structure
+        /// using the specified <see cref="TextWriter"/>.
+        /// </summary>
+        /// <param name="textWriter">The <see cref="TextWriter"/> used to write the JSON structure.</param>
+        /// <param name="value">The <see cref="Object"/> to serialize.</param>
+        public void Serialize(TextWriter textWriter, object? value)
+        {
+            Serialize(new JsonTextWriter(textWriter), value);
+        }
+
+        /// <summary>
+        /// Serializes the specified <see cref="Object"/> and writes the JSON structure
+        /// using the specified <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="jsonWriter">The <see cref="JsonWriter"/> used to write the JSON structure.</param>
+        /// <param name="value">The <see cref="Object"/> to serialize.</param>
+        /// <param name="objectType">
+        /// The type of the value being serialized.
+        /// This parameter is used when <see cref="JsonSerializer.TypeNameHandling"/> is <see cref="Json.TypeNameHandling.Auto"/> to write out the type name if the type of the value does not match.
+        /// Specifying the type is optional.
+        /// </param>
+        public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
+        {
+            SerializeInternal(jsonWriter, value, objectType);
+        }
+
+        /// <summary>
+        /// Serializes the specified <see cref="Object"/> and writes the JSON structure
+        /// using the specified <see cref="TextWriter"/>.
+        /// </summary>
+        /// <param name="textWriter">The <see cref="TextWriter"/> used to write the JSON structure.</param>
+        /// <param name="value">The <see cref="Object"/> to serialize.</param>
+        /// <param name="objectType">
+        /// The type of the value being serialized.
+        /// This parameter is used when <see cref="TypeNameHandling"/> is Auto to write out the type name if the type of the value does not match.
+        /// Specifying the type is optional.
+        /// </param>
+        public void Serialize(TextWriter textWriter, object? value, Type objectType)
+        {
+            Serialize(new JsonTextWriter(textWriter), value, objectType);
+        }
+
+        /// <summary>
+        /// Serializes the specified <see cref="Object"/> and writes the JSON structure
+        /// using the specified <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="jsonWriter">The <see cref="JsonWriter"/> used to write the JSON structure.</param>
+        /// <param name="value">The <see cref="Object"/> to serialize.</param>
+        public void Serialize(JsonWriter jsonWriter, object? value)
+        {
+            SerializeInternal(jsonWriter, value, null);
+        }
+
+        private TraceJsonReader CreateTraceJsonReader(JsonReader reader)
+        {
+            TraceJsonReader traceReader = new TraceJsonReader(reader);
+            if (reader.TokenType != JsonToken.None)
+            {
+                traceReader.WriteCurrentToken();
+            }
+
+            return traceReader;
+        }
+
+        internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType)
+        {
+            ValidationUtils.ArgumentNotNull(jsonWriter, nameof(jsonWriter));
+
+            // set serialization options onto writer
+            Formatting? previousFormatting = null;
+            if (_formatting != null && jsonWriter.Formatting != _formatting)
+            {
+                previousFormatting = jsonWriter.Formatting;
+                jsonWriter.Formatting = _formatting.GetValueOrDefault();
+            }
+
+            DateFormatHandling? previousDateFormatHandling = null;
+            if (_dateFormatHandling != null && jsonWriter.DateFormatHandling != _dateFormatHandling)
+            {
+                previousDateFormatHandling = jsonWriter.DateFormatHandling;
+                jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault();
+            }
+
+            DateTimeZoneHandling? previousDateTimeZoneHandling = null;
+            if (_dateTimeZoneHandling != null && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling)
+            {
+                previousDateTimeZoneHandling = jsonWriter.DateTimeZoneHandling;
+                jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
+            }
+
+            FloatFormatHandling? previousFloatFormatHandling = null;
+            if (_floatFormatHandling != null && jsonWriter.FloatFormatHandling != _floatFormatHandling)
+            {
+                previousFloatFormatHandling = jsonWriter.FloatFormatHandling;
+                jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault();
+            }
+
+            StringEscapeHandling? previousStringEscapeHandling = null;
+            if (_stringEscapeHandling != null && jsonWriter.StringEscapeHandling != _stringEscapeHandling)
+            {
+                previousStringEscapeHandling = jsonWriter.StringEscapeHandling;
+                jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault();
+            }
+
+            CultureInfo? previousCulture = null;
+            if (_culture != null && !_culture.Equals(jsonWriter.Culture))
+            {
+                previousCulture = jsonWriter.Culture;
+                jsonWriter.Culture = _culture;
+            }
+
+            string? previousDateFormatString = null;
+            if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString)
+            {
+                previousDateFormatString = jsonWriter.DateFormatString;
+                jsonWriter.DateFormatString = _dateFormatString;
+            }
+
+            TraceJsonWriter? traceJsonWriter = (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                ? new TraceJsonWriter(jsonWriter)
+                : null;
+
+            JsonSerializerInternalWriter serializerWriter = new JsonSerializerInternalWriter(this);
+            serializerWriter.Serialize(traceJsonWriter ?? jsonWriter, value, objectType);
+
+            if (traceJsonWriter != null)
+            {
+                TraceWriter!.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null);
+            }
+
+            // reset writer back to previous options
+            if (previousFormatting != null)
+            {
+                jsonWriter.Formatting = previousFormatting.GetValueOrDefault();
+            }
+            if (previousDateFormatHandling != null)
+            {
+                jsonWriter.DateFormatHandling = previousDateFormatHandling.GetValueOrDefault();
+            }
+            if (previousDateTimeZoneHandling != null)
+            {
+                jsonWriter.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
+            }
+            if (previousFloatFormatHandling != null)
+            {
+                jsonWriter.FloatFormatHandling = previousFloatFormatHandling.GetValueOrDefault();
+            }
+            if (previousStringEscapeHandling != null)
+            {
+                jsonWriter.StringEscapeHandling = previousStringEscapeHandling.GetValueOrDefault();
+            }
+            if (_dateFormatStringSet)
+            {
+                jsonWriter.DateFormatString = previousDateFormatString;
+            }
+            if (previousCulture != null)
+            {
+                jsonWriter.Culture = previousCulture;
+            }
+        }
+
+        internal IReferenceResolver GetReferenceResolver()
+        {
+            if (_referenceResolver == null)
+            {
+                _referenceResolver = new DefaultReferenceResolver();
+            }
+
+            return _referenceResolver;
+        }
+
+        internal JsonConverter? GetMatchingConverter(Type type)
+        {
+            return GetMatchingConverter(_converters, type);
+        }
+
+        internal static JsonConverter? GetMatchingConverter(IList<JsonConverter>? converters, Type objectType)
+        {
+#if DEBUG
+            ValidationUtils.ArgumentNotNull(objectType, nameof(objectType));
+#endif
+
+            if (converters != null)
+            {
+                for (int i = 0; i < converters.Count; i++)
+                {
+                    JsonConverter converter = converters[i];
+
+                    if (converter.CanConvert(objectType))
+                    {
+                        return converter;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        internal void OnError(ErrorEventArgs e)
+        {
+            Error?.Invoke(this, e);
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/JsonSerializerSettings.cs b/Libs/Newtonsoft.Json/JsonSerializerSettings.cs
new file mode 100644
index 0000000..e0d42b8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonSerializerSettings.cs
@@ -0,0 +1,456 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Runtime.Serialization.Formatters;
+using LC.Newtonsoft.Json.Serialization;
+using System.Runtime.Serialization;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies the settings on a <see cref="JsonSerializer"/> object.
+    /// </summary>
+    public class JsonSerializerSettings
+    {
+        internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error;
+        internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore;
+        internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include;
+        internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include;
+        internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto;
+        internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None;
+        internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default;
+        internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None;
+        internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default;
+        internal static readonly StreamingContext DefaultContext;
+
+        internal const Formatting DefaultFormatting = Formatting.None;
+        internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat;
+        internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
+        internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime;
+        internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double;
+        internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String;
+        internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default;
+        internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;
+        internal static readonly CultureInfo DefaultCulture;
+        internal const bool DefaultCheckAdditionalContent = false;
+        internal const string DefaultDateFormatString = @"yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
+        internal const int DefaultMaxDepth = 64;
+
+        internal Formatting? _formatting;
+        internal DateFormatHandling? _dateFormatHandling;
+        internal DateTimeZoneHandling? _dateTimeZoneHandling;
+        internal DateParseHandling? _dateParseHandling;
+        internal FloatFormatHandling? _floatFormatHandling;
+        internal FloatParseHandling? _floatParseHandling;
+        internal StringEscapeHandling? _stringEscapeHandling;
+        internal CultureInfo? _culture;
+        internal bool? _checkAdditionalContent;
+        internal int? _maxDepth;
+        internal bool _maxDepthSet;
+        internal string? _dateFormatString;
+        internal bool _dateFormatStringSet;
+        internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling;
+        internal DefaultValueHandling? _defaultValueHandling;
+        internal PreserveReferencesHandling? _preserveReferencesHandling;
+        internal NullValueHandling? _nullValueHandling;
+        internal ObjectCreationHandling? _objectCreationHandling;
+        internal MissingMemberHandling? _missingMemberHandling;
+        internal ReferenceLoopHandling? _referenceLoopHandling;
+        internal StreamingContext? _context;
+        internal ConstructorHandling? _constructorHandling;
+        internal TypeNameHandling? _typeNameHandling;
+        internal MetadataPropertyHandling? _metadataPropertyHandling;
+
+        /// <summary>
+        /// Gets or sets how reference loops (e.g. a class referencing itself) are handled.
+        /// The default value is <see cref="Json.ReferenceLoopHandling.Error" />.
+        /// </summary>
+        /// <value>Reference loop handling.</value>
+        public ReferenceLoopHandling ReferenceLoopHandling
+        {
+            get => _referenceLoopHandling ?? DefaultReferenceLoopHandling;
+            set => _referenceLoopHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization.
+        /// The default value is <see cref="Json.MissingMemberHandling.Ignore" />.
+        /// </summary>
+        /// <value>Missing member handling.</value>
+        public MissingMemberHandling MissingMemberHandling
+        {
+            get => _missingMemberHandling ?? DefaultMissingMemberHandling;
+            set => _missingMemberHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how objects are created during deserialization.
+        /// The default value is <see cref="Json.ObjectCreationHandling.Auto" />.
+        /// </summary>
+        /// <value>The object creation handling.</value>
+        public ObjectCreationHandling ObjectCreationHandling
+        {
+            get => _objectCreationHandling ?? DefaultObjectCreationHandling;
+            set => _objectCreationHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how null values are handled during serialization and deserialization.
+        /// The default value is <see cref="Json.NullValueHandling.Include" />.
+        /// </summary>
+        /// <value>Null value handling.</value>
+        public NullValueHandling NullValueHandling
+        {
+            get => _nullValueHandling ?? DefaultNullValueHandling;
+            set => _nullValueHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how default values are handled during serialization and deserialization.
+        /// The default value is <see cref="Json.DefaultValueHandling.Include" />.
+        /// </summary>
+        /// <value>The default value handling.</value>
+        public DefaultValueHandling DefaultValueHandling
+        {
+            get => _defaultValueHandling ?? DefaultDefaultValueHandling;
+            set => _defaultValueHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets a <see cref="JsonConverter"/> collection that will be used during serialization.
+        /// </summary>
+        /// <value>The converters.</value>
+        public IList<JsonConverter> Converters { get; set; }
+
+        /// <summary>
+        /// Gets or sets how object references are preserved by the serializer.
+        /// The default value is <see cref="Json.PreserveReferencesHandling.None" />.
+        /// </summary>
+        /// <value>The preserve references handling.</value>
+        public PreserveReferencesHandling PreserveReferencesHandling
+        {
+            get => _preserveReferencesHandling ?? DefaultPreserveReferencesHandling;
+            set => _preserveReferencesHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how type name writing and reading is handled by the serializer.
+        /// The default value is <see cref="Json.TypeNameHandling.None" />.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="JsonSerializerSettings.TypeNameHandling"/> should be used with caution when your application deserializes JSON from an external source.
+        /// Incoming types should be validated with a custom <see cref="JsonSerializerSettings.SerializationBinder"/>
+        /// when deserializing with a value other than <see cref="Json.TypeNameHandling.None"/>.
+        /// </remarks>
+        /// <value>The type name handling.</value>
+        public TypeNameHandling TypeNameHandling
+        {
+            get => _typeNameHandling ?? DefaultTypeNameHandling;
+            set => _typeNameHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how metadata properties are used during deserialization.
+        /// The default value is <see cref="Json.MetadataPropertyHandling.Default" />.
+        /// </summary>
+        /// <value>The metadata properties handling.</value>
+        public MetadataPropertyHandling MetadataPropertyHandling
+        {
+            get => _metadataPropertyHandling ?? DefaultMetadataPropertyHandling;
+            set => _metadataPropertyHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how a type name assembly is written and resolved by the serializer.
+        /// The default value is <see cref="FormatterAssemblyStyle.Simple" />.
+        /// </summary>
+        /// <value>The type name assembly format.</value>
+        [Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
+        public FormatterAssemblyStyle TypeNameAssemblyFormat
+        {
+            get => (FormatterAssemblyStyle)TypeNameAssemblyFormatHandling;
+            set => TypeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
+        }
+
+        /// <summary>
+        /// Gets or sets how a type name assembly is written and resolved by the serializer.
+        /// The default value is <see cref="Json.TypeNameAssemblyFormatHandling.Simple" />.
+        /// </summary>
+        /// <value>The type name assembly format.</value>
+        public TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
+        {
+            get => _typeNameAssemblyFormatHandling ?? DefaultTypeNameAssemblyFormatHandling;
+            set => _typeNameAssemblyFormatHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how constructors are used during deserialization.
+        /// The default value is <see cref="Json.ConstructorHandling.Default" />.
+        /// </summary>
+        /// <value>The constructor handling.</value>
+        public ConstructorHandling ConstructorHandling
+        {
+            get => _constructorHandling ?? DefaultConstructorHandling;
+            set => _constructorHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the contract resolver used by the serializer when
+        /// serializing .NET objects to JSON and vice versa.
+        /// </summary>
+        /// <value>The contract resolver.</value>
+        public IContractResolver? ContractResolver { get; set; }
+
+        /// <summary>
+        /// Gets or sets the equality comparer used by the serializer when comparing references.
+        /// </summary>
+        /// <value>The equality comparer.</value>
+        public IEqualityComparer? EqualityComparer { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="IReferenceResolver"/> used by the serializer when resolving references.
+        /// </summary>
+        /// <value>The reference resolver.</value>
+        [Obsolete("ReferenceResolver property is obsolete. Use the ReferenceResolverProvider property to set the IReferenceResolver: settings.ReferenceResolverProvider = () => resolver")]
+        public IReferenceResolver? ReferenceResolver
+        {
+            get => ReferenceResolverProvider?.Invoke();
+            set
+            {
+                ReferenceResolverProvider = (value != null)
+                    ? () => value
+                    : (Func<IReferenceResolver?>?)null;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a function that creates the <see cref="IReferenceResolver"/> used by the serializer when resolving references.
+        /// </summary>
+        /// <value>A function that creates the <see cref="IReferenceResolver"/> used by the serializer when resolving references.</value>
+        public Func<IReferenceResolver?>? ReferenceResolverProvider { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ITraceWriter"/> used by the serializer when writing trace messages.
+        /// </summary>
+        /// <value>The trace writer.</value>
+        public ITraceWriter? TraceWriter { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="SerializationBinder"/> used by the serializer when resolving type names.
+        /// </summary>
+        /// <value>The binder.</value>
+        [Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
+        public SerializationBinder? Binder
+        {
+            get
+            {
+                if (SerializationBinder == null)
+                {
+                    return null;
+                }
+
+                if (SerializationBinder is SerializationBinderAdapter adapter)
+                {
+                    return adapter.SerializationBinder;
+                }
+
+                throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
+            }
+            set => SerializationBinder = value == null ? null : new SerializationBinderAdapter(value);
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ISerializationBinder"/> used by the serializer when resolving type names.
+        /// </summary>
+        /// <value>The binder.</value>
+        public ISerializationBinder? SerializationBinder { get; set; }
+
+        /// <summary>
+        /// Gets or sets the error handler called during serialization and deserialization.
+        /// </summary>
+        /// <value>The error handler called during serialization and deserialization.</value>
+        public EventHandler<ErrorEventArgs>? Error { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="StreamingContext"/> used by the serializer when invoking serialization callback methods.
+        /// </summary>
+        /// <value>The context.</value>
+        public StreamingContext Context
+        {
+            get => _context ?? DefaultContext;
+            set => _context = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how <see cref="DateTime"/> and <see cref="DateTimeOffset"/> values are formatted when writing JSON text,
+        /// and the expected date format when reading JSON text.
+        /// The default value is <c>"yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"</c>.
+        /// </summary>
+        public string DateFormatString
+        {
+            get => _dateFormatString ?? DefaultDateFormatString;
+            set
+            {
+                _dateFormatString = value;
+                _dateFormatStringSet = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a <see cref="JsonReaderException"/>.
+        /// A null value means there is no maximum.
+        /// The default value is <c>128</c>.
+        /// </summary>
+        public int? MaxDepth
+        {
+            get => _maxDepthSet ? _maxDepth : DefaultMaxDepth;
+            set
+            {
+                if (value <= 0)
+                {
+                    throw new ArgumentException("Value must be positive.", nameof(value));
+                }
+
+                _maxDepth = value;
+                _maxDepthSet = true;
+            }
+        }
+
+        /// <summary>
+        /// Indicates how JSON text output is formatted.
+        /// The default value is <see cref="Json.Formatting.None" />.
+        /// </summary>
+        public Formatting Formatting
+        {
+            get => _formatting ?? DefaultFormatting;
+            set => _formatting = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how dates are written to JSON text.
+        /// The default value is <see cref="Json.DateFormatHandling.IsoDateFormat" />.
+        /// </summary>
+        public DateFormatHandling DateFormatHandling
+        {
+            get => _dateFormatHandling ?? DefaultDateFormatHandling;
+            set => _dateFormatHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how <see cref="DateTime"/> time zones are handled during serialization and deserialization.
+        /// The default value is <see cref="Json.DateTimeZoneHandling.RoundtripKind" />.
+        /// </summary>
+        public DateTimeZoneHandling DateTimeZoneHandling
+        {
+            get => _dateTimeZoneHandling ?? DefaultDateTimeZoneHandling;
+            set => _dateTimeZoneHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how date formatted strings, e.g. <c>"\/Date(1198908717056)\/"</c> and <c>"2012-03-21T05:40Z"</c>, are parsed when reading JSON.
+        /// The default value is <see cref="Json.DateParseHandling.DateTime" />.
+        /// </summary>
+        public DateParseHandling DateParseHandling
+        {
+            get => _dateParseHandling ?? DefaultDateParseHandling;
+            set => _dateParseHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how special floating point numbers, e.g. <see cref="Double.NaN"/>,
+        /// <see cref="Double.PositiveInfinity"/> and <see cref="Double.NegativeInfinity"/>,
+        /// are written as JSON.
+        /// The default value is <see cref="Json.FloatFormatHandling.String" />.
+        /// </summary>
+        public FloatFormatHandling FloatFormatHandling
+        {
+            get => _floatFormatHandling ?? DefaultFloatFormatHandling;
+            set => _floatFormatHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
+        /// The default value is <see cref="Json.FloatParseHandling.Double" />.
+        /// </summary>
+        public FloatParseHandling FloatParseHandling
+        {
+            get => _floatParseHandling ?? DefaultFloatParseHandling;
+            set => _floatParseHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets how strings are escaped when writing JSON text.
+        /// The default value is <see cref="Json.StringEscapeHandling.Default" />.
+        /// </summary>
+        public StringEscapeHandling StringEscapeHandling
+        {
+            get => _stringEscapeHandling ?? DefaultStringEscapeHandling;
+            set => _stringEscapeHandling = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the culture used when reading JSON.
+        /// The default value is <see cref="CultureInfo.InvariantCulture"/>.
+        /// </summary>
+        public CultureInfo Culture
+        {
+            get => _culture ?? DefaultCulture;
+            set => _culture = value;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether there will be a check for additional content after deserializing an object.
+        /// The default value is <c>false</c>.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if there will be a check for additional content after deserializing an object; otherwise, <c>false</c>.
+        /// </value>
+        public bool CheckAdditionalContent
+        {
+            get => _checkAdditionalContent ?? DefaultCheckAdditionalContent;
+            set => _checkAdditionalContent = value;
+        }
+
+        static JsonSerializerSettings()
+        {
+            DefaultContext = new StreamingContext();
+            DefaultCulture = CultureInfo.InvariantCulture;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSerializerSettings"/> class.
+        /// </summary>
+        [DebuggerStepThrough]
+        public JsonSerializerSettings()
+        {
+            Converters = new List<JsonConverter>();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonTextReader.Async.cs b/Libs/Newtonsoft.Json/JsonTextReader.Async.cs
new file mode 100644
index 0000000..79ffe99
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonTextReader.Async.cs
@@ -0,0 +1,1806 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Globalization;
+using System.Threading;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json
+{
+    public partial class JsonTextReader
+    {
+        // It's not safe to perform the async methods here in a derived class as if the synchronous equivalent
+        // has been overriden then the asychronous method will no longer be doing the same operation
+#if HAVE_ASYNC // Double-check this isn't included inappropriately.
+        private readonly bool _safeAsync;
+#endif
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns <c>true</c> if the next token was read successfully; <c>false</c> if there are no more tokens to read.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<bool> ReadAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsync(cancellationToken) : base.ReadAsync(cancellationToken);
+        }
+
+        internal Task<bool> DoReadAsync(CancellationToken cancellationToken)
+        {
+            EnsureBuffer();
+
+            while (true)
+            {
+                switch (_currentState)
+                {
+                    case State.Start:
+                    case State.Property:
+                    case State.Array:
+                    case State.ArrayStart:
+                    case State.Constructor:
+                    case State.ConstructorStart:
+                        return ParseValueAsync(cancellationToken);
+                    case State.Object:
+                    case State.ObjectStart:
+                        return ParseObjectAsync(cancellationToken);
+                    case State.PostValue:
+                        Task<bool> task = ParsePostValueAsync(false, cancellationToken);
+                        if (task.IsCompletedSucessfully())
+                        {
+                            if (task.Result)
+                            {
+                                return AsyncUtils.True;
+                            }
+                        }
+                        else
+                        {
+                            return DoReadAsync(task, cancellationToken);
+                        }
+                        break;
+                    case State.Finished:
+                        return ReadFromFinishedAsync(cancellationToken);
+                    default:
+                        throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+                }
+            }
+        }
+
+        private async Task<bool> DoReadAsync(Task<bool> task, CancellationToken cancellationToken)
+        {
+            bool result = await task.ConfigureAwait(false);
+            if (result)
+            {
+                return true;
+            }
+            return await DoReadAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        private async Task<bool> ParsePostValueAsync(bool ignoreComments, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
+                            {
+                                _currentState = State.Finished;
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+
+                        break;
+                    case '}':
+                        _charPos++;
+                        SetToken(JsonToken.EndObject);
+                        return true;
+                    case ']':
+                        _charPos++;
+                        SetToken(JsonToken.EndArray);
+                        return true;
+                    case ')':
+                        _charPos++;
+                        SetToken(JsonToken.EndConstructor);
+                        return true;
+                    case '/':
+                        await ParseCommentAsync(!ignoreComments, cancellationToken).ConfigureAwait(false);
+                        if (!ignoreComments)
+                        {
+                            return true;
+                        }
+                        break;
+                    case ',':
+                        _charPos++;
+
+                        // finished parsing
+                        SetStateBasedOnCurrent();
+                        return false;
+                    case ' ':
+                    case StringUtils.Tab:
+
+                        // eat
+                        _charPos++;
+                        break;
+                    case StringUtils.CarriageReturn:
+                        await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    default:
+                        if (char.IsWhiteSpace(currentChar))
+                        {
+                            // eat
+                            _charPos++;
+                        }
+                        else
+                        {
+                            // handle multiple content without comma delimiter
+                            if (SupportMultipleContent && Depth == 0)
+                            {
+                                SetStateBasedOnCurrent();
+                                return false;
+                            }
+
+                            throw JsonReaderException.Create(this, "After parsing a value an unexpected character was encountered: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
+                        }
+
+                        break;
+                }
+            }
+        }
+
+        private async Task<bool> ReadFromFinishedAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (await EnsureCharsAsync(0, false, cancellationToken).ConfigureAwait(false))
+            {
+                await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
+                if (_isEndOfFile)
+                {
+                    SetToken(JsonToken.None);
+                    return false;
+                }
+
+                if (_chars[_charPos] == '/')
+                {
+                    await ParseCommentAsync(true, cancellationToken).ConfigureAwait(false);
+                    return true;
+                }
+
+                throw JsonReaderException.Create(this, "Additional text encountered after finished reading JSON content: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+            }
+
+            SetToken(JsonToken.None);
+            return false;
+        }
+
+        private Task<int> ReadDataAsync(bool append, CancellationToken cancellationToken)
+        {
+            return ReadDataAsync(append, 0, cancellationToken);
+        }
+
+        private async Task<int> ReadDataAsync(bool append, int charsRequired, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (_isEndOfFile)
+            {
+                return 0;
+            }
+
+            PrepareBufferForReadData(append, charsRequired);
+
+            int charsRead = await _reader.ReadAsync(_chars, _charsUsed, _chars.Length - _charsUsed - 1, cancellationToken).ConfigureAwait(false);
+
+            _charsUsed += charsRead;
+
+            if (charsRead == 0)
+            {
+                _isEndOfFile = true;
+            }
+
+            _chars[_charsUsed] = '\0';
+            return charsRead;
+        }
+
+        private async Task<bool> ParseValueAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+
+                        break;
+                    case '"':
+                    case '\'':
+                        await ParseStringAsync(currentChar, ReadType.Read, cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case 't':
+                        await ParseTrueAsync(cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case 'f':
+                        await ParseFalseAsync(cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case 'n':
+                        if (await EnsureCharsAsync(1, true, cancellationToken).ConfigureAwait(false))
+                        {
+                            switch (_chars[_charPos + 1])
+                            {
+                                case 'u':
+                                    await ParseNullAsync(cancellationToken).ConfigureAwait(false);
+                                    break;
+                                case 'e':
+                                    await ParseConstructorAsync(cancellationToken).ConfigureAwait(false);
+                                    break;
+                                default:
+                                    throw CreateUnexpectedCharacterException(_chars[_charPos]);
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                            throw CreateUnexpectedEndException();
+                        }
+
+                        return true;
+                    case 'N':
+                        await ParseNumberNaNAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case 'I':
+                        await ParseNumberPositiveInfinityAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case '-':
+                        if (await EnsureCharsAsync(1, true, cancellationToken).ConfigureAwait(false) && _chars[_charPos + 1] == 'I')
+                        {
+                            await ParseNumberNegativeInfinityAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
+                        }
+                        else
+                        {
+                            await ParseNumberAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
+                        }
+                        return true;
+                    case '/':
+                        await ParseCommentAsync(true, cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case 'u':
+                        await ParseUndefinedAsync(cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case '{':
+                        _charPos++;
+                        SetToken(JsonToken.StartObject);
+                        return true;
+                    case '[':
+                        _charPos++;
+                        SetToken(JsonToken.StartArray);
+                        return true;
+                    case ']':
+                        _charPos++;
+                        SetToken(JsonToken.EndArray);
+                        return true;
+                    case ',':
+
+                        // don't increment position, the next call to read will handle comma
+                        // this is done to handle multiple empty comma values
+                        SetToken(JsonToken.Undefined);
+                        return true;
+                    case ')':
+                        _charPos++;
+                        SetToken(JsonToken.EndConstructor);
+                        return true;
+                    case StringUtils.CarriageReturn:
+                        await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    case ' ':
+                    case StringUtils.Tab:
+
+                        // eat
+                        _charPos++;
+                        break;
+                    default:
+                        if (char.IsWhiteSpace(currentChar))
+                        {
+                            // eat
+                            _charPos++;
+                            break;
+                        }
+
+                        if (char.IsNumber(currentChar) || currentChar == '-' || currentChar == '.')
+                        {
+                            await ParseNumberAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
+                            return true;
+                        }
+
+                        throw CreateUnexpectedCharacterException(currentChar);
+                }
+            }
+        }
+
+        private async Task ReadStringIntoBufferAsync(char quote, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            int charPos = _charPos;
+            int initialPosition = _charPos;
+            int lastWritePosition = _charPos;
+            _stringBuffer.Position = 0;
+
+            while (true)
+            {
+                switch (_chars[charPos++])
+                {
+                    case '\0':
+                        if (_charsUsed == charPos - 1)
+                        {
+                            charPos--;
+
+                            if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
+                            {
+                                _charPos = charPos;
+                                throw JsonReaderException.Create(this, "Unterminated string. Expected delimiter: {0}.".FormatWith(CultureInfo.InvariantCulture, quote));
+                            }
+                        }
+
+                        break;
+                    case '\\':
+                        _charPos = charPos;
+                        if (!await EnsureCharsAsync(0, true, cancellationToken).ConfigureAwait(false))
+                        {
+                            throw JsonReaderException.Create(this, "Unterminated string. Expected delimiter: {0}.".FormatWith(CultureInfo.InvariantCulture, quote));
+                        }
+
+                        // start of escape sequence
+                        int escapeStartPos = charPos - 1;
+
+                        char currentChar = _chars[charPos];
+                        charPos++;
+
+                        char writeChar;
+
+                        switch (currentChar)
+                        {
+                            case 'b':
+                                writeChar = '\b';
+                                break;
+                            case 't':
+                                writeChar = '\t';
+                                break;
+                            case 'n':
+                                writeChar = '\n';
+                                break;
+                            case 'f':
+                                writeChar = '\f';
+                                break;
+                            case 'r':
+                                writeChar = '\r';
+                                break;
+                            case '\\':
+                                writeChar = '\\';
+                                break;
+                            case '"':
+                            case '\'':
+                            case '/':
+                                writeChar = currentChar;
+                                break;
+                            case 'u':
+                                _charPos = charPos;
+                                writeChar = await ParseUnicodeAsync(cancellationToken).ConfigureAwait(false);
+
+                                if (StringUtils.IsLowSurrogate(writeChar))
+                                {
+                                    // low surrogate with no preceding high surrogate; this char is replaced
+                                    writeChar = UnicodeReplacementChar;
+                                }
+                                else if (StringUtils.IsHighSurrogate(writeChar))
+                                {
+                                    bool anotherHighSurrogate;
+
+                                    // loop for handling situations where there are multiple consecutive high surrogates
+                                    do
+                                    {
+                                        anotherHighSurrogate = false;
+
+                                        // potential start of a surrogate pair
+                                        if (await EnsureCharsAsync(2, true, cancellationToken).ConfigureAwait(false) && _chars[_charPos] == '\\' && _chars[_charPos + 1] == 'u')
+                                        {
+                                            char highSurrogate = writeChar;
+
+                                            _charPos += 2;
+                                            writeChar = await ParseUnicodeAsync(cancellationToken).ConfigureAwait(false);
+
+                                            if (StringUtils.IsLowSurrogate(writeChar))
+                                            {
+                                                // a valid surrogate pair!
+                                            }
+                                            else if (StringUtils.IsHighSurrogate(writeChar))
+                                            {
+                                                // another high surrogate; replace current and start check over
+                                                highSurrogate = UnicodeReplacementChar;
+                                                anotherHighSurrogate = true;
+                                            }
+                                            else
+                                            {
+                                                // high surrogate not followed by low surrogate; original char is replaced
+                                                highSurrogate = UnicodeReplacementChar;
+                                            }
+
+                                            EnsureBufferNotEmpty();
+
+                                            WriteCharToBuffer(highSurrogate, lastWritePosition, escapeStartPos);
+                                            lastWritePosition = _charPos;
+                                        }
+                                        else
+                                        {
+                                            // there are not enough remaining chars for the low surrogate or is not follow by unicode sequence
+                                            // replace high surrogate and continue on as usual
+                                            writeChar = UnicodeReplacementChar;
+                                        }
+                                    } while (anotherHighSurrogate);
+                                }
+
+                                charPos = _charPos;
+                                break;
+                            default:
+                                _charPos = charPos;
+                                throw JsonReaderException.Create(this, "Bad JSON escape sequence: {0}.".FormatWith(CultureInfo.InvariantCulture, @"\" + currentChar));
+                        }
+
+                        EnsureBufferNotEmpty();
+                        WriteCharToBuffer(writeChar, lastWritePosition, escapeStartPos);
+
+                        lastWritePosition = charPos;
+                        break;
+                    case StringUtils.CarriageReturn:
+                        _charPos = charPos - 1;
+                        await ProcessCarriageReturnAsync(true, cancellationToken).ConfigureAwait(false);
+                        charPos = _charPos;
+                        break;
+                    case StringUtils.LineFeed:
+                        _charPos = charPos - 1;
+                        ProcessLineFeed();
+                        charPos = _charPos;
+                        break;
+                    case '"':
+                    case '\'':
+                        if (_chars[charPos - 1] == quote)
+                        {
+                            FinishReadStringIntoBuffer(charPos - 1, initialPosition, lastWritePosition);
+                            return;
+                        }
+
+                        break;
+                }
+            }
+        }
+
+        private Task ProcessCarriageReturnAsync(bool append, CancellationToken cancellationToken)
+        {
+            _charPos++;
+
+            Task<bool> task = EnsureCharsAsync(1, append, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                SetNewLine(task.Result);
+                return AsyncUtils.CompletedTask;
+            }
+
+            return ProcessCarriageReturnAsync(task);
+        }
+
+        private async Task ProcessCarriageReturnAsync(Task<bool> task)
+        {
+            SetNewLine(await task.ConfigureAwait(false));
+        }
+
+        private async Task<char> ParseUnicodeAsync(CancellationToken cancellationToken)
+        {
+            return ConvertUnicode(await EnsureCharsAsync(4, true, cancellationToken).ConfigureAwait(false));
+        }
+
+        private Task<bool> EnsureCharsAsync(int relativePosition, bool append, CancellationToken cancellationToken)
+        {
+            if (_charPos + relativePosition < _charsUsed)
+            {
+                return AsyncUtils.True;
+            }
+
+            if (_isEndOfFile)
+            {
+                return AsyncUtils.False;
+            }
+
+            return ReadCharsAsync(relativePosition, append, cancellationToken);
+        }
+
+        private async Task<bool> ReadCharsAsync(int relativePosition, bool append, CancellationToken cancellationToken)
+        {
+            int charsRequired = _charPos + relativePosition - _charsUsed + 1;
+
+            // it is possible that the TextReader doesn't return all data at once
+            // repeat read until the required text is returned or the reader is out of content
+            do
+            {
+                int charsRead = await ReadDataAsync(append, charsRequired, cancellationToken).ConfigureAwait(false);
+
+                // no more content
+                if (charsRead == 0)
+                {
+                    return false;
+                }
+
+                charsRequired -= charsRead;
+            } while (charsRequired > 0);
+
+            return true;
+        }
+
+        private async Task<bool> ParseObjectAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+
+                        break;
+                    case '}':
+                        SetToken(JsonToken.EndObject);
+                        _charPos++;
+                        return true;
+                    case '/':
+                        await ParseCommentAsync(true, cancellationToken).ConfigureAwait(false);
+                        return true;
+                    case StringUtils.CarriageReturn:
+                        await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    case ' ':
+                    case StringUtils.Tab:
+
+                        // eat
+                        _charPos++;
+                        break;
+                    default:
+                        if (char.IsWhiteSpace(currentChar))
+                        {
+                            // eat
+                            _charPos++;
+                        }
+                        else
+                        {
+                            return await ParsePropertyAsync(cancellationToken).ConfigureAwait(false);
+                        }
+
+                        break;
+                }
+            }
+        }
+
+        private async Task ParseCommentAsync(bool setToken, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            // should have already parsed / character before reaching this method
+            _charPos++;
+
+            if (!await EnsureCharsAsync(1, false, cancellationToken).ConfigureAwait(false))
+            {
+                throw JsonReaderException.Create(this, "Unexpected end while parsing comment.");
+            }
+
+            bool singlelineComment;
+
+            if (_chars[_charPos] == '*')
+            {
+                singlelineComment = false;
+            }
+            else if (_chars[_charPos] == '/')
+            {
+                singlelineComment = true;
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Error parsing comment. Expected: *, got {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+            }
+
+            _charPos++;
+
+            int initialPosition = _charPos;
+
+            while (true)
+            {
+                switch (_chars[_charPos])
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
+                            {
+                                if (!singlelineComment)
+                                {
+                                    throw JsonReaderException.Create(this, "Unexpected end while parsing comment.");
+                                }
+
+                                EndComment(setToken, initialPosition, _charPos);
+                                return;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+
+                        break;
+                    case '*':
+                        _charPos++;
+
+                        if (!singlelineComment)
+                        {
+                            if (await EnsureCharsAsync(0, true, cancellationToken).ConfigureAwait(false))
+                            {
+                                if (_chars[_charPos] == '/')
+                                {
+                                    EndComment(setToken, initialPosition, _charPos - 1);
+
+                                    _charPos++;
+                                    return;
+                                }
+                            }
+                        }
+
+                        break;
+                    case StringUtils.CarriageReturn:
+                        if (singlelineComment)
+                        {
+                            EndComment(setToken, initialPosition, _charPos);
+                            return;
+                        }
+
+                        await ProcessCarriageReturnAsync(true, cancellationToken).ConfigureAwait(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        if (singlelineComment)
+                        {
+                            EndComment(setToken, initialPosition, _charPos);
+                            return;
+                        }
+
+                        ProcessLineFeed();
+                        break;
+                    default:
+                        _charPos++;
+                        break;
+                }
+            }
+        }
+
+        private async Task EatWhitespaceAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
+                            {
+                                return;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+                        break;
+                    case StringUtils.CarriageReturn:
+                        await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    default:
+                        if (currentChar == ' ' || char.IsWhiteSpace(currentChar))
+                        {
+                            _charPos++;
+                        }
+                        else
+                        {
+                            return;
+                        }
+                        break;
+                }
+            }
+        }
+
+        private async Task ParseStringAsync(char quote, ReadType readType, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            _charPos++;
+
+            ShiftBufferIfNeeded();
+            await ReadStringIntoBufferAsync(quote, cancellationToken).ConfigureAwait(false);
+            ParseReadString(quote, readType);
+        }
+
+        private async Task<bool> MatchValueAsync(string value, CancellationToken cancellationToken)
+        {
+            return MatchValue(await EnsureCharsAsync(value.Length - 1, true, cancellationToken).ConfigureAwait(false), value);
+        }
+
+        private async Task<bool> MatchValueWithTrailingSeparatorAsync(string value, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            // will match value and then move to the next character, checking that it is a separator character
+            if (!await MatchValueAsync(value, cancellationToken).ConfigureAwait(false))
+            {
+                return false;
+            }
+
+            if (!await EnsureCharsAsync(0, false, cancellationToken).ConfigureAwait(false))
+            {
+                return true;
+            }
+
+            return IsSeparator(_chars[_charPos]) || _chars[_charPos] == '\0';
+        }
+
+        private async Task MatchAndSetAsync(string value, JsonToken newToken, object? tokenValue, CancellationToken cancellationToken)
+        {
+            if (await MatchValueWithTrailingSeparatorAsync(value, cancellationToken).ConfigureAwait(false))
+            {
+                SetToken(newToken, tokenValue);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Error parsing " + newToken.ToString().ToLowerInvariant() + " value.");
+            }
+        }
+
+        private Task ParseTrueAsync(CancellationToken cancellationToken)
+        {
+            return MatchAndSetAsync(JsonConvert.True, JsonToken.Boolean, true, cancellationToken);
+        }
+
+        private Task ParseFalseAsync(CancellationToken cancellationToken)
+        {
+            return MatchAndSetAsync(JsonConvert.False, JsonToken.Boolean, false, cancellationToken);
+        }
+
+        private Task ParseNullAsync(CancellationToken cancellationToken)
+        {
+            return MatchAndSetAsync(JsonConvert.Null, JsonToken.Null, null, cancellationToken);
+        }
+
+        private async Task ParseConstructorAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (await MatchValueWithTrailingSeparatorAsync("new", cancellationToken).ConfigureAwait(false))
+            {
+                await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
+
+                int initialPosition = _charPos;
+                int endPosition;
+
+                while (true)
+                {
+                    char currentChar = _chars[_charPos];
+                    if (currentChar == '\0')
+                    {
+                        if (_charsUsed == _charPos)
+                        {
+                            if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
+                            {
+                                throw JsonReaderException.Create(this, "Unexpected end while parsing constructor.");
+                            }
+                        }
+                        else
+                        {
+                            endPosition = _charPos;
+                            _charPos++;
+                            break;
+                        }
+                    }
+                    else if (char.IsLetterOrDigit(currentChar))
+                    {
+                        _charPos++;
+                    }
+                    else if (currentChar == StringUtils.CarriageReturn)
+                    {
+                        endPosition = _charPos;
+                        await ProcessCarriageReturnAsync(true, cancellationToken).ConfigureAwait(false);
+                        break;
+                    }
+                    else if (currentChar == StringUtils.LineFeed)
+                    {
+                        endPosition = _charPos;
+                        ProcessLineFeed();
+                        break;
+                    }
+                    else if (char.IsWhiteSpace(currentChar))
+                    {
+                        endPosition = _charPos;
+                        _charPos++;
+                        break;
+                    }
+                    else if (currentChar == '(')
+                    {
+                        endPosition = _charPos;
+                        break;
+                    }
+                    else
+                    {
+                        throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
+                    }
+                }
+
+                _stringReference = new StringReference(_chars, initialPosition, endPosition - initialPosition);
+                string constructorName = _stringReference.ToString();
+
+                await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
+
+                if (_chars[_charPos] != '(')
+                {
+                    throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+                }
+
+                _charPos++;
+
+                ClearRecentString();
+
+                SetToken(JsonToken.StartConstructor, constructorName);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Unexpected content while parsing JSON.");
+            }
+        }
+
+        private async Task<object> ParseNumberNaNAsync(ReadType readType, CancellationToken cancellationToken)
+        {
+            return ParseNumberNaN(readType, await MatchValueWithTrailingSeparatorAsync(JsonConvert.NaN, cancellationToken).ConfigureAwait(false));
+        }
+
+        private async Task<object> ParseNumberPositiveInfinityAsync(ReadType readType, CancellationToken cancellationToken)
+        {
+            return ParseNumberPositiveInfinity(readType, await MatchValueWithTrailingSeparatorAsync(JsonConvert.PositiveInfinity, cancellationToken).ConfigureAwait(false));
+        }
+
+        private async Task<object> ParseNumberNegativeInfinityAsync(ReadType readType, CancellationToken cancellationToken)
+        {
+            return ParseNumberNegativeInfinity(readType, await MatchValueWithTrailingSeparatorAsync(JsonConvert.NegativeInfinity, cancellationToken).ConfigureAwait(false));
+        }
+
+        private async Task ParseNumberAsync(ReadType readType, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            ShiftBufferIfNeeded();
+
+            char firstChar = _chars[_charPos];
+            int initialPosition = _charPos;
+
+            await ReadNumberIntoBufferAsync(cancellationToken).ConfigureAwait(false);
+
+            ParseReadNumber(readType, firstChar, initialPosition);
+        }
+
+        private Task ParseUndefinedAsync(CancellationToken cancellationToken)
+        {
+            return MatchAndSetAsync(JsonConvert.Undefined, JsonToken.Undefined, null, cancellationToken);
+        }
+
+        private async Task<bool> ParsePropertyAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            char firstChar = _chars[_charPos];
+            char quoteChar;
+
+            if (firstChar == '"' || firstChar == '\'')
+            {
+                _charPos++;
+                quoteChar = firstChar;
+                ShiftBufferIfNeeded();
+                await ReadStringIntoBufferAsync(quoteChar, cancellationToken).ConfigureAwait(false);
+            }
+            else if (ValidIdentifierChar(firstChar))
+            {
+                quoteChar = '\0';
+                ShiftBufferIfNeeded();
+                await ParseUnquotedPropertyAsync(cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Invalid property identifier character: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+            }
+
+            string propertyName;
+
+            if (PropertyNameTable != null)
+            {
+                propertyName = PropertyNameTable.Get(_stringReference.Chars, _stringReference.StartIndex, _stringReference.Length)
+                    // no match in name table
+                    ?? _stringReference.ToString();
+            }
+            else
+            {
+                propertyName = _stringReference.ToString();
+            }
+
+            await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
+
+            if (_chars[_charPos] != ':')
+            {
+                throw JsonReaderException.Create(this, "Invalid character after parsing property name. Expected ':' but got: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+            }
+
+            _charPos++;
+
+            SetToken(JsonToken.PropertyName, propertyName);
+            _quoteChar = quoteChar;
+            ClearRecentString();
+
+            return true;
+        }
+
+        private async Task ReadNumberIntoBufferAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            int charPos = _charPos;
+
+            while (true)
+            {
+                char currentChar = _chars[charPos];
+                if (currentChar == '\0')
+                {
+                    _charPos = charPos;
+
+                    if (_charsUsed == charPos)
+                    {
+                        if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
+                        {
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        return;
+                    }
+                }
+                else if (ReadNumberCharIntoBuffer(currentChar, charPos))
+                {
+                    return;
+                }
+                else
+                {
+                    charPos++;
+                }
+            }
+        }
+
+        private async Task ParseUnquotedPropertyAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            int initialPosition = _charPos;
+
+            // parse unquoted property name until whitespace or colon
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+                if (currentChar == '\0')
+                {
+                    if (_charsUsed == _charPos)
+                    {
+                        if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
+                        {
+                            throw JsonReaderException.Create(this, "Unexpected end while parsing unquoted property name.");
+                        }
+
+                        continue;
+                    }
+
+                    _stringReference = new StringReference(_chars, initialPosition, _charPos - initialPosition);
+                    return;
+                }
+
+                if (ReadUnquotedPropertyReportIfDone(currentChar, initialPosition))
+                {
+                    return;
+                }
+            }
+        }
+
+        private async Task<bool> ReadNullCharAsync(CancellationToken cancellationToken)
+        {
+            if (_charsUsed == _charPos)
+            {
+                if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
+                {
+                    _isEndOfFile = true;
+                    return true;
+                }
+            }
+            else
+            {
+                _charPos++;
+            }
+
+            return false;
+        }
+
+        private async Task HandleNullAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (await EnsureCharsAsync(1, true, cancellationToken).ConfigureAwait(false))
+            {
+                if (_chars[_charPos + 1] == 'u')
+                {
+                    await ParseNullAsync(cancellationToken).ConfigureAwait(false);
+                    return;
+                }
+
+                _charPos += 2;
+                throw CreateUnexpectedCharacterException(_chars[_charPos - 1]);
+            }
+
+            _charPos = _charsUsed;
+            throw CreateUnexpectedEndException();
+        }
+
+        private async Task ReadFinishedAsync(CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (await EnsureCharsAsync(0, false, cancellationToken).ConfigureAwait(false))
+            {
+                await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
+                if (_isEndOfFile)
+                {
+                    SetToken(JsonToken.None);
+                    return;
+                }
+
+                if (_chars[_charPos] == '/')
+                {
+                    await ParseCommentAsync(false, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    throw JsonReaderException.Create(this, "Additional text encountered after finished reading JSON content: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+                }
+            }
+
+            SetToken(JsonToken.None);
+        }
+
+        private async Task<object?> ReadStringValueAsync(ReadType readType, CancellationToken cancellationToken)
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (await ParsePostValueAsync(true, cancellationToken).ConfigureAwait(false))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (await ReadNullCharAsync(cancellationToken).ConfigureAwait(false))
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+
+                                break;
+                            case '"':
+                            case '\'':
+                                await ParseStringAsync(currentChar, readType, cancellationToken).ConfigureAwait(false);
+                                return FinishReadQuotedStringValue(readType);
+                            case '-':
+                                if (await EnsureCharsAsync(1, true, cancellationToken).ConfigureAwait(false) && _chars[_charPos + 1] == 'I')
+                                {
+                                    return ParseNumberNegativeInfinity(readType);
+                                }
+                                else
+                                {
+                                    await ParseNumberAsync(readType, cancellationToken).ConfigureAwait(false);
+                                    return Value;
+                                }
+                            case '.':
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                if (readType != ReadType.ReadAsString)
+                                {
+                                    _charPos++;
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                await ParseNumberAsync(ReadType.ReadAsString, cancellationToken).ConfigureAwait(false);
+                                return Value;
+                            case 't':
+                            case 'f':
+                                if (readType != ReadType.ReadAsString)
+                                {
+                                    _charPos++;
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                string expected = currentChar == 't' ? JsonConvert.True : JsonConvert.False;
+                                if (!await MatchValueWithTrailingSeparatorAsync(expected, cancellationToken).ConfigureAwait(false))
+                                {
+                                    throw CreateUnexpectedCharacterException(_chars[_charPos]);
+                                }
+
+                                SetToken(JsonToken.String, expected);
+                                return expected;
+                            case 'I':
+                                return await ParseNumberPositiveInfinityAsync(readType, cancellationToken).ConfigureAwait(false);
+                            case 'N':
+                                return await ParseNumberNaNAsync(readType, cancellationToken).ConfigureAwait(false);
+                            case 'n':
+                                await HandleNullAsync(cancellationToken).ConfigureAwait(false);
+                                return null;
+                            case '/':
+                                await ParseCommentAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    await ReadFinishedAsync(cancellationToken).ConfigureAwait(false);
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        private async Task<object?> ReadNumberValueAsync(ReadType readType, CancellationToken cancellationToken)
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (await ParsePostValueAsync(true, cancellationToken).ConfigureAwait(false))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (await ReadNullCharAsync(cancellationToken).ConfigureAwait(false))
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+
+                                break;
+                            case '"':
+                            case '\'':
+                                await ParseStringAsync(currentChar, readType, cancellationToken).ConfigureAwait(false);
+                                return FinishReadQuotedNumber(readType);
+                            case 'n':
+                                await HandleNullAsync(cancellationToken).ConfigureAwait(false);
+                                return null;
+                            case 'N':
+                                return await ParseNumberNaNAsync(readType, cancellationToken).ConfigureAwait(false);
+                            case 'I':
+                                return await ParseNumberPositiveInfinityAsync(readType, cancellationToken).ConfigureAwait(false);
+                            case '-':
+                                if (await EnsureCharsAsync(1, true, cancellationToken).ConfigureAwait(false) && _chars[_charPos + 1] == 'I')
+                                {
+                                    return await ParseNumberNegativeInfinityAsync(readType, cancellationToken).ConfigureAwait(false);
+                                }
+                                else
+                                {
+                                    await ParseNumberAsync(readType, cancellationToken).ConfigureAwait(false);
+                                    return Value;
+                                }
+                            case '.':
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                await ParseNumberAsync(readType, cancellationToken).ConfigureAwait(false);
+                                return Value;
+                            case '/':
+                                await ParseCommentAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    await ReadFinishedAsync(cancellationToken).ConfigureAwait(false);
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="bool"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="bool"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsBooleanAsync(cancellationToken) : base.ReadAsBooleanAsync(cancellationToken);
+        }
+
+        internal async Task<bool?> DoReadAsBooleanAsync(CancellationToken cancellationToken)
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (await ParsePostValueAsync(true, cancellationToken).ConfigureAwait(false))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (await ReadNullCharAsync(cancellationToken).ConfigureAwait(false))
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+
+                                break;
+                            case '"':
+                            case '\'':
+                                await ParseStringAsync(currentChar, ReadType.Read, cancellationToken).ConfigureAwait(false);
+                                return ReadBooleanString(_stringReference.ToString());
+                            case 'n':
+                                await HandleNullAsync(cancellationToken).ConfigureAwait(false);
+                                return null;
+                            case '-':
+                            case '.':
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                await ParseNumberAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
+                                bool b;
+#if HAVE_BIG_INTEGER
+                                if (Value is BigInteger i)
+                                {
+                                    b = i != 0;
+                                }
+                                else
+#endif
+                                {
+                                    b = Convert.ToBoolean(Value, CultureInfo.InvariantCulture);
+                                }
+                                SetToken(JsonToken.Boolean, b, false);
+                                return b;
+                            case 't':
+                            case 'f':
+                                bool isTrue = currentChar == 't';
+                                if (!await MatchValueWithTrailingSeparatorAsync(isTrue ? JsonConvert.True : JsonConvert.False, cancellationToken).ConfigureAwait(false))
+                                {
+                                    throw CreateUnexpectedCharacterException(_chars[_charPos]);
+                                }
+
+                                SetToken(JsonToken.Boolean, isTrue);
+                                return isTrue;
+                            case '/':
+                                await ParseCommentAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    await ReadFinishedAsync(cancellationToken).ConfigureAwait(false);
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="byte"/>[].
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="byte"/>[]. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsBytesAsync(cancellationToken) : base.ReadAsBytesAsync(cancellationToken);
+        }
+
+        internal async Task<byte[]?> DoReadAsBytesAsync(CancellationToken cancellationToken)
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            bool isWrapped = false;
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (await ParsePostValueAsync(true, cancellationToken).ConfigureAwait(false))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (await ReadNullCharAsync(cancellationToken).ConfigureAwait(false))
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+
+                                break;
+                            case '"':
+                            case '\'':
+                                await ParseStringAsync(currentChar, ReadType.ReadAsBytes, cancellationToken).ConfigureAwait(false);
+                                byte[]? data = (byte[]?)Value;
+                                if (isWrapped)
+                                {
+                                    await ReaderReadAndAssertAsync(cancellationToken).ConfigureAwait(false);
+                                    if (TokenType != JsonToken.EndObject)
+                                    {
+                                        throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
+                                    }
+
+                                    SetToken(JsonToken.Bytes, data, false);
+                                }
+
+                                return data;
+                            case '{':
+                                _charPos++;
+                                SetToken(JsonToken.StartObject);
+                                await ReadIntoWrappedTypeObjectAsync(cancellationToken).ConfigureAwait(false);
+                                isWrapped = true;
+                                break;
+                            case '[':
+                                _charPos++;
+                                SetToken(JsonToken.StartArray);
+                                return await ReadArrayIntoByteArrayAsync(cancellationToken).ConfigureAwait(false);
+                            case 'n':
+                                await HandleNullAsync(cancellationToken).ConfigureAwait(false);
+                                return null;
+                            case '/':
+                                await ParseCommentAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    await ReadFinishedAsync(cancellationToken).ConfigureAwait(false);
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        private async Task ReadIntoWrappedTypeObjectAsync(CancellationToken cancellationToken)
+        {
+            await ReaderReadAndAssertAsync(cancellationToken).ConfigureAwait(false);
+            if (Value != null && Value.ToString() == JsonTypeReflector.TypePropertyName)
+            {
+                await ReaderReadAndAssertAsync(cancellationToken).ConfigureAwait(false);
+                if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal))
+                {
+                    await ReaderReadAndAssertAsync(cancellationToken).ConfigureAwait(false);
+                    if (Value.ToString() == JsonTypeReflector.ValuePropertyName)
+                    {
+                        return;
+                    }
+                }
+            }
+
+            throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="DateTime"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="DateTime"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsDateTimeAsync(cancellationToken) : base.ReadAsDateTimeAsync(cancellationToken);
+        }
+
+        internal async Task<DateTime?> DoReadAsDateTimeAsync(CancellationToken cancellationToken)
+        {
+            return (DateTime?)await ReadStringValueAsync(ReadType.ReadAsDateTime, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsDateTimeOffsetAsync(cancellationToken) : base.ReadAsDateTimeOffsetAsync(cancellationToken);
+        }
+
+        internal async Task<DateTimeOffset?> DoReadAsDateTimeOffsetAsync(CancellationToken cancellationToken)
+        {
+            return (DateTimeOffset?)await ReadStringValueAsync(ReadType.ReadAsDateTimeOffset, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="decimal"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsDecimalAsync(cancellationToken) : base.ReadAsDecimalAsync(cancellationToken);
+        }
+
+        internal async Task<decimal?> DoReadAsDecimalAsync(CancellationToken cancellationToken)
+        {
+            return (decimal?)await ReadNumberValueAsync(ReadType.ReadAsDecimal, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="double"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="double"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsDoubleAsync(cancellationToken) : base.ReadAsDoubleAsync(cancellationToken);
+        }
+
+        internal async Task<double?> DoReadAsDoubleAsync(CancellationToken cancellationToken)
+        {
+            return (double?)await ReadNumberValueAsync(ReadType.ReadAsDouble, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="Nullable{T}"/> of <see cref="int"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="Nullable{T}"/> of <see cref="int"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsInt32Async(cancellationToken) : base.ReadAsInt32Async(cancellationToken);
+        }
+
+        internal async Task<int?> DoReadAsInt32Async(CancellationToken cancellationToken)
+        {
+            return (int?)await ReadNumberValueAsync(ReadType.ReadAsInt32, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously reads the next JSON token from the source as a <see cref="string"/>.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous read. The <see cref="Task{TResult}.Result"/>
+        /// property returns the <see cref="string"/>. This result will be <c>null</c> at the end of an array.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoReadAsStringAsync(cancellationToken) : base.ReadAsStringAsync(cancellationToken);
+        }
+
+        internal async Task<string?> DoReadAsStringAsync(CancellationToken cancellationToken)
+        {
+            return (string?)await ReadStringValueAsync(ReadType.ReadAsString, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/JsonTextReader.cs b/Libs/Newtonsoft.Json/JsonTextReader.cs
new file mode 100644
index 0000000..9bfa85c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonTextReader.cs
@@ -0,0 +1,2655 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Runtime.CompilerServices;
+using System.IO;
+using System.Globalization;
+using System.Diagnostics;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json
+{
+    internal enum ReadType
+    {
+        Read,
+        ReadAsInt32,
+        ReadAsInt64,
+        ReadAsBytes,
+        ReadAsString,
+        ReadAsDecimal,
+        ReadAsDateTime,
+#if HAVE_DATE_TIME_OFFSET
+        ReadAsDateTimeOffset,
+#endif
+        ReadAsDouble,
+        ReadAsBoolean
+    }
+
+    /// <summary>
+    /// Represents a reader that provides fast, non-cached, forward-only access to JSON text data.
+    /// </summary>
+    public partial class JsonTextReader : JsonReader, IJsonLineInfo
+    {
+        private const char UnicodeReplacementChar = '\uFFFD';
+#if HAVE_BIG_INTEGER
+        private const int MaximumJavascriptIntegerCharacterLength = 380;
+#endif
+#if DEBUG
+        internal int LargeBufferLength { get; set; } = int.MaxValue / 2;
+#else
+        private const int LargeBufferLength = int.MaxValue / 2;
+#endif
+
+        private readonly TextReader _reader;
+        private char[]? _chars;
+        private int _charsUsed;
+        private int _charPos;
+        private int _lineStartPos;
+        private int _lineNumber;
+        private bool _isEndOfFile;
+        private StringBuffer _stringBuffer;
+        private StringReference _stringReference;
+        private IArrayPool<char>? _arrayPool;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonTextReader"/> class with the specified <see cref="TextReader"/>.
+        /// </summary>
+        /// <param name="reader">The <see cref="TextReader"/> containing the JSON data to read.</param>
+        public JsonTextReader(TextReader reader)
+        {
+            if (reader == null)
+            {
+                throw new ArgumentNullException(nameof(reader));
+            }
+
+            _reader = reader;
+            _lineNumber = 1;
+
+#if HAVE_ASYNC
+            _safeAsync = GetType() == typeof(JsonTextReader);
+#endif
+        }
+
+#if DEBUG
+        internal char[]? CharBuffer
+        {
+            get => _chars;
+            set => _chars = value;
+        }
+
+        internal int CharPos => _charPos;
+#endif
+
+        /// <summary>
+        /// Gets or sets the reader's property name table.
+        /// </summary>
+        public JsonNameTable? PropertyNameTable { get; set; }
+
+        /// <summary>
+        /// Gets or sets the reader's character buffer pool.
+        /// </summary>
+        public IArrayPool<char>? ArrayPool
+        {
+            get => _arrayPool;
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+
+                _arrayPool = value;
+            }
+        }
+
+        private void EnsureBufferNotEmpty()
+        {
+            if (_stringBuffer.IsEmpty)
+            {
+                _stringBuffer = new StringBuffer(_arrayPool, 1024);
+            }
+        }
+
+        private void SetNewLine(bool hasNextChar)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (hasNextChar && _chars[_charPos] == StringUtils.LineFeed)
+            {
+                _charPos++;
+            }
+
+            OnNewLine(_charPos);
+        }
+
+        private void OnNewLine(int pos)
+        {
+            _lineNumber++;
+            _lineStartPos = pos;
+        }
+
+        private void ParseString(char quote, ReadType readType)
+        {
+            _charPos++;
+
+            ShiftBufferIfNeeded();
+            ReadStringIntoBuffer(quote);
+            ParseReadString(quote, readType);
+        }
+
+        private void ParseReadString(char quote, ReadType readType)
+        { 
+            SetPostValueState(true);
+
+            switch (readType)
+            {
+                case ReadType.ReadAsBytes:
+                    Guid g;
+                    byte[] data;
+                    if (_stringReference.Length == 0)
+                    {
+                        data = CollectionUtils.ArrayEmpty<byte>();
+                    }
+                    else if (_stringReference.Length == 36 && ConvertUtils.TryConvertGuid(_stringReference.ToString(), out g))
+                    {
+                        data = g.ToByteArray();
+                    }
+                    else
+                    {
+                        data = Convert.FromBase64CharArray(_stringReference.Chars, _stringReference.StartIndex, _stringReference.Length);
+                    }
+
+                    SetToken(JsonToken.Bytes, data, false);
+                    break;
+                case ReadType.ReadAsString:
+                    string text = _stringReference.ToString();
+
+                    SetToken(JsonToken.String, text, false);
+                    _quoteChar = quote;
+                    break;
+                case ReadType.ReadAsInt32:
+                case ReadType.ReadAsDecimal:
+                case ReadType.ReadAsBoolean:
+                    // caller will convert result
+                    break;
+                default:
+                    if (_dateParseHandling != DateParseHandling.None)
+                    {
+                        DateParseHandling dateParseHandling;
+                        if (readType == ReadType.ReadAsDateTime)
+                        {
+                            dateParseHandling = DateParseHandling.DateTime;
+                        }
+#if HAVE_DATE_TIME_OFFSET
+                        else if (readType == ReadType.ReadAsDateTimeOffset)
+                        {
+                            dateParseHandling = DateParseHandling.DateTimeOffset;
+                        }
+#endif
+                        else
+                        {
+                            dateParseHandling = _dateParseHandling;
+                        }
+
+                        if (dateParseHandling == DateParseHandling.DateTime)
+                        {
+                            if (DateTimeUtils.TryParseDateTime(_stringReference, DateTimeZoneHandling, DateFormatString, Culture, out DateTime dt))
+                            {
+                                SetToken(JsonToken.Date, dt, false);
+                                return;
+                            }
+                        }
+#if HAVE_DATE_TIME_OFFSET
+                        else
+                        {
+                            if (DateTimeUtils.TryParseDateTimeOffset(_stringReference, DateFormatString, Culture, out DateTimeOffset dt))
+                            {
+                                SetToken(JsonToken.Date, dt, false);
+                                return;
+                            }
+                        }
+#endif
+                    }
+
+                    SetToken(JsonToken.String, _stringReference.ToString(), false);
+                    _quoteChar = quote;
+                    break;
+            }
+        }
+
+        private static void BlockCopyChars(char[] src, int srcOffset, char[] dst, int dstOffset, int count)
+        {
+            const int charByteCount = 2;
+
+            Buffer.BlockCopy(src, srcOffset * charByteCount, dst, dstOffset * charByteCount, count * charByteCount);
+        }
+
+        private void ShiftBufferIfNeeded()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            // once in the last 10% of the buffer, or buffer is already very large then
+            // shift the remaining content to the start to avoid unnecessarily increasing
+            // the buffer size when reading numbers/strings
+            int length = _chars.Length;
+            if (length - _charPos <= length * 0.1 || length >= LargeBufferLength)
+            {
+                int count = _charsUsed - _charPos;
+                if (count > 0)
+                {
+                    BlockCopyChars(_chars, _charPos, _chars, 0, count);
+                }
+
+                _lineStartPos -= _charPos;
+                _charPos = 0;
+                _charsUsed = count;
+                _chars[_charsUsed] = '\0';
+            }
+        }
+
+        private int ReadData(bool append)
+        {
+            return ReadData(append, 0);
+        }
+
+        private void PrepareBufferForReadData(bool append, int charsRequired)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            // char buffer is full
+            if (_charsUsed + charsRequired >= _chars.Length - 1)
+            {
+                if (append)
+                {
+                    int doubledArrayLength = _chars.Length * 2;
+
+                    // copy to new array either double the size of the current or big enough to fit required content
+                    int newArrayLength = Math.Max(
+                        doubledArrayLength < 0 ? int.MaxValue : doubledArrayLength, // handle overflow
+                        _charsUsed + charsRequired + 1);
+
+                    // increase the size of the buffer
+                    char[] dst = BufferUtils.RentBuffer(_arrayPool, newArrayLength);
+
+                    BlockCopyChars(_chars, 0, dst, 0, _chars.Length);
+
+                    BufferUtils.ReturnBuffer(_arrayPool, _chars);
+
+                    _chars = dst;
+                }
+                else
+                {
+                    int remainingCharCount = _charsUsed - _charPos;
+
+                    if (remainingCharCount + charsRequired + 1 >= _chars.Length)
+                    {
+                        // the remaining count plus the required is bigger than the current buffer size
+                        char[] dst = BufferUtils.RentBuffer(_arrayPool, remainingCharCount + charsRequired + 1);
+
+                        if (remainingCharCount > 0)
+                        {
+                            BlockCopyChars(_chars, _charPos, dst, 0, remainingCharCount);
+                        }
+
+                        BufferUtils.ReturnBuffer(_arrayPool, _chars);
+
+                        _chars = dst;
+                    }
+                    else
+                    {
+                        // copy any remaining data to the beginning of the buffer if needed and reset positions
+                        if (remainingCharCount > 0)
+                        {
+                            BlockCopyChars(_chars, _charPos, _chars, 0, remainingCharCount);
+                        }
+                    }
+
+                    _lineStartPos -= _charPos;
+                    _charPos = 0;
+                    _charsUsed = remainingCharCount;
+                }
+            }
+        }
+
+        private int ReadData(bool append, int charsRequired)
+        {
+            if (_isEndOfFile)
+            {
+                return 0;
+            }
+
+            PrepareBufferForReadData(append, charsRequired);
+            MiscellaneousUtils.Assert(_chars != null);
+
+            int attemptCharReadCount = _chars.Length - _charsUsed - 1;
+
+            int charsRead = _reader.Read(_chars, _charsUsed, attemptCharReadCount);
+
+            _charsUsed += charsRead;
+
+            if (charsRead == 0)
+            {
+                _isEndOfFile = true;
+            }
+
+            _chars[_charsUsed] = '\0';
+            return charsRead;
+        }
+
+        private bool EnsureChars(int relativePosition, bool append)
+        {
+            if (_charPos + relativePosition >= _charsUsed)
+            {
+                return ReadChars(relativePosition, append);
+            }
+
+            return true;
+        }
+
+        private bool ReadChars(int relativePosition, bool append)
+        {
+            if (_isEndOfFile)
+            {
+                return false;
+            }
+
+            int charsRequired = _charPos + relativePosition - _charsUsed + 1;
+
+            int totalCharsRead = 0;
+
+            // it is possible that the TextReader doesn't return all data at once
+            // repeat read until the required text is returned or the reader is out of content
+            do
+            {
+                int charsRead = ReadData(append, charsRequired - totalCharsRead);
+
+                // no more content
+                if (charsRead == 0)
+                {
+                    break;
+                }
+
+                totalCharsRead += charsRead;
+            } while (totalCharsRead < charsRequired);
+
+            if (totalCharsRead < charsRequired)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/>.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the next token was read successfully; <c>false</c> if there are no more tokens to read.
+        /// </returns>
+        public override bool Read()
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                switch (_currentState)
+                {
+                    case State.Start:
+                    case State.Property:
+                    case State.Array:
+                    case State.ArrayStart:
+                    case State.Constructor:
+                    case State.ConstructorStart:
+                        return ParseValue();
+                    case State.Object:
+                    case State.ObjectStart:
+                        return ParseObject();
+                    case State.PostValue:
+                        // returns true if it hits
+                        // end of object or array
+                        if (ParsePostValue(false))
+                        {
+                            return true;
+                        }
+                        break;
+                    case State.Finished:
+                        if (EnsureChars(0, false))
+                        {
+                            EatWhitespace();
+                            if (_isEndOfFile)
+                            {
+                                SetToken(JsonToken.None);
+                                return false;
+                            }
+                            if (_chars[_charPos] == '/')
+                            {
+                                ParseComment(true);
+                                return true;
+                            }
+
+                            throw JsonReaderException.Create(this, "Additional text encountered after finished reading JSON content: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+                        }
+                        SetToken(JsonToken.None);
+                        return false;
+                    default:
+                        throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="Nullable{T}"/> of <see cref="Int32"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Int32"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override int? ReadAsInt32()
+        {
+            return (int?)ReadNumberValue(ReadType.ReadAsInt32);
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="Nullable{T}"/> of <see cref="DateTime"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="DateTime"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override DateTime? ReadAsDateTime()
+        {
+            return (DateTime?)ReadStringValue(ReadType.ReadAsDateTime);
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="String"/>.
+        /// </summary>
+        /// <returns>A <see cref="String"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override string? ReadAsString()
+        {
+            return (string?)ReadStringValue(ReadType.ReadAsString);
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="Byte"/>[].
+        /// </summary>
+        /// <returns>A <see cref="Byte"/>[] or <c>null</c> if the next JSON token is null. This method will return <c>null</c> at the end of an array.</returns>
+        public override byte[]? ReadAsBytes()
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            bool isWrapped = false;
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (ParsePostValue(true))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (ReadNullChar())
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+                                break;
+                            case '"':
+                            case '\'':
+                                ParseString(currentChar, ReadType.ReadAsBytes);
+                                byte[]? data = (byte[]?)Value;
+                                if (isWrapped)
+                                {
+                                    ReaderReadAndAssert();
+                                    if (TokenType != JsonToken.EndObject)
+                                    {
+                                        throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
+                                    }
+                                    SetToken(JsonToken.Bytes, data, false);
+                                }
+                                return data;
+                            case '{':
+                                _charPos++;
+                                SetToken(JsonToken.StartObject);
+                                ReadIntoWrappedTypeObject();
+                                isWrapped = true;
+                                break;
+                            case '[':
+                                _charPos++;
+                                SetToken(JsonToken.StartArray);
+                                return ReadArrayIntoByteArray();
+                            case 'n':
+                                HandleNull();
+                                return null;
+                            case '/':
+                                ParseComment(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                ProcessCarriageReturn(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    ReadFinished();
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        private object? ReadStringValue(ReadType readType)
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (ParsePostValue(true))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (ReadNullChar())
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+                                break;
+                            case '"':
+                            case '\'':
+                                ParseString(currentChar, readType);
+                                return FinishReadQuotedStringValue(readType);
+                            case '-':
+                                if (EnsureChars(1, true) && _chars[_charPos + 1] == 'I')
+                                {
+                                    return ParseNumberNegativeInfinity(readType);
+                                }
+                                else
+                                {
+                                    ParseNumber(readType);
+                                    return Value;
+                                }
+                            case '.':
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                if (readType != ReadType.ReadAsString)
+                                {
+                                    _charPos++;
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+                                ParseNumber(ReadType.ReadAsString);
+                                return Value;
+                            case 't':
+                            case 'f':
+                                if (readType != ReadType.ReadAsString)
+                                {
+                                    _charPos++;
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+                                string expected = currentChar == 't' ? JsonConvert.True : JsonConvert.False;
+                                if (!MatchValueWithTrailingSeparator(expected))
+                                {
+                                    throw CreateUnexpectedCharacterException(_chars[_charPos]);
+                                }
+                                SetToken(JsonToken.String, expected);
+                                return expected;
+                            case 'I':
+                                return ParseNumberPositiveInfinity(readType);
+                            case 'N':
+                                return ParseNumberNaN(readType);
+                            case 'n':
+                                HandleNull();
+                                return null;
+                            case '/':
+                                ParseComment(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                ProcessCarriageReturn(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    ReadFinished();
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        private object? FinishReadQuotedStringValue(ReadType readType)
+        {
+            switch (readType)
+            {
+                case ReadType.ReadAsBytes:
+                case ReadType.ReadAsString:
+                    return Value;
+                case ReadType.ReadAsDateTime:
+                    if (Value is DateTime time)
+                    {
+                        return time;
+                    }
+
+                    return ReadDateTimeString((string?)Value);
+#if HAVE_DATE_TIME_OFFSET
+                case ReadType.ReadAsDateTimeOffset:
+                    if (Value is DateTimeOffset offset)
+                    {
+                        return offset;
+                    }
+
+                    return ReadDateTimeOffsetString((string?)Value);
+#endif
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(readType));
+            }
+        }
+
+        private JsonReaderException CreateUnexpectedCharacterException(char c)
+        {
+            return JsonReaderException.Create(this, "Unexpected character encountered while parsing value: {0}.".FormatWith(CultureInfo.InvariantCulture, c));
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="Nullable{T}"/> of <see cref="Boolean"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Boolean"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override bool? ReadAsBoolean()
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (ParsePostValue(true))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (ReadNullChar())
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+                                break;
+                            case '"':
+                            case '\'':
+                                ParseString(currentChar, ReadType.Read);
+                                return ReadBooleanString(_stringReference.ToString());
+                            case 'n':
+                                HandleNull();
+                                return null;
+                            case '-':
+                            case '.':
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                ParseNumber(ReadType.Read);
+                                bool b;
+#if HAVE_BIG_INTEGER
+                                if (Value is BigInteger integer)
+                                {
+                                    b = integer != 0;
+                                }
+                                else
+#endif
+                                {
+                                    b = Convert.ToBoolean(Value, CultureInfo.InvariantCulture);
+                                }
+                                SetToken(JsonToken.Boolean, b, false);
+                                return b;
+                            case 't':
+                            case 'f':
+                                bool isTrue = currentChar == 't';
+                                string expected = isTrue ? JsonConvert.True : JsonConvert.False;
+
+                                if (!MatchValueWithTrailingSeparator(expected))
+                                {
+                                    throw CreateUnexpectedCharacterException(_chars[_charPos]);
+                                }
+                                SetToken(JsonToken.Boolean, isTrue);
+                                return isTrue;
+                            case '/':
+                                ParseComment(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                ProcessCarriageReturn(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    ReadFinished();
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        private void ProcessValueComma()
+        {
+            _charPos++;
+
+            if (_currentState != State.PostValue)
+            {
+                SetToken(JsonToken.Undefined);
+                JsonReaderException ex = CreateUnexpectedCharacterException(',');
+                // so the comma will be parsed again
+                _charPos--;
+
+                throw ex;
+            }
+
+            SetStateBasedOnCurrent();
+        }
+
+        private object? ReadNumberValue(ReadType readType)
+        {
+            EnsureBuffer();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            switch (_currentState)
+            {
+                case State.PostValue:
+                    if (ParsePostValue(true))
+                    {
+                        return null;
+                    }
+                    goto case State.Start;
+                case State.Start:
+                case State.Property:
+                case State.Array:
+                case State.ArrayStart:
+                case State.Constructor:
+                case State.ConstructorStart:
+                    while (true)
+                    {
+                        char currentChar = _chars[_charPos];
+
+                        switch (currentChar)
+                        {
+                            case '\0':
+                                if (ReadNullChar())
+                                {
+                                    SetToken(JsonToken.None, null, false);
+                                    return null;
+                                }
+                                break;
+                            case '"':
+                            case '\'':
+                                ParseString(currentChar, readType);
+                                return FinishReadQuotedNumber(readType);
+                            case 'n':
+                                HandleNull();
+                                return null;
+                            case 'N':
+                                return ParseNumberNaN(readType);
+                            case 'I':
+                                return ParseNumberPositiveInfinity(readType);
+                            case '-':
+                                if (EnsureChars(1, true) && _chars[_charPos + 1] == 'I')
+                                {
+                                    return ParseNumberNegativeInfinity(readType);
+                                }
+                                else
+                                {
+                                    ParseNumber(readType);
+                                    return Value;
+                                }
+                            case '.':
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                ParseNumber(readType);
+                                return Value;
+                            case '/':
+                                ParseComment(false);
+                                break;
+                            case ',':
+                                ProcessValueComma();
+                                break;
+                            case ']':
+                                _charPos++;
+                                if (_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.PostValue)
+                                {
+                                    SetToken(JsonToken.EndArray);
+                                    return null;
+                                }
+                                throw CreateUnexpectedCharacterException(currentChar);
+                            case StringUtils.CarriageReturn:
+                                ProcessCarriageReturn(false);
+                                break;
+                            case StringUtils.LineFeed:
+                                ProcessLineFeed();
+                                break;
+                            case ' ':
+                            case StringUtils.Tab:
+                                // eat
+                                _charPos++;
+                                break;
+                            default:
+                                _charPos++;
+
+                                if (!char.IsWhiteSpace(currentChar))
+                                {
+                                    throw CreateUnexpectedCharacterException(currentChar);
+                                }
+
+                                // eat
+                                break;
+                        }
+                    }
+                case State.Finished:
+                    ReadFinished();
+                    return null;
+                default:
+                    throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
+            }
+        }
+
+        private object? FinishReadQuotedNumber(ReadType readType)
+        {
+            switch (readType)
+            {
+                case ReadType.ReadAsInt32:
+                    return ReadInt32String(_stringReference.ToString());
+                case ReadType.ReadAsDecimal:
+                    return ReadDecimalString(_stringReference.ToString());
+                case ReadType.ReadAsDouble:
+                    return ReadDoubleString(_stringReference.ToString());
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(readType));
+            }
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override DateTimeOffset? ReadAsDateTimeOffset()
+        {
+            return (DateTimeOffset?)ReadStringValue(ReadType.ReadAsDateTimeOffset);
+        }
+#endif
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="Nullable{T}"/> of <see cref="Decimal"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Decimal"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override decimal? ReadAsDecimal()
+        {
+            return (decimal?)ReadNumberValue(ReadType.ReadAsDecimal);
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="TextReader"/> as a <see cref="Nullable{T}"/> of <see cref="Double"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Double"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override double? ReadAsDouble()
+        {
+            return (double?)ReadNumberValue(ReadType.ReadAsDouble);
+        }
+
+        private void HandleNull()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (EnsureChars(1, true))
+            {
+                char next = _chars[_charPos + 1];
+
+                if (next == 'u')
+                {
+                    ParseNull();
+                    return;
+                }
+
+                _charPos += 2;
+                throw CreateUnexpectedCharacterException(_chars[_charPos - 1]);
+            }
+
+            _charPos = _charsUsed;
+            throw CreateUnexpectedEndException();
+        }
+
+        private void ReadFinished()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (EnsureChars(0, false))
+            {
+                EatWhitespace();
+                if (_isEndOfFile)
+                {
+                    return;
+                }
+                if (_chars[_charPos] == '/')
+                {
+                    ParseComment(false);
+                }
+                else
+                {
+                    throw JsonReaderException.Create(this, "Additional text encountered after finished reading JSON content: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+                }
+            }
+
+            SetToken(JsonToken.None);
+        }
+
+        private bool ReadNullChar()
+        {
+            if (_charsUsed == _charPos)
+            {
+                if (ReadData(false) == 0)
+                {
+                    _isEndOfFile = true;
+                    return true;
+                }
+            }
+            else
+            {
+                _charPos++;
+            }
+
+            return false;
+        }
+
+        private void EnsureBuffer()
+        {
+            if (_chars == null)
+            {
+                _chars = BufferUtils.RentBuffer(_arrayPool, 1024);
+                _chars[0] = '\0';
+            }
+        }
+
+        private void ReadStringIntoBuffer(char quote)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            int charPos = _charPos;
+            int initialPosition = _charPos;
+            int lastWritePosition = _charPos;
+            _stringBuffer.Position = 0;
+
+            while (true)
+            {
+                switch (_chars[charPos++])
+                {
+                    case '\0':
+                        if (_charsUsed == charPos - 1)
+                        {
+                            charPos--;
+
+                            if (ReadData(true) == 0)
+                            {
+                                _charPos = charPos;
+                                throw JsonReaderException.Create(this, "Unterminated string. Expected delimiter: {0}.".FormatWith(CultureInfo.InvariantCulture, quote));
+                            }
+                        }
+                        break;
+                    case '\\':
+                        _charPos = charPos;
+                        if (!EnsureChars(0, true))
+                        {
+                            throw JsonReaderException.Create(this, "Unterminated string. Expected delimiter: {0}.".FormatWith(CultureInfo.InvariantCulture, quote));
+                        }
+
+                        // start of escape sequence
+                        int escapeStartPos = charPos - 1;
+
+                        char currentChar = _chars[charPos];
+                        charPos++;
+
+                        char writeChar;
+
+                        switch (currentChar)
+                        {
+                            case 'b':
+                                writeChar = '\b';
+                                break;
+                            case 't':
+                                writeChar = '\t';
+                                break;
+                            case 'n':
+                                writeChar = '\n';
+                                break;
+                            case 'f':
+                                writeChar = '\f';
+                                break;
+                            case 'r':
+                                writeChar = '\r';
+                                break;
+                            case '\\':
+                                writeChar = '\\';
+                                break;
+                            case '"':
+                            case '\'':
+                            case '/':
+                                writeChar = currentChar;
+                                break;
+                            case 'u':
+                                _charPos = charPos;
+                                writeChar = ParseUnicode();
+
+                                if (StringUtils.IsLowSurrogate(writeChar))
+                                {
+                                    // low surrogate with no preceding high surrogate; this char is replaced
+                                    writeChar = UnicodeReplacementChar;
+                                }
+                                else if (StringUtils.IsHighSurrogate(writeChar))
+                                {
+                                    bool anotherHighSurrogate;
+
+                                    // loop for handling situations where there are multiple consecutive high surrogates
+                                    do
+                                    {
+                                        anotherHighSurrogate = false;
+
+                                        // potential start of a surrogate pair
+                                        if (EnsureChars(2, true) && _chars[_charPos] == '\\' && _chars[_charPos + 1] == 'u')
+                                        {
+                                            char highSurrogate = writeChar;
+
+                                            _charPos += 2;
+                                            writeChar = ParseUnicode();
+
+                                            if (StringUtils.IsLowSurrogate(writeChar))
+                                            {
+                                                // a valid surrogate pair!
+                                            }
+                                            else if (StringUtils.IsHighSurrogate(writeChar))
+                                            {
+                                                // another high surrogate; replace current and start check over
+                                                highSurrogate = UnicodeReplacementChar;
+                                                anotherHighSurrogate = true;
+                                            }
+                                            else
+                                            {
+                                                // high surrogate not followed by low surrogate; original char is replaced
+                                                highSurrogate = UnicodeReplacementChar;
+                                            }
+
+                                            EnsureBufferNotEmpty();
+
+                                            WriteCharToBuffer(highSurrogate, lastWritePosition, escapeStartPos);
+                                            lastWritePosition = _charPos;
+                                        }
+                                        else
+                                        {
+                                            // there are not enough remaining chars for the low surrogate or is not follow by unicode sequence
+                                            // replace high surrogate and continue on as usual
+                                            writeChar = UnicodeReplacementChar;
+                                        }
+                                    } while (anotherHighSurrogate);
+                                }
+
+                                charPos = _charPos;
+                                break;
+                            default:
+                                _charPos = charPos;
+                                throw JsonReaderException.Create(this, "Bad JSON escape sequence: {0}.".FormatWith(CultureInfo.InvariantCulture, @"\" + currentChar));
+                        }
+
+                        EnsureBufferNotEmpty();
+                        WriteCharToBuffer(writeChar, lastWritePosition, escapeStartPos);
+
+                        lastWritePosition = charPos;
+                        break;
+                    case StringUtils.CarriageReturn:
+                        _charPos = charPos - 1;
+                        ProcessCarriageReturn(true);
+                        charPos = _charPos;
+                        break;
+                    case StringUtils.LineFeed:
+                        _charPos = charPos - 1;
+                        ProcessLineFeed();
+                        charPos = _charPos;
+                        break;
+                    case '"':
+                    case '\'':
+                        if (_chars[charPos - 1] == quote)
+                        {
+                            FinishReadStringIntoBuffer(charPos - 1, initialPosition, lastWritePosition);
+                            return;
+                        }
+                        break;
+                }
+            }
+        }
+
+        private void FinishReadStringIntoBuffer(int charPos, int initialPosition, int lastWritePosition)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (initialPosition == lastWritePosition)
+            {
+                _stringReference = new StringReference(_chars, initialPosition, charPos - initialPosition);
+            }
+            else
+            {
+                EnsureBufferNotEmpty();
+
+                if (charPos > lastWritePosition)
+                {
+                    _stringBuffer.Append(_arrayPool, _chars, lastWritePosition, charPos - lastWritePosition);
+                }
+
+                _stringReference = new StringReference(_stringBuffer.InternalBuffer!, 0, _stringBuffer.Position);
+            }
+
+            _charPos = charPos + 1;
+        }
+
+        private void WriteCharToBuffer(char writeChar, int lastWritePosition, int writeToPosition)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (writeToPosition > lastWritePosition)
+            {
+                _stringBuffer.Append(_arrayPool, _chars, lastWritePosition, writeToPosition - lastWritePosition);
+            }
+
+            _stringBuffer.Append(_arrayPool, writeChar);
+        }
+
+        private char ConvertUnicode(bool enoughChars)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (enoughChars)
+            {
+                if (ConvertUtils.TryHexTextToInt(_chars, _charPos, _charPos + 4, out int value))
+                {
+                    char hexChar = Convert.ToChar(value);
+                    _charPos += 4;
+                    return hexChar;
+                }
+                else
+                {
+                    throw JsonReaderException.Create(this, @"Invalid Unicode escape sequence: \u{0}.".FormatWith(CultureInfo.InvariantCulture, new string(_chars, _charPos, 4)));
+                }
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Unexpected end while parsing Unicode escape sequence.");
+            }
+        }
+
+        private char ParseUnicode()
+        {
+            return ConvertUnicode(EnsureChars(4, true));
+        }
+
+        private void ReadNumberIntoBuffer()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            int charPos = _charPos;
+
+            while (true)
+            {
+                char currentChar = _chars[charPos];
+                if (currentChar == '\0')
+                {
+                    _charPos = charPos;
+
+                    if (_charsUsed == charPos)
+                    {
+                        if (ReadData(true) == 0)
+                        {
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        return;
+                    }
+                }
+                else if (ReadNumberCharIntoBuffer(currentChar, charPos))
+                {
+                    return;
+                }
+                else
+                {
+                    charPos++;
+                }
+            }
+        }
+
+        private bool ReadNumberCharIntoBuffer(char currentChar, int charPos)
+        {
+            switch (currentChar)
+            {
+                case '-':
+                case '+':
+                case 'a':
+                case 'A':
+                case 'b':
+                case 'B':
+                case 'c':
+                case 'C':
+                case 'd':
+                case 'D':
+                case 'e':
+                case 'E':
+                case 'f':
+                case 'F':
+                case 'x':
+                case 'X':
+                case '.':
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    return false;
+                default:
+                    _charPos = charPos;
+
+                    if (char.IsWhiteSpace(currentChar) || currentChar == ',' || currentChar == '}' || currentChar == ']' || currentChar == ')' || currentChar == '/')
+                    {
+                        return true;
+                    }
+
+                    throw JsonReaderException.Create(this, "Unexpected character encountered while parsing number: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
+            }
+        }
+
+        private void ClearRecentString()
+        {
+            _stringBuffer.Position = 0;
+            _stringReference = new StringReference();
+        }
+
+        private bool ParsePostValue(bool ignoreComments)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (ReadData(false) == 0)
+                            {
+                                _currentState = State.Finished;
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+                        break;
+                    case '}':
+                        _charPos++;
+                        SetToken(JsonToken.EndObject);
+                        return true;
+                    case ']':
+                        _charPos++;
+                        SetToken(JsonToken.EndArray);
+                        return true;
+                    case ')':
+                        _charPos++;
+                        SetToken(JsonToken.EndConstructor);
+                        return true;
+                    case '/':
+                        ParseComment(!ignoreComments);
+                        if (!ignoreComments)
+                        {
+                            return true;
+                        }
+                        break;
+                    case ',':
+                        _charPos++;
+
+                        // finished parsing
+                        SetStateBasedOnCurrent();
+                        return false;
+                    case ' ':
+                    case StringUtils.Tab:
+                        // eat
+                        _charPos++;
+                        break;
+                    case StringUtils.CarriageReturn:
+                        ProcessCarriageReturn(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    default:
+                        if (char.IsWhiteSpace(currentChar))
+                        {
+                            // eat
+                            _charPos++;
+                        }
+                        else
+                        {
+                            // handle multiple content without comma delimiter
+                            if (SupportMultipleContent && Depth == 0)
+                            {
+                                SetStateBasedOnCurrent();
+                                return false;
+                            }
+
+                            throw JsonReaderException.Create(this, "After parsing a value an unexpected character was encountered: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
+                        }
+                        break;
+                }
+            }
+        }
+
+        private bool ParseObject()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (ReadData(false) == 0)
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+                        break;
+                    case '}':
+                        SetToken(JsonToken.EndObject);
+                        _charPos++;
+                        return true;
+                    case '/':
+                        ParseComment(true);
+                        return true;
+                    case StringUtils.CarriageReturn:
+                        ProcessCarriageReturn(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    case ' ':
+                    case StringUtils.Tab:
+                        // eat
+                        _charPos++;
+                        break;
+                    default:
+                        if (char.IsWhiteSpace(currentChar))
+                        {
+                            // eat
+                            _charPos++;
+                        }
+                        else
+                        {
+                            return ParseProperty();
+                        }
+                        break;
+                }
+            }
+        }
+
+        private bool ParseProperty()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            char firstChar = _chars[_charPos];
+            char quoteChar;
+
+            if (firstChar == '"' || firstChar == '\'')
+            {
+                _charPos++;
+                quoteChar = firstChar;
+                ShiftBufferIfNeeded();
+                ReadStringIntoBuffer(quoteChar);
+            }
+            else if (ValidIdentifierChar(firstChar))
+            {
+                quoteChar = '\0';
+                ShiftBufferIfNeeded();
+                ParseUnquotedProperty();
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Invalid property identifier character: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+            }
+
+            string? propertyName;
+
+            if (PropertyNameTable != null)
+            {
+                propertyName = PropertyNameTable.Get(_stringReference.Chars, _stringReference.StartIndex, _stringReference.Length);
+
+                // no match in name table
+                if (propertyName == null)
+                {
+                    propertyName = _stringReference.ToString();
+                }
+            }
+            else
+            {
+                propertyName = _stringReference.ToString();
+            }
+
+            EatWhitespace();
+
+            if (_chars[_charPos] != ':')
+            {
+                throw JsonReaderException.Create(this, "Invalid character after parsing property name. Expected ':' but got: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+            }
+
+            _charPos++;
+
+            SetToken(JsonToken.PropertyName, propertyName);
+            _quoteChar = quoteChar;
+            ClearRecentString();
+
+            return true;
+        }
+
+        private bool ValidIdentifierChar(char value)
+        {
+            return (char.IsLetterOrDigit(value) || value == '_' || value == '$');
+        }
+
+        private void ParseUnquotedProperty()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            int initialPosition = _charPos;
+
+            // parse unquoted property name until whitespace or colon
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+                if (currentChar == '\0')
+                {
+                    if (_charsUsed == _charPos)
+                    {
+                        if (ReadData(true) == 0)
+                        {
+                            throw JsonReaderException.Create(this, "Unexpected end while parsing unquoted property name.");
+                        }
+
+                        continue;
+                    }
+
+                    _stringReference = new StringReference(_chars, initialPosition, _charPos - initialPosition);
+                    return;
+                }
+
+                if (ReadUnquotedPropertyReportIfDone(currentChar, initialPosition))
+                {
+                    return;
+                }
+            }
+        }
+
+        private bool ReadUnquotedPropertyReportIfDone(char currentChar, int initialPosition)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (ValidIdentifierChar(currentChar))
+            {
+                _charPos++;
+                return false;
+            }
+
+            if (char.IsWhiteSpace(currentChar) || currentChar == ':')
+            {
+                _stringReference = new StringReference(_chars, initialPosition, _charPos - initialPosition);
+                return true;
+            }
+
+            throw JsonReaderException.Create(this, "Invalid JavaScript property identifier character: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
+        }
+
+        private bool ParseValue()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (ReadData(false) == 0)
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+                        break;
+                    case '"':
+                    case '\'':
+                        ParseString(currentChar, ReadType.Read);
+                        return true;
+                    case 't':
+                        ParseTrue();
+                        return true;
+                    case 'f':
+                        ParseFalse();
+                        return true;
+                    case 'n':
+                        if (EnsureChars(1, true))
+                        {
+                            char next = _chars[_charPos + 1];
+
+                            if (next == 'u')
+                            {
+                                ParseNull();
+                            }
+                            else if (next == 'e')
+                            {
+                                ParseConstructor();
+                            }
+                            else
+                            {
+                                throw CreateUnexpectedCharacterException(_chars[_charPos]);
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                            throw CreateUnexpectedEndException();
+                        }
+                        return true;
+                    case 'N':
+                        ParseNumberNaN(ReadType.Read);
+                        return true;
+                    case 'I':
+                        ParseNumberPositiveInfinity(ReadType.Read);
+                        return true;
+                    case '-':
+                        if (EnsureChars(1, true) && _chars[_charPos + 1] == 'I')
+                        {
+                            ParseNumberNegativeInfinity(ReadType.Read);
+                        }
+                        else
+                        {
+                            ParseNumber(ReadType.Read);
+                        }
+                        return true;
+                    case '/':
+                        ParseComment(true);
+                        return true;
+                    case 'u':
+                        ParseUndefined();
+                        return true;
+                    case '{':
+                        _charPos++;
+                        SetToken(JsonToken.StartObject);
+                        return true;
+                    case '[':
+                        _charPos++;
+                        SetToken(JsonToken.StartArray);
+                        return true;
+                    case ']':
+                        _charPos++;
+                        SetToken(JsonToken.EndArray);
+                        return true;
+                    case ',':
+                        // don't increment position, the next call to read will handle comma
+                        // this is done to handle multiple empty comma values
+                        SetToken(JsonToken.Undefined);
+                        return true;
+                    case ')':
+                        _charPos++;
+                        SetToken(JsonToken.EndConstructor);
+                        return true;
+                    case StringUtils.CarriageReturn:
+                        ProcessCarriageReturn(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    case ' ':
+                    case StringUtils.Tab:
+                        // eat
+                        _charPos++;
+                        break;
+                    default:
+                        if (char.IsWhiteSpace(currentChar))
+                        {
+                            // eat
+                            _charPos++;
+                            break;
+                        }
+                        if (char.IsNumber(currentChar) || currentChar == '-' || currentChar == '.')
+                        {
+                            ParseNumber(ReadType.Read);
+                            return true;
+                        }
+
+                        throw CreateUnexpectedCharacterException(currentChar);
+                }
+            }
+        }
+
+        private void ProcessLineFeed()
+        {
+            _charPos++;
+            OnNewLine(_charPos);
+        }
+
+        private void ProcessCarriageReturn(bool append)
+        {
+            _charPos++;
+
+            SetNewLine(EnsureChars(1, append));
+        }
+
+        private void EatWhitespace()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            while (true)
+            {
+                char currentChar = _chars[_charPos];
+
+                switch (currentChar)
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (ReadData(false) == 0)
+                            {
+                                return;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+                        break;
+                    case StringUtils.CarriageReturn:
+                        ProcessCarriageReturn(false);
+                        break;
+                    case StringUtils.LineFeed:
+                        ProcessLineFeed();
+                        break;
+                    default:
+                        if (currentChar == ' ' || char.IsWhiteSpace(currentChar))
+                        {
+                            _charPos++;
+                        }
+                        else
+                        {
+                            return;
+                        }
+                        break;
+                }
+            }
+        }
+
+        private void ParseConstructor()
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (MatchValueWithTrailingSeparator("new"))
+            {
+                EatWhitespace();
+
+                int initialPosition = _charPos;
+                int endPosition;
+
+                while (true)
+                {
+                    char currentChar = _chars[_charPos];
+                    if (currentChar == '\0')
+                    {
+                        if (_charsUsed == _charPos)
+                        {
+                            if (ReadData(true) == 0)
+                            {
+                                throw JsonReaderException.Create(this, "Unexpected end while parsing constructor.");
+                            }
+                        }
+                        else
+                        {
+                            endPosition = _charPos;
+                            _charPos++;
+                            break;
+                        }
+                    }
+                    else if (char.IsLetterOrDigit(currentChar))
+                    {
+                        _charPos++;
+                    }
+                    else if (currentChar == StringUtils.CarriageReturn)
+                    {
+                        endPosition = _charPos;
+                        ProcessCarriageReturn(true);
+                        break;
+                    }
+                    else if (currentChar == StringUtils.LineFeed)
+                    {
+                        endPosition = _charPos;
+                        ProcessLineFeed();
+                        break;
+                    }
+                    else if (char.IsWhiteSpace(currentChar))
+                    {
+                        endPosition = _charPos;
+                        _charPos++;
+                        break;
+                    }
+                    else if (currentChar == '(')
+                    {
+                        endPosition = _charPos;
+                        break;
+                    }
+                    else
+                    {
+                        throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
+                    }
+                }
+
+                _stringReference = new StringReference(_chars, initialPosition, endPosition - initialPosition);
+                string constructorName = _stringReference.ToString();
+
+                EatWhitespace();
+
+                if (_chars[_charPos] != '(')
+                {
+                    throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+                }
+
+                _charPos++;
+
+                ClearRecentString();
+
+                SetToken(JsonToken.StartConstructor, constructorName);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Unexpected content while parsing JSON.");
+            }
+        }
+
+        private void ParseNumber(ReadType readType)
+        {
+            ShiftBufferIfNeeded();
+            MiscellaneousUtils.Assert(_chars != null);
+
+            char firstChar = _chars[_charPos];
+            int initialPosition = _charPos;
+
+            ReadNumberIntoBuffer();
+
+            ParseReadNumber(readType, firstChar, initialPosition);
+        }
+
+        private void ParseReadNumber(ReadType readType, char firstChar, int initialPosition)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            // set state to PostValue now so that if there is an error parsing the number then the reader can continue
+            SetPostValueState(true);
+
+            _stringReference = new StringReference(_chars, initialPosition, _charPos - initialPosition);
+
+            object numberValue;
+            JsonToken numberType;
+
+            bool singleDigit = (char.IsDigit(firstChar) && _stringReference.Length == 1);
+            bool nonBase10 = (firstChar == '0' && _stringReference.Length > 1 && _stringReference.Chars[_stringReference.StartIndex + 1] != '.' && _stringReference.Chars[_stringReference.StartIndex + 1] != 'e' && _stringReference.Chars[_stringReference.StartIndex + 1] != 'E');
+
+            switch (readType)
+            {
+                case ReadType.ReadAsString:
+                    {
+                        string number = _stringReference.ToString();
+
+                        // validate that the string is a valid number
+                        if (nonBase10)
+                        {
+                            try
+                            {
+                                if (number.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
+                                {
+                                    Convert.ToInt64(number, 16);
+                                }
+                                else
+                                {
+                                    Convert.ToInt64(number, 8);
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid number.".FormatWith(CultureInfo.InvariantCulture, number), ex);
+                            }
+                        }
+                        else
+                        {
+                            if (!double.TryParse(number, NumberStyles.Float, CultureInfo.InvariantCulture, out _))
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid number.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                            }
+                        }
+
+                        numberType = JsonToken.String;
+                        numberValue = number;
+                    }
+                    break;
+                case ReadType.ReadAsInt32:
+                    {
+                        if (singleDigit)
+                        {
+                            // digit char values start at 48
+                            numberValue = firstChar - 48;
+                        }
+                        else if (nonBase10)
+                        {
+                            string number = _stringReference.ToString();
+
+                            try
+                            {
+                                int integer = number.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? Convert.ToInt32(number, 16) : Convert.ToInt32(number, 8);
+
+                                numberValue = integer;
+                            }
+                            catch (Exception ex)
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid integer.".FormatWith(CultureInfo.InvariantCulture, number), ex);
+                            }
+                        }
+                        else
+                        {
+                            ParseResult parseResult = ConvertUtils.Int32TryParse(_stringReference.Chars, _stringReference.StartIndex, _stringReference.Length, out int value);
+                            if (parseResult == ParseResult.Success)
+                            {
+                                numberValue = value;
+                            }
+                            else if (parseResult == ParseResult.Overflow)
+                            {
+                                throw ThrowReaderError("JSON integer {0} is too large or small for an Int32.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                            }
+                            else
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid integer.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                            }
+                        }
+
+                        numberType = JsonToken.Integer;
+                    }
+                    break;
+                case ReadType.ReadAsDecimal:
+                    {
+                        if (singleDigit)
+                        {
+                            // digit char values start at 48
+                            numberValue = (decimal)firstChar - 48;
+                        }
+                        else if (nonBase10)
+                        {
+                            string number = _stringReference.ToString();
+
+                            try
+                            {
+                                // decimal.Parse doesn't support parsing hexadecimal values
+                                long integer = number.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? Convert.ToInt64(number, 16) : Convert.ToInt64(number, 8);
+
+                                numberValue = Convert.ToDecimal(integer);
+                            }
+                            catch (Exception ex)
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid decimal.".FormatWith(CultureInfo.InvariantCulture, number), ex);
+                            }
+                        }
+                        else
+                        {
+                            ParseResult parseResult = ConvertUtils.DecimalTryParse(_stringReference.Chars, _stringReference.StartIndex, _stringReference.Length, out decimal value);
+                            if (parseResult == ParseResult.Success)
+                            {
+                                numberValue = value;
+                            }
+                            else
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid decimal.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                            }
+                        }
+
+                        numberType = JsonToken.Float;
+                    }
+                    break;
+                case ReadType.ReadAsDouble:
+                    {
+                        if (singleDigit)
+                        {
+                            // digit char values start at 48
+                            numberValue = (double)firstChar - 48;
+                        }
+                        else if (nonBase10)
+                        {
+                            string number = _stringReference.ToString();
+
+                            try
+                            {
+                                // double.Parse doesn't support parsing hexadecimal values
+                                long integer = number.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? Convert.ToInt64(number, 16) : Convert.ToInt64(number, 8);
+
+                                numberValue = Convert.ToDouble(integer);
+                            }
+                            catch (Exception ex)
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid double.".FormatWith(CultureInfo.InvariantCulture, number), ex);
+                            }
+                        }
+                        else
+                        {
+                            string number = _stringReference.ToString();
+
+                            if (double.TryParse(number, NumberStyles.Float, CultureInfo.InvariantCulture, out double value))
+                            {
+                                numberValue = value;
+                            }
+                            else
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid double.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                            }
+                        }
+
+                        numberType = JsonToken.Float;
+                    }
+                    break;
+                case ReadType.Read:
+                case ReadType.ReadAsInt64:
+                    {
+                        if (singleDigit)
+                        {
+                            // digit char values start at 48
+                            numberValue = (long)firstChar - 48;
+                            numberType = JsonToken.Integer;
+                        }
+                        else if (nonBase10)
+                        {
+                            string number = _stringReference.ToString();
+
+                            try
+                            {
+                                numberValue = number.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? Convert.ToInt64(number, 16) : Convert.ToInt64(number, 8);
+                            }
+                            catch (Exception ex)
+                            {
+                                throw ThrowReaderError("Input string '{0}' is not a valid number.".FormatWith(CultureInfo.InvariantCulture, number), ex);
+                            }
+
+                            numberType = JsonToken.Integer;
+                        }
+                        else
+                        {
+                            ParseResult parseResult = ConvertUtils.Int64TryParse(_stringReference.Chars, _stringReference.StartIndex, _stringReference.Length, out long value);
+                            if (parseResult == ParseResult.Success)
+                            {
+                                numberValue = value;
+                                numberType = JsonToken.Integer;
+                            }
+                            else if (parseResult == ParseResult.Overflow)
+                            {
+#if HAVE_BIG_INTEGER
+                                string number = _stringReference.ToString();
+
+                                if (number.Length > MaximumJavascriptIntegerCharacterLength)
+                                {
+                                    throw ThrowReaderError("JSON integer {0} is too large to parse.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                                }
+
+                                numberValue = BigIntegerParse(number, CultureInfo.InvariantCulture);
+                                numberType = JsonToken.Integer;
+#else
+                                throw ThrowReaderError("JSON integer {0} is too large or small for an Int64.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+#endif
+                            }
+                            else
+                            {
+                                if (_floatParseHandling == FloatParseHandling.Decimal)
+                                {
+                                    parseResult = ConvertUtils.DecimalTryParse(_stringReference.Chars, _stringReference.StartIndex, _stringReference.Length, out decimal d);
+                                    if (parseResult == ParseResult.Success)
+                                    {
+                                        numberValue = d;
+                                    }
+                                    else
+                                    {
+                                        throw ThrowReaderError("Input string '{0}' is not a valid decimal.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                                    }
+                                }
+                                else
+                                {
+                                    string number = _stringReference.ToString();
+
+                                    if (double.TryParse(number, NumberStyles.Float, CultureInfo.InvariantCulture, out double d))
+                                    {
+                                        numberValue = d;
+                                    }
+                                    else
+                                    {
+                                        throw ThrowReaderError("Input string '{0}' is not a valid number.".FormatWith(CultureInfo.InvariantCulture, _stringReference.ToString()));
+                                    }
+                                }
+
+                                numberType = JsonToken.Float;
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    throw JsonReaderException.Create(this, "Cannot read number value as type.");
+            }
+
+            ClearRecentString();
+
+            // index has already been updated
+            SetToken(numberType, numberValue, false);
+        }
+
+        private JsonReaderException ThrowReaderError(string message, Exception? ex = null)
+        {
+            SetToken(JsonToken.Undefined, null, false);
+            return JsonReaderException.Create(this, message, ex);
+        }
+
+#if HAVE_BIG_INTEGER
+        // By using the BigInteger type in a separate method,
+        // the runtime can execute the ParseNumber even if 
+        // the System.Numerics.BigInteger.Parse method is
+        // missing, which happens in some versions of Mono
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static object BigIntegerParse(string number, CultureInfo culture)
+        {
+            return System.Numerics.BigInteger.Parse(number, culture);
+        }
+#endif
+
+        private void ParseComment(bool setToken)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            // should have already parsed / character before reaching this method
+            _charPos++;
+
+            if (!EnsureChars(1, false))
+            {
+                throw JsonReaderException.Create(this, "Unexpected end while parsing comment.");
+            }
+
+            bool singlelineComment;
+
+            if (_chars[_charPos] == '*')
+            {
+                singlelineComment = false;
+            }
+            else if (_chars[_charPos] == '/')
+            {
+                singlelineComment = true;
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Error parsing comment. Expected: *, got {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
+            }
+
+            _charPos++;
+
+            int initialPosition = _charPos;
+
+            while (true)
+            {
+                switch (_chars[_charPos])
+                {
+                    case '\0':
+                        if (_charsUsed == _charPos)
+                        {
+                            if (ReadData(true) == 0)
+                            {
+                                if (!singlelineComment)
+                                {
+                                    throw JsonReaderException.Create(this, "Unexpected end while parsing comment.");
+                                }
+
+                                EndComment(setToken, initialPosition, _charPos);
+                                return;
+                            }
+                        }
+                        else
+                        {
+                            _charPos++;
+                        }
+                        break;
+                    case '*':
+                        _charPos++;
+
+                        if (!singlelineComment)
+                        {
+                            if (EnsureChars(0, true))
+                            {
+                                if (_chars[_charPos] == '/')
+                                {
+                                    EndComment(setToken, initialPosition, _charPos - 1);
+
+                                    _charPos++;
+                                    return;
+                                }
+                            }
+                        }
+                        break;
+                    case StringUtils.CarriageReturn:
+                        if (singlelineComment)
+                        {
+                            EndComment(setToken, initialPosition, _charPos);
+                            return;
+                        }
+                        ProcessCarriageReturn(true);
+                        break;
+                    case StringUtils.LineFeed:
+                        if (singlelineComment)
+                        {
+                            EndComment(setToken, initialPosition, _charPos);
+                            return;
+                        }
+                        ProcessLineFeed();
+                        break;
+                    default:
+                        _charPos++;
+                        break;
+                }
+            }
+        }
+
+        private void EndComment(bool setToken, int initialPosition, int endPosition)
+        {
+            if (setToken)
+            {
+                SetToken(JsonToken.Comment, new string(_chars, initialPosition, endPosition - initialPosition));
+            }
+        }
+
+        private bool MatchValue(string value)
+        {
+            return MatchValue(EnsureChars(value.Length - 1, true), value);
+        }
+
+        private bool MatchValue(bool enoughChars, string value)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            if (!enoughChars)
+            {
+                _charPos = _charsUsed;
+                throw CreateUnexpectedEndException();
+            }
+
+            for (int i = 0; i < value.Length; i++)
+            {
+                if (_chars[_charPos + i] != value[i])
+                {
+                    _charPos += i;
+                    return false;
+                }
+            }
+
+            _charPos += value.Length;
+
+            return true;
+        }
+
+        private bool MatchValueWithTrailingSeparator(string value)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            // will match value and then move to the next character, checking that it is a separator character
+            bool match = MatchValue(value);
+
+            if (!match)
+            {
+                return false;
+            }
+
+            if (!EnsureChars(0, false))
+            {
+                return true;
+            }
+
+            return IsSeparator(_chars[_charPos]) || _chars[_charPos] == '\0';
+        }
+
+        private bool IsSeparator(char c)
+        {
+            MiscellaneousUtils.Assert(_chars != null);
+
+            switch (c)
+            {
+                case '}':
+                case ']':
+                case ',':
+                    return true;
+                case '/':
+                    // check next character to see if start of a comment
+                    if (!EnsureChars(1, false))
+                    {
+                        return false;
+                    }
+
+                    char nextChart = _chars[_charPos + 1];
+
+                    return (nextChart == '*' || nextChart == '/');
+                case ')':
+                    if (CurrentState == State.Constructor || CurrentState == State.ConstructorStart)
+                    {
+                        return true;
+                    }
+                    break;
+                case ' ':
+                case StringUtils.Tab:
+                case StringUtils.LineFeed:
+                case StringUtils.CarriageReturn:
+                    return true;
+                default:
+                    if (char.IsWhiteSpace(c))
+                    {
+                        return true;
+                    }
+                    break;
+            }
+
+            return false;
+        }
+
+        private void ParseTrue()
+        {
+            // check characters equal 'true'
+            // and that it is followed by either a separator character
+            // or the text ends
+            if (MatchValueWithTrailingSeparator(JsonConvert.True))
+            {
+                SetToken(JsonToken.Boolean, true);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Error parsing boolean value.");
+            }
+        }
+
+        private void ParseNull()
+        {
+            if (MatchValueWithTrailingSeparator(JsonConvert.Null))
+            {
+                SetToken(JsonToken.Null);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Error parsing null value.");
+            }
+        }
+
+        private void ParseUndefined()
+        {
+            if (MatchValueWithTrailingSeparator(JsonConvert.Undefined))
+            {
+                SetToken(JsonToken.Undefined);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Error parsing undefined value.");
+            }
+        }
+
+        private void ParseFalse()
+        {
+            if (MatchValueWithTrailingSeparator(JsonConvert.False))
+            {
+                SetToken(JsonToken.Boolean, false);
+            }
+            else
+            {
+                throw JsonReaderException.Create(this, "Error parsing boolean value.");
+            }
+        }
+
+        private object ParseNumberNegativeInfinity(ReadType readType)
+        {
+            return ParseNumberNegativeInfinity(readType, MatchValueWithTrailingSeparator(JsonConvert.NegativeInfinity));
+        }
+
+        private object ParseNumberNegativeInfinity(ReadType readType, bool matched)
+        {
+            if (matched)
+            {
+                switch (readType)
+                {
+                    case ReadType.Read:
+                    case ReadType.ReadAsDouble:
+                        if (_floatParseHandling == FloatParseHandling.Double)
+                        {
+                            SetToken(JsonToken.Float, double.NegativeInfinity);
+                            return double.NegativeInfinity;
+                        }
+                        break;
+                    case ReadType.ReadAsString:
+                        SetToken(JsonToken.String, JsonConvert.NegativeInfinity);
+                        return JsonConvert.NegativeInfinity;
+                }
+
+                throw JsonReaderException.Create(this, "Cannot read -Infinity value.");
+            }
+
+            throw JsonReaderException.Create(this, "Error parsing -Infinity value.");
+        }
+
+        private object ParseNumberPositiveInfinity(ReadType readType)
+        {
+            return ParseNumberPositiveInfinity(readType, MatchValueWithTrailingSeparator(JsonConvert.PositiveInfinity));
+        }
+        private object ParseNumberPositiveInfinity(ReadType readType, bool matched)
+        {
+            if (matched)
+            {
+                switch (readType)
+                {
+                    case ReadType.Read:
+                    case ReadType.ReadAsDouble:
+                        if (_floatParseHandling == FloatParseHandling.Double)
+                        {
+                            SetToken(JsonToken.Float, double.PositiveInfinity);
+                            return double.PositiveInfinity;
+                        }
+                        break;
+                    case ReadType.ReadAsString:
+                        SetToken(JsonToken.String, JsonConvert.PositiveInfinity);
+                        return JsonConvert.PositiveInfinity;
+                }
+
+                throw JsonReaderException.Create(this, "Cannot read Infinity value.");
+            }
+
+            throw JsonReaderException.Create(this, "Error parsing Infinity value.");
+        }
+
+        private object ParseNumberNaN(ReadType readType)
+        {
+            return ParseNumberNaN(readType, MatchValueWithTrailingSeparator(JsonConvert.NaN));
+        }
+
+        private object ParseNumberNaN(ReadType readType, bool matched)
+        {
+            if (matched)
+            {
+                switch (readType)
+                {
+                    case ReadType.Read:
+                    case ReadType.ReadAsDouble:
+                        if (_floatParseHandling == FloatParseHandling.Double)
+                        {
+                            SetToken(JsonToken.Float, double.NaN);
+                            return double.NaN;
+                        }
+                        break;
+                    case ReadType.ReadAsString:
+                        SetToken(JsonToken.String, JsonConvert.NaN);
+                        return JsonConvert.NaN;
+                }
+
+                throw JsonReaderException.Create(this, "Cannot read NaN value.");
+            }
+
+            throw JsonReaderException.Create(this, "Error parsing NaN value.");
+        }
+
+        /// <summary>
+        /// Changes the reader's state to <see cref="JsonReader.State.Closed"/>.
+        /// If <see cref="JsonReader.CloseInput"/> is set to <c>true</c>, the underlying <see cref="TextReader"/> is also closed.
+        /// </summary>
+        public override void Close()
+        {
+            base.Close();
+
+            if (_chars != null)
+            {
+                BufferUtils.ReturnBuffer(_arrayPool, _chars);
+                _chars = null;
+            }
+
+            if (CloseInput)
+            {
+#if HAVE_STREAM_READER_WRITER_CLOSE
+                _reader?.Close();
+#else
+                _reader?.Dispose();
+#endif
+            }
+
+            _stringBuffer.Clear(_arrayPool);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the class can return line information.
+        /// </summary>
+        /// <returns>
+        /// 	<c>true</c> if <see cref="JsonTextReader.LineNumber"/> and <see cref="JsonTextReader.LinePosition"/> can be provided; otherwise, <c>false</c>.
+        /// </returns>
+        public bool HasLineInfo()
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the current line number.
+        /// </summary>
+        /// <value>
+        /// The current line number or 0 if no line information is available (for example, <see cref="JsonTextReader.HasLineInfo"/> returns <c>false</c>).
+        /// </value>
+        public int LineNumber
+        {
+            get
+            {
+                if (CurrentState == State.Start && LinePosition == 0 && TokenType != JsonToken.Comment)
+                {
+                    return 0;
+                }
+
+                return _lineNumber;
+            }
+        }
+
+        /// <summary>
+        /// Gets the current line position.
+        /// </summary>
+        /// <value>
+        /// The current line position or 0 if no line information is available (for example, <see cref="JsonTextReader.HasLineInfo"/> returns <c>false</c>).
+        /// </value>
+        public int LinePosition => _charPos - _lineStartPos;
+    }
+}
diff --git a/Libs/Newtonsoft.Json/JsonTextWriter.Async.cs b/Libs/Newtonsoft.Json/JsonTextWriter.Async.cs
new file mode 100644
index 0000000..dd7309e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonTextWriter.Async.cs
@@ -0,0 +1,1361 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Globalization;
+using System.Threading;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json
+{
+    public partial class JsonTextWriter
+    {
+        // It's not safe to perform the async methods here in a derived class as if the synchronous equivalent
+        // has been overriden then the asychronous method will no longer be doing the same operation.
+#if HAVE_ASYNC // Double-check this isn't included inappropriately.
+        private readonly bool _safeAsync;
+#endif
+
+        /// <summary>
+        /// Asynchronously flushes whatever is in the buffer to the destination and also flushes the destination.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task FlushAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoFlushAsync(cancellationToken) : base.FlushAsync(cancellationToken);
+        }
+
+        internal Task DoFlushAsync(CancellationToken cancellationToken)
+        {
+            return cancellationToken.CancelIfRequestedAsync() ?? _writer.FlushAsync();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the JSON value delimiter.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        protected override Task WriteValueDelimiterAsync(CancellationToken cancellationToken)
+        {
+            return _safeAsync ? DoWriteValueDelimiterAsync(cancellationToken) : base.WriteValueDelimiterAsync(cancellationToken);
+        }
+
+        internal Task DoWriteValueDelimiterAsync(CancellationToken cancellationToken)
+        {
+            return _writer.WriteAsync(',', cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the specified end token.
+        /// </summary>
+        /// <param name="token">The end token to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        protected override Task WriteEndAsync(JsonToken token, CancellationToken cancellationToken)
+        {
+            return _safeAsync ? DoWriteEndAsync(token, cancellationToken) : base.WriteEndAsync(token, cancellationToken);
+        }
+
+        internal Task DoWriteEndAsync(JsonToken token, CancellationToken cancellationToken)
+        {
+            switch (token)
+            {
+                case JsonToken.EndObject:
+                    return _writer.WriteAsync('}', cancellationToken);
+                case JsonToken.EndArray:
+                    return _writer.WriteAsync(']', cancellationToken);
+                case JsonToken.EndConstructor:
+                    return _writer.WriteAsync(')', cancellationToken);
+                default:
+                    throw JsonWriterException.Create(this, "Invalid JsonToken: " + token, null);
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously closes this writer.
+        /// If <see cref="JsonWriter.CloseOutput"/> is set to <c>true</c>, the destination is also closed.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task CloseAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoCloseAsync(cancellationToken) : base.CloseAsync(cancellationToken);
+        }
+
+        internal async Task DoCloseAsync(CancellationToken cancellationToken)
+        {
+            if (Top == 0) // otherwise will happen in calls to WriteEndAsync
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+
+            while (Top > 0)
+            {
+                await WriteEndAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            CloseBufferAndWriter();
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of the current JSON object or array.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteEndAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteEndInternalAsync(cancellationToken) : base.WriteEndAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes indent characters.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        protected override Task WriteIndentAsync(CancellationToken cancellationToken)
+        {
+            return _safeAsync ? DoWriteIndentAsync(cancellationToken) : base.WriteIndentAsync(cancellationToken);
+        }
+
+        internal Task DoWriteIndentAsync(CancellationToken cancellationToken)
+        {
+            // levels of indentation multiplied by the indent count
+            int currentIndentCount = Top * _indentation;
+
+            int newLineLen = SetIndentChars();
+            MiscellaneousUtils.Assert(_indentChars != null);
+
+            if (currentIndentCount <= IndentCharBufferSize)
+            {
+                return _writer.WriteAsync(_indentChars, 0, newLineLen + currentIndentCount, cancellationToken);
+            }
+
+            return WriteIndentAsync(currentIndentCount, newLineLen, cancellationToken);
+        }
+
+        private async Task WriteIndentAsync(int currentIndentCount, int newLineLen, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(_indentChars != null);
+
+            await _writer.WriteAsync(_indentChars, 0, newLineLen + Math.Min(currentIndentCount, IndentCharBufferSize), cancellationToken).ConfigureAwait(false);
+
+            while ((currentIndentCount -= IndentCharBufferSize) > 0)
+            {
+                await _writer.WriteAsync(_indentChars, newLineLen, Math.Min(currentIndentCount, IndentCharBufferSize), cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        private Task WriteValueInternalAsync(JsonToken token, string value, CancellationToken cancellationToken)
+        {
+            Task task = InternalWriteValueAsync(token, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return _writer.WriteAsync(value, cancellationToken);
+            }
+
+            return WriteValueInternalAsync(task, value, cancellationToken);
+        }
+
+        private async Task WriteValueInternalAsync(Task task, string value, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+            await _writer.WriteAsync(value, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes an indent space.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        protected override Task WriteIndentSpaceAsync(CancellationToken cancellationToken)
+        {
+            return _safeAsync ? DoWriteIndentSpaceAsync(cancellationToken) : base.WriteIndentSpaceAsync(cancellationToken);
+        }
+
+        internal Task DoWriteIndentSpaceAsync(CancellationToken cancellationToken)
+        {
+            return _writer.WriteAsync(' ', cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes raw JSON without changing the writer's state.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteRawAsync(string? json, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteRawAsync(json, cancellationToken) : base.WriteRawAsync(json, cancellationToken);
+        }
+
+        internal Task DoWriteRawAsync(string? json, CancellationToken cancellationToken)
+        {
+            return _writer.WriteAsync(json, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a null value.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteNullAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteNullAsync(cancellationToken) : base.WriteNullAsync(cancellationToken);
+        }
+
+        internal Task DoWriteNullAsync(CancellationToken cancellationToken)
+        {
+            return WriteValueInternalAsync(JsonToken.Null, JsonConvert.Null, cancellationToken);
+        }
+
+        private Task WriteDigitsAsync(ulong uvalue, bool negative, CancellationToken cancellationToken)
+        {
+            if (uvalue <= 9 & !negative)
+            {
+                return _writer.WriteAsync((char)('0' + uvalue), cancellationToken);
+            }
+
+            int length = WriteNumberToBuffer(uvalue, negative);
+            return _writer.WriteAsync(_writeBuffer!, 0, length, cancellationToken);
+        }
+
+        private Task WriteIntegerValueAsync(ulong uvalue, bool negative, CancellationToken cancellationToken)
+        {
+            Task task = InternalWriteValueAsync(JsonToken.Integer, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return WriteDigitsAsync(uvalue, negative, cancellationToken);
+            }
+
+            return WriteIntegerValueAsync(task, uvalue, negative, cancellationToken);
+        }
+
+        private async Task WriteIntegerValueAsync(Task task, ulong uvalue, bool negative, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+            await WriteDigitsAsync(uvalue, negative, cancellationToken).ConfigureAwait(false);
+        }
+
+        internal Task WriteIntegerValueAsync(long value, CancellationToken cancellationToken)
+        {
+            bool negative = value < 0;
+            if (negative)
+            {
+                value = -value;
+            }
+
+            return WriteIntegerValueAsync((ulong)value, negative, cancellationToken);
+        }
+
+        internal Task WriteIntegerValueAsync(ulong uvalue, CancellationToken cancellationToken)
+        {
+            return WriteIntegerValueAsync(uvalue, false, cancellationToken);
+        }
+
+        private Task WriteEscapedStringAsync(string value, bool quote, CancellationToken cancellationToken)
+        {
+            return JavaScriptUtils.WriteEscapedJavaScriptStringAsync(_writer, value, _quoteChar, quote, _charEscapeFlags!, StringEscapeHandling, this, _writeBuffer!, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the property name of a name/value pair of a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WritePropertyNameAsync(string name, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWritePropertyNameAsync(name, cancellationToken) : base.WritePropertyNameAsync(name, cancellationToken);
+        }
+
+        internal Task DoWritePropertyNameAsync(string name, CancellationToken cancellationToken)
+        {
+            Task task = InternalWritePropertyNameAsync(name, cancellationToken);
+            if (!task.IsCompletedSucessfully())
+            {
+                return DoWritePropertyNameAsync(task, name, cancellationToken);
+            }
+
+            task = WriteEscapedStringAsync(name, _quoteName, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return _writer.WriteAsync(':', cancellationToken);
+            }
+
+            return JavaScriptUtils.WriteCharAsync(task, _writer, ':', cancellationToken);
+        }
+
+        private async Task DoWritePropertyNameAsync(Task task, string name, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+
+            await WriteEscapedStringAsync(name, _quoteName, cancellationToken).ConfigureAwait(false);
+
+            await _writer.WriteAsync(':').ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the property name of a name/value pair of a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        /// <param name="escape">A flag to indicate whether the text should be escaped when it is written as a JSON property name.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WritePropertyNameAsync(string name, bool escape, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWritePropertyNameAsync(name, escape, cancellationToken) : base.WritePropertyNameAsync(name, escape, cancellationToken);
+        }
+
+        internal async Task DoWritePropertyNameAsync(string name, bool escape, CancellationToken cancellationToken)
+        {
+            await InternalWritePropertyNameAsync(name, cancellationToken).ConfigureAwait(false);
+
+            if (escape)
+            {
+                await WriteEscapedStringAsync(name, _quoteName, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                if (_quoteName)
+                {
+                    await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+                }
+
+                await _writer.WriteAsync(name, cancellationToken).ConfigureAwait(false);
+
+                if (_quoteName)
+                {
+                    await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+                }
+            }
+
+            await _writer.WriteAsync(':').ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the beginning of a JSON array.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteStartArrayAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteStartArrayAsync(cancellationToken) : base.WriteStartArrayAsync(cancellationToken);
+        }
+
+        internal Task DoWriteStartArrayAsync(CancellationToken cancellationToken)
+        {
+            Task task = InternalWriteStartAsync(JsonToken.StartArray, JsonContainerType.Array, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return _writer.WriteAsync('[', cancellationToken);
+            }
+
+            return DoWriteStartArrayAsync(task, cancellationToken);
+        }
+
+        internal async Task DoWriteStartArrayAsync(Task task, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+
+            await _writer.WriteAsync('[', cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the beginning of a JSON object.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteStartObjectAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteStartObjectAsync(cancellationToken) : base.WriteStartObjectAsync(cancellationToken);
+        }
+
+        internal Task DoWriteStartObjectAsync(CancellationToken cancellationToken)
+        {
+            Task task = InternalWriteStartAsync(JsonToken.StartObject, JsonContainerType.Object, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return _writer.WriteAsync('{', cancellationToken);
+            }
+
+            return DoWriteStartObjectAsync(task, cancellationToken);
+        }
+
+        internal async Task DoWriteStartObjectAsync(Task task, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+
+            await _writer.WriteAsync('{', cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the start of a constructor with the given name.
+        /// </summary>
+        /// <param name="name">The name of the constructor.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteStartConstructorAsync(string name, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteStartConstructorAsync(name, cancellationToken) : base.WriteStartConstructorAsync(name, cancellationToken);
+        }
+
+        internal async Task DoWriteStartConstructorAsync(string name, CancellationToken cancellationToken)
+        {
+            await InternalWriteStartAsync(JsonToken.StartConstructor, JsonContainerType.Constructor, cancellationToken).ConfigureAwait(false);
+
+            await _writer.WriteAsync("new ", cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync(name, cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync('(').ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes an undefined value.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteUndefinedAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteUndefinedAsync(cancellationToken) : base.WriteUndefinedAsync(cancellationToken);
+        }
+
+        internal Task DoWriteUndefinedAsync(CancellationToken cancellationToken)
+        {
+            Task task = InternalWriteValueAsync(JsonToken.Undefined, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return _writer.WriteAsync(JsonConvert.Undefined, cancellationToken);
+            }
+
+            return DoWriteUndefinedAsync(task, cancellationToken);
+        }
+
+        private async Task DoWriteUndefinedAsync(Task task, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+            await _writer.WriteAsync(JsonConvert.Undefined, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the given white space.
+        /// </summary>
+        /// <param name="ws">The string of white space characters.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteWhitespaceAsync(string ws, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteWhitespaceAsync(ws, cancellationToken) : base.WriteWhitespaceAsync(ws, cancellationToken);
+        }
+
+        internal Task DoWriteWhitespaceAsync(string ws, CancellationToken cancellationToken)
+        {
+            InternalWriteWhitespace(ws);
+            return _writer.WriteAsync(ws, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="bool"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="bool"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(bool value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(bool value, CancellationToken cancellationToken)
+        {
+            return WriteValueInternalAsync(JsonToken.Boolean, JsonConvert.ToString(value), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="bool"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="bool"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(bool? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(bool? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : DoWriteValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="byte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(byte value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="byte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(byte? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(byte? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="byte"/>[] value.
+        /// </summary>
+        /// <param name="value">The <see cref="byte"/>[] value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(byte[]? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? (value == null ? WriteNullAsync(cancellationToken) : WriteValueNonNullAsync(value, cancellationToken)) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal async Task WriteValueNonNullAsync(byte[] value, CancellationToken cancellationToken)
+        {
+            await InternalWriteValueAsync(JsonToken.Bytes, cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+            await Base64Encoder.EncodeAsync(value, 0, value.Length, cancellationToken).ConfigureAwait(false);
+            await Base64Encoder.FlushAsync(cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="char"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(char value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(char value, CancellationToken cancellationToken)
+        {
+            return WriteValueInternalAsync(JsonToken.String, JsonConvert.ToString(value), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="char"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(char? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(char? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : DoWriteValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(DateTime value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal async Task DoWriteValueAsync(DateTime value, CancellationToken cancellationToken)
+        {
+            await InternalWriteValueAsync(JsonToken.Date, cancellationToken).ConfigureAwait(false);
+            value = DateTimeUtils.EnsureDateTime(value, DateTimeZoneHandling);
+
+            if (StringUtils.IsNullOrEmpty(DateFormatString))
+            {
+                int length = WriteValueToBuffer(value);
+
+                await _writer.WriteAsync(_writeBuffer!, 0, length, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+                await _writer.WriteAsync(value.ToString(DateFormatString, Culture), cancellationToken).ConfigureAwait(false);
+                await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="DateTime"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(DateTime? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(DateTime? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : DoWriteValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTimeOffset"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(DateTimeOffset value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal async Task DoWriteValueAsync(DateTimeOffset value, CancellationToken cancellationToken)
+        {
+            await InternalWriteValueAsync(JsonToken.Date, cancellationToken).ConfigureAwait(false);
+
+            if (StringUtils.IsNullOrEmpty(DateFormatString))
+            {
+                int length = WriteValueToBuffer(value);
+
+                await _writer.WriteAsync(_writeBuffer!, 0, length, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+                await _writer.WriteAsync(value.ToString(DateFormatString, Culture), cancellationToken).ConfigureAwait(false);
+                await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(DateTimeOffset? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(DateTimeOffset? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : DoWriteValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="decimal"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(decimal value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(decimal value, CancellationToken cancellationToken)
+        {
+            return WriteValueInternalAsync(JsonToken.Float, JsonConvert.ToString(value), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="decimal"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(decimal? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(decimal? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : DoWriteValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="double"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(double value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteValueAsync(value, false, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task WriteValueAsync(double value, bool nullable, CancellationToken cancellationToken)
+        {
+            return WriteValueInternalAsync(JsonToken.Float, JsonConvert.ToString(value, FloatFormatHandling, QuoteChar, nullable), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="double"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(double? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? (value.HasValue ? WriteValueAsync(value.GetValueOrDefault(), true, cancellationToken) : WriteNullAsync(cancellationToken)) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="float"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="float"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(float value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteValueAsync(value, false, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task WriteValueAsync(float value, bool nullable, CancellationToken cancellationToken)
+        {
+            return WriteValueInternalAsync(JsonToken.Float, JsonConvert.ToString(value, FloatFormatHandling, QuoteChar, nullable), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="float"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="float"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(float? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? (value.HasValue ? WriteValueAsync(value.GetValueOrDefault(), true, cancellationToken) : WriteNullAsync(cancellationToken)) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Guid"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(Guid value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal async Task DoWriteValueAsync(Guid value, CancellationToken cancellationToken)
+        {
+            await InternalWriteValueAsync(JsonToken.String, cancellationToken).ConfigureAwait(false);
+
+            await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+#if HAVE_CHAR_TO_STRING_WITH_CULTURE
+            await _writer.WriteAsync(value.ToString("D", CultureInfo.InvariantCulture), cancellationToken).ConfigureAwait(false);
+#else
+            await _writer.WriteAsync(value.ToString("D"), cancellationToken).ConfigureAwait(false);
+#endif
+            await _writer.WriteAsync(_quoteChar).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Guid"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(Guid? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(Guid? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : DoWriteValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="int"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="int"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(int value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="int"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="int"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(int? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(int? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="long"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="long"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(long value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="long"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="long"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(long? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(long? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+#if HAVE_BIG_INTEGER
+        internal Task WriteValueAsync(BigInteger value, CancellationToken cancellationToken)
+        {
+            return WriteValueInternalAsync(JsonToken.Integer, value.ToString(CultureInfo.InvariantCulture), cancellationToken);
+        }
+#endif
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="object"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="object"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(object? value, CancellationToken cancellationToken = default)
+        {
+            if (_safeAsync)
+            {
+                if (value == null)
+                {
+                    return WriteNullAsync(cancellationToken);
+                }
+#if HAVE_BIG_INTEGER
+                if (value is BigInteger i)
+                {
+                    return WriteValueAsync(i, cancellationToken);
+                }
+#endif
+
+                return WriteValueAsync(this, ConvertUtils.GetTypeCode(value.GetType()), value, cancellationToken);
+            }
+
+            return base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="sbyte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="sbyte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(sbyte value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="sbyte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="sbyte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(sbyte? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(sbyte? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="short"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="short"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(short value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="short"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="short"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(short? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(short? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="string"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="string"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(string? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(string? value, CancellationToken cancellationToken)
+        {
+            Task task = InternalWriteValueAsync(JsonToken.String, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return value == null ? _writer.WriteAsync(JsonConvert.Null, cancellationToken) : WriteEscapedStringAsync(value, true, cancellationToken);
+            }
+
+            return DoWriteValueAsync(task, value, cancellationToken);
+        }
+
+        private async Task DoWriteValueAsync(Task task, string? value, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+            await (value == null ? _writer.WriteAsync(JsonConvert.Null, cancellationToken) : WriteEscapedStringAsync(value, true, cancellationToken)).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="TimeSpan"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(TimeSpan value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal async Task DoWriteValueAsync(TimeSpan value, CancellationToken cancellationToken)
+        {
+            await InternalWriteValueAsync(JsonToken.String, cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync(_quoteChar, cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync(value.ToString(null, CultureInfo.InvariantCulture), cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync(_quoteChar, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="TimeSpan"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(TimeSpan? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(TimeSpan? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : DoWriteValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="uint"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="uint"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(uint value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="uint"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="uint"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(uint? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(uint? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="ulong"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="ulong"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(ulong value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="ulong"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="ulong"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(ulong? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(ulong? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Uri"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Uri"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteValueAsync(Uri? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? (value == null ? WriteNullAsync(cancellationToken) : WriteValueNotNullAsync(value, cancellationToken)) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task WriteValueNotNullAsync(Uri value, CancellationToken cancellationToken)
+        {
+            Task task = InternalWriteValueAsync(JsonToken.String, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return WriteEscapedStringAsync(value.OriginalString, true, cancellationToken);
+            }
+
+            return WriteValueNotNullAsync(task, value, cancellationToken);
+        }
+
+        internal async Task WriteValueNotNullAsync(Task task, Uri value, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+            await WriteEscapedStringAsync(value.OriginalString, true, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="ushort"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="ushort"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(ushort value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? WriteIntegerValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="ushort"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="ushort"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        [CLSCompliant(false)]
+        public override Task WriteValueAsync(ushort? value, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteValueAsync(value, cancellationToken) : base.WriteValueAsync(value, cancellationToken);
+        }
+
+        internal Task DoWriteValueAsync(ushort? value, CancellationToken cancellationToken)
+        {
+            return value == null ? DoWriteNullAsync(cancellationToken) : WriteIntegerValueAsync(value.GetValueOrDefault(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a comment <c>/*...*/</c> containing the specified text.
+        /// </summary>
+        /// <param name="text">Text to place inside the comment.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteCommentAsync(string? text, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteCommentAsync(text, cancellationToken) : base.WriteCommentAsync(text, cancellationToken);
+        }
+
+        internal async Task DoWriteCommentAsync(string? text, CancellationToken cancellationToken)
+        {
+            await InternalWriteCommentAsync(cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync("/*", cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync(text ?? string.Empty, cancellationToken).ConfigureAwait(false);
+            await _writer.WriteAsync("*/", cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of an array.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteEndArrayAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? InternalWriteEndAsync(JsonContainerType.Array, cancellationToken) : base.WriteEndArrayAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of a constructor.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteEndConstructorAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? InternalWriteEndAsync(JsonContainerType.Constructor, cancellationToken) : base.WriteEndConstructorAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of a JSON object.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteEndObjectAsync(CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? InternalWriteEndAsync(JsonContainerType.Object, cancellationToken) : base.WriteEndObjectAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes raw JSON where a value is expected and updates the writer's state.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>Derived classes must override this method to get asynchronous behaviour. Otherwise it will
+        /// execute synchronously, returning an already-completed task.</remarks>
+        public override Task WriteRawValueAsync(string? json, CancellationToken cancellationToken = default)
+        {
+            return _safeAsync ? DoWriteRawValueAsync(json, cancellationToken) : base.WriteRawValueAsync(json, cancellationToken);
+        }
+
+        internal Task DoWriteRawValueAsync(string? json, CancellationToken cancellationToken)
+        {
+            UpdateScopeWithFinishedValue();
+            Task task = AutoCompleteAsync(JsonToken.Undefined, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return WriteRawAsync(json, cancellationToken);
+            }
+
+            return DoWriteRawValueAsync(task, json, cancellationToken);
+        }
+
+        private async Task DoWriteRawValueAsync(Task task, string? json, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+            await WriteRawAsync(json, cancellationToken).ConfigureAwait(false);
+        }
+
+        internal char[] EnsureWriteBuffer(int length, int copyTo)
+        {
+            if (length < 35)
+            {
+                length = 35;
+            }
+
+            char[]? buffer = _writeBuffer;
+            if (buffer == null)
+            {
+                return _writeBuffer = BufferUtils.RentBuffer(_arrayPool, length);
+            }
+
+            if (buffer.Length >= length)
+            {
+                return buffer;
+            }
+
+            char[] newBuffer = BufferUtils.RentBuffer(_arrayPool, length);
+            if (copyTo != 0)
+            {
+                Array.Copy(buffer, newBuffer, copyTo);
+            }
+
+            BufferUtils.ReturnBuffer(_arrayPool, buffer);
+            _writeBuffer = newBuffer;
+            return newBuffer;
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonTextWriter.cs b/Libs/Newtonsoft.Json/JsonTextWriter.cs
new file mode 100644
index 0000000..9719604
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonTextWriter.cs
@@ -0,0 +1,920 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Text;
+using System.IO;
+using System.Xml;
+using LC.Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data.
+    /// </summary>
+    public partial class JsonTextWriter : JsonWriter
+    {
+        private const int IndentCharBufferSize = 12;
+        private readonly TextWriter _writer;
+        private Base64Encoder? _base64Encoder;
+        private char _indentChar;
+        private int _indentation;
+        private char _quoteChar;
+        private bool _quoteName;
+        private bool[]? _charEscapeFlags;
+        private char[]? _writeBuffer;
+        private IArrayPool<char>? _arrayPool;
+        private char[]? _indentChars;
+
+        private Base64Encoder Base64Encoder
+        {
+            get
+            {
+                if (_base64Encoder == null)
+                {
+                    _base64Encoder = new Base64Encoder(_writer);
+                }
+
+                return _base64Encoder;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the writer's character array pool.
+        /// </summary>
+        public IArrayPool<char>? ArrayPool
+        {
+            get => _arrayPool;
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+
+                _arrayPool = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how many <see cref="JsonTextWriter.IndentChar"/>s to write for each level in the hierarchy when <see cref="JsonWriter.Formatting"/> is set to <see cref="Formatting.Indented"/>.
+        /// </summary>
+        public int Indentation
+        {
+            get => _indentation;
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentException("Indentation value must be greater than 0.");
+                }
+
+                _indentation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets which character to use to quote attribute values.
+        /// </summary>
+        public char QuoteChar
+        {
+            get => _quoteChar;
+            set
+            {
+                if (value != '"' && value != '\'')
+                {
+                    throw new ArgumentException(@"Invalid JavaScript string quote character. Valid quote characters are ' and "".");
+                }
+
+                _quoteChar = value;
+                UpdateCharEscapeFlags();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets which character to use for indenting when <see cref="JsonWriter.Formatting"/> is set to <see cref="Formatting.Indented"/>.
+        /// </summary>
+        public char IndentChar
+        {
+            get => _indentChar;
+            set
+            {
+                if (value != _indentChar)
+                {
+                    _indentChar = value;
+                    _indentChars = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether object names will be surrounded with quotes.
+        /// </summary>
+        public bool QuoteName
+        {
+            get => _quoteName;
+            set => _quoteName = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonTextWriter"/> class using the specified <see cref="TextWriter"/>.
+        /// </summary>
+        /// <param name="textWriter">The <see cref="TextWriter"/> to write to.</param>
+        public JsonTextWriter(TextWriter textWriter)
+        {
+            if (textWriter == null)
+            {
+                throw new ArgumentNullException(nameof(textWriter));
+            }
+
+            _writer = textWriter;
+            _quoteChar = '"';
+            _quoteName = true;
+            _indentChar = ' ';
+            _indentation = 2;
+
+            UpdateCharEscapeFlags();
+
+#if HAVE_ASYNC
+            _safeAsync = GetType() == typeof(JsonTextWriter);
+#endif
+        }
+
+        /// <summary>
+        /// Flushes whatever is in the buffer to the underlying <see cref="TextWriter"/> and also flushes the underlying <see cref="TextWriter"/>.
+        /// </summary>
+        public override void Flush()
+        {
+            _writer.Flush();
+        }
+
+        /// <summary>
+        /// Closes this writer.
+        /// If <see cref="JsonWriter.CloseOutput"/> is set to <c>true</c>, the underlying <see cref="TextWriter"/> is also closed.
+        /// If <see cref="JsonWriter.AutoCompleteOnClose"/> is set to <c>true</c>, the JSON is auto-completed.
+        /// </summary>
+        public override void Close()
+        {
+            base.Close();
+
+            CloseBufferAndWriter();
+        }
+
+        private void CloseBufferAndWriter()
+        {
+            if (_writeBuffer != null)
+            {
+                BufferUtils.ReturnBuffer(_arrayPool, _writeBuffer);
+                _writeBuffer = null;
+            }
+
+            if (CloseOutput)
+            {
+#if HAVE_STREAM_READER_WRITER_CLOSE
+                _writer?.Close();
+#else
+                _writer?.Dispose();
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON object.
+        /// </summary>
+        public override void WriteStartObject()
+        {
+            InternalWriteStart(JsonToken.StartObject, JsonContainerType.Object);
+
+            _writer.Write('{');
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON array.
+        /// </summary>
+        public override void WriteStartArray()
+        {
+            InternalWriteStart(JsonToken.StartArray, JsonContainerType.Array);
+
+            _writer.Write('[');
+        }
+
+        /// <summary>
+        /// Writes the start of a constructor with the given name.
+        /// </summary>
+        /// <param name="name">The name of the constructor.</param>
+        public override void WriteStartConstructor(string name)
+        {
+            InternalWriteStart(JsonToken.StartConstructor, JsonContainerType.Constructor);
+
+            _writer.Write("new ");
+            _writer.Write(name);
+            _writer.Write('(');
+        }
+
+        /// <summary>
+        /// Writes the specified end token.
+        /// </summary>
+        /// <param name="token">The end token to write.</param>
+        protected override void WriteEnd(JsonToken token)
+        {
+            switch (token)
+            {
+                case JsonToken.EndObject:
+                    _writer.Write('}');
+                    break;
+                case JsonToken.EndArray:
+                    _writer.Write(']');
+                    break;
+                case JsonToken.EndConstructor:
+                    _writer.Write(')');
+                    break;
+                default:
+                    throw JsonWriterException.Create(this, "Invalid JsonToken: " + token, null);
+            }
+        }
+
+        /// <summary>
+        /// Writes the property name of a name/value pair on a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        public override void WritePropertyName(string name)
+        {
+            InternalWritePropertyName(name);
+
+            WriteEscapedString(name, _quoteName);
+
+            _writer.Write(':');
+        }
+
+        /// <summary>
+        /// Writes the property name of a name/value pair on a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        /// <param name="escape">A flag to indicate whether the text should be escaped when it is written as a JSON property name.</param>
+        public override void WritePropertyName(string name, bool escape)
+        {
+            InternalWritePropertyName(name);
+
+            if (escape)
+            {
+                WriteEscapedString(name, _quoteName);
+            }
+            else
+            {
+                if (_quoteName)
+                {
+                    _writer.Write(_quoteChar);
+                }
+
+                _writer.Write(name);
+
+                if (_quoteName)
+                {
+                    _writer.Write(_quoteChar);
+                }
+            }
+
+            _writer.Write(':');
+        }
+
+        internal override void OnStringEscapeHandlingChanged()
+        {
+            UpdateCharEscapeFlags();
+        }
+
+        private void UpdateCharEscapeFlags()
+        {
+            _charEscapeFlags = JavaScriptUtils.GetCharEscapeFlags(StringEscapeHandling, _quoteChar);
+        }
+
+        /// <summary>
+        /// Writes indent characters.
+        /// </summary>
+        protected override void WriteIndent()
+        {
+            // levels of indentation multiplied by the indent count
+            int currentIndentCount = Top * _indentation;
+
+            int newLineLen = SetIndentChars();
+
+            _writer.Write(_indentChars, 0, newLineLen + Math.Min(currentIndentCount, IndentCharBufferSize));
+
+            while ((currentIndentCount -= IndentCharBufferSize) > 0)
+            {
+                _writer.Write(_indentChars, newLineLen, Math.Min(currentIndentCount, IndentCharBufferSize));
+            }
+        }
+
+        private int SetIndentChars()
+        {
+            // Set _indentChars to be a newline followed by IndentCharBufferSize indent characters.
+            string writerNewLine = _writer.NewLine;
+            int newLineLen = writerNewLine.Length;
+            bool match = _indentChars != null && _indentChars.Length == IndentCharBufferSize + newLineLen;
+            if (match)
+            {
+                for (int i = 0; i != newLineLen; ++i)
+                {
+                    if (writerNewLine[i] != _indentChars![i])
+                    {
+                        match = false;
+                        break;
+                    }
+                }
+            }
+
+            if (!match)
+            {
+                // If we're here, either _indentChars hasn't been set yet, or _writer.NewLine
+                // has been changed, or _indentChar has been changed.
+                _indentChars = (writerNewLine + new string(_indentChar, IndentCharBufferSize)).ToCharArray();
+            }
+
+            return newLineLen;
+        }
+
+        /// <summary>
+        /// Writes the JSON value delimiter.
+        /// </summary>
+        protected override void WriteValueDelimiter()
+        {
+            _writer.Write(',');
+        }
+
+        /// <summary>
+        /// Writes an indent space.
+        /// </summary>
+        protected override void WriteIndentSpace()
+        {
+            _writer.Write(' ');
+        }
+
+        private void WriteValueInternal(string value, JsonToken token)
+        {
+            _writer.Write(value);
+        }
+
+        #region WriteValue methods
+        /// <summary>
+        /// Writes a <see cref="Object"/> value.
+        /// An error will raised if the value cannot be written as a single JSON token.
+        /// </summary>
+        /// <param name="value">The <see cref="Object"/> value to write.</param>
+        public override void WriteValue(object? value)
+        {
+#if HAVE_BIG_INTEGER
+            if (value is BigInteger i)
+            {
+                InternalWriteValue(JsonToken.Integer);
+                WriteValueInternal(i.ToString(CultureInfo.InvariantCulture), JsonToken.String);
+            }
+            else
+#endif
+            {
+                base.WriteValue(value);
+            }
+        }
+
+        /// <summary>
+        /// Writes a null value.
+        /// </summary>
+        public override void WriteNull()
+        {
+            InternalWriteValue(JsonToken.Null);
+            WriteValueInternal(JsonConvert.Null, JsonToken.Null);
+        }
+
+        /// <summary>
+        /// Writes an undefined value.
+        /// </summary>
+        public override void WriteUndefined()
+        {
+            InternalWriteValue(JsonToken.Undefined);
+            WriteValueInternal(JsonConvert.Undefined, JsonToken.Undefined);
+        }
+
+        /// <summary>
+        /// Writes raw JSON.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        public override void WriteRaw(string? json)
+        {
+            InternalWriteRaw();
+
+            _writer.Write(json);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="String"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="String"/> value to write.</param>
+        public override void WriteValue(string? value)
+        {
+            InternalWriteValue(JsonToken.String);
+
+            if (value == null)
+            {
+                WriteValueInternal(JsonConvert.Null, JsonToken.Null);
+            }
+            else
+            {
+                WriteEscapedString(value, true);
+            }
+        }
+
+        private void WriteEscapedString(string value, bool quote)
+        {
+            EnsureWriteBuffer();
+            JavaScriptUtils.WriteEscapedJavaScriptString(_writer, value, _quoteChar, quote, _charEscapeFlags!, StringEscapeHandling, _arrayPool, ref _writeBuffer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int32"/> value to write.</param>
+        public override void WriteValue(int value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt32"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(uint value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int64"/> value to write.</param>
+        public override void WriteValue(long value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt64"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(ulong value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value, false);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Single"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Single"/> value to write.</param>
+        public override void WriteValue(float value)
+        {
+            InternalWriteValue(JsonToken.Float);
+            WriteValueInternal(JsonConvert.ToString(value, FloatFormatHandling, QuoteChar, false), JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Single"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Single"/> value to write.</param>
+        public override void WriteValue(float? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                InternalWriteValue(JsonToken.Float);
+                WriteValueInternal(JsonConvert.ToString(value.GetValueOrDefault(), FloatFormatHandling, QuoteChar, true), JsonToken.Float);
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Double"/> value to write.</param>
+        public override void WriteValue(double value)
+        {
+            InternalWriteValue(JsonToken.Float);
+            WriteValueInternal(JsonConvert.ToString(value, FloatFormatHandling, QuoteChar, false), JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Double"/> value to write.</param>
+        public override void WriteValue(double? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                InternalWriteValue(JsonToken.Float);
+                WriteValueInternal(JsonConvert.ToString(value.GetValueOrDefault(), FloatFormatHandling, QuoteChar, true), JsonToken.Float);
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Boolean"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Boolean"/> value to write.</param>
+        public override void WriteValue(bool value)
+        {
+            InternalWriteValue(JsonToken.Boolean);
+            WriteValueInternal(JsonConvert.ToString(value), JsonToken.Boolean);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int16"/> value to write.</param>
+        public override void WriteValue(short value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt16"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(ushort value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Char"/> value to write.</param>
+        public override void WriteValue(char value)
+        {
+            InternalWriteValue(JsonToken.String);
+            WriteValueInternal(JsonConvert.ToString(value), JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/> value to write.</param>
+        public override void WriteValue(byte value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="SByte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="SByte"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(sbyte value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+            WriteIntegerValue(value);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Decimal"/> value to write.</param>
+        public override void WriteValue(decimal value)
+        {
+            InternalWriteValue(JsonToken.Float);
+            WriteValueInternal(JsonConvert.ToString(value), JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
+        public override void WriteValue(DateTime value)
+        {
+            InternalWriteValue(JsonToken.Date);
+            value = DateTimeUtils.EnsureDateTime(value, DateTimeZoneHandling);
+
+            if (StringUtils.IsNullOrEmpty(DateFormatString))
+            {
+                int length = WriteValueToBuffer(value);
+
+                _writer.Write(_writeBuffer, 0, length);
+            }
+            else
+            {
+                _writer.Write(_quoteChar);
+                _writer.Write(value.ToString(DateFormatString, Culture));
+                _writer.Write(_quoteChar);
+            }
+        }
+
+        private int WriteValueToBuffer(DateTime value)
+        {
+            EnsureWriteBuffer();
+            MiscellaneousUtils.Assert(_writeBuffer != null);
+
+            int pos = 0;
+            _writeBuffer[pos++] = _quoteChar;
+            pos = DateTimeUtils.WriteDateTimeString(_writeBuffer, pos, value, null, value.Kind, DateFormatHandling);
+            _writeBuffer[pos++] = _quoteChar;
+            return pos;
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/>[] value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/>[] value to write.</param>
+        public override void WriteValue(byte[]? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                InternalWriteValue(JsonToken.Bytes);
+                _writer.Write(_quoteChar);
+                Base64Encoder.Encode(value, 0, value.Length);
+                Base64Encoder.Flush();
+                _writer.Write(_quoteChar);
+            }
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Writes a <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTimeOffset"/> value to write.</param>
+        public override void WriteValue(DateTimeOffset value)
+        {
+            InternalWriteValue(JsonToken.Date);
+
+            if (StringUtils.IsNullOrEmpty(DateFormatString))
+            {
+                int length = WriteValueToBuffer(value);
+
+                _writer.Write(_writeBuffer, 0, length);
+            }
+            else
+            {
+                _writer.Write(_quoteChar);
+                _writer.Write(value.ToString(DateFormatString, Culture));
+                _writer.Write(_quoteChar);
+            }
+        }
+
+        private int WriteValueToBuffer(DateTimeOffset value)
+        {
+            EnsureWriteBuffer();
+            MiscellaneousUtils.Assert(_writeBuffer != null);
+
+            int pos = 0;
+            _writeBuffer[pos++] = _quoteChar;
+            pos = DateTimeUtils.WriteDateTimeString(_writeBuffer, pos, (DateFormatHandling == DateFormatHandling.IsoDateFormat) ? value.DateTime : value.UtcDateTime, value.Offset, DateTimeKind.Local, DateFormatHandling);
+            _writeBuffer[pos++] = _quoteChar;
+            return pos;
+        }
+#endif
+
+        /// <summary>
+        /// Writes a <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Guid"/> value to write.</param>
+        public override void WriteValue(Guid value)
+        {
+            InternalWriteValue(JsonToken.String);
+
+            string text;
+
+#if HAVE_CHAR_TO_STRING_WITH_CULTURE
+            text = value.ToString("D", CultureInfo.InvariantCulture);
+#else
+            text = value.ToString("D");
+#endif
+
+            _writer.Write(_quoteChar);
+            _writer.Write(text);
+            _writer.Write(_quoteChar);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="TimeSpan"/> value to write.</param>
+        public override void WriteValue(TimeSpan value)
+        {
+            InternalWriteValue(JsonToken.String);
+
+            string text;
+#if !HAVE_TIME_SPAN_TO_STRING_WITH_CULTURE
+            text = value.ToString();
+#else
+            text = value.ToString(null, CultureInfo.InvariantCulture);
+#endif
+
+            _writer.Write(_quoteChar);
+            _writer.Write(text);
+            _writer.Write(_quoteChar);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Uri"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Uri"/> value to write.</param>
+        public override void WriteValue(Uri? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                InternalWriteValue(JsonToken.String);
+                WriteEscapedString(value.OriginalString, true);
+            }
+        }
+        #endregion
+
+        /// <summary>
+        /// Writes a comment <c>/*...*/</c> containing the specified text. 
+        /// </summary>
+        /// <param name="text">Text to place inside the comment.</param>
+        public override void WriteComment(string? text)
+        {
+            InternalWriteComment();
+
+            _writer.Write("/*");
+            _writer.Write(text);
+            _writer.Write("*/");
+        }
+
+        /// <summary>
+        /// Writes the given white space.
+        /// </summary>
+        /// <param name="ws">The string of white space characters.</param>
+        public override void WriteWhitespace(string ws)
+        {
+            InternalWriteWhitespace(ws);
+
+            _writer.Write(ws);
+        }
+
+        private void EnsureWriteBuffer()
+        {
+            if (_writeBuffer == null)
+            {
+                // maximum buffer sized used when writing iso date
+                _writeBuffer = BufferUtils.RentBuffer(_arrayPool, 35);
+            }
+        }
+
+        private void WriteIntegerValue(long value)
+        {
+            if (value >= 0 && value <= 9)
+            {
+                _writer.Write((char)('0' + value));
+            }
+            else
+            {
+                bool negative = value < 0;
+                WriteIntegerValue(negative ? (ulong)-value : (ulong)value, negative);
+            }
+        }
+
+        private void WriteIntegerValue(ulong value, bool negative)
+        {
+            if (!negative & value <= 9)
+            {
+                _writer.Write((char)('0' + value));
+            }
+            else
+            {
+                int length = WriteNumberToBuffer(value, negative);
+                _writer.Write(_writeBuffer, 0, length);
+            }
+        }
+
+        private int WriteNumberToBuffer(ulong value, bool negative)
+        {
+            if (value <= uint.MaxValue)
+            {
+                // avoid the 64 bit division if possible
+                return WriteNumberToBuffer((uint)value, negative);
+            }
+
+            EnsureWriteBuffer();
+            MiscellaneousUtils.Assert(_writeBuffer != null);
+
+            int totalLength = MathUtils.IntLength(value);
+
+            if (negative)
+            {
+                totalLength++;
+                _writeBuffer[0] = '-';
+            }
+
+            int index = totalLength;
+
+            do
+            {
+                ulong quotient = value / 10;
+                ulong digit = value - (quotient * 10);
+                _writeBuffer[--index] = (char)('0' + digit);
+                value = quotient;
+            } while (value != 0);
+
+            return totalLength;
+        }
+
+        private void WriteIntegerValue(int value)
+        {
+            if (value >= 0 && value <= 9)
+            {
+                _writer.Write((char)('0' + value));
+            }
+            else
+            {
+                bool negative = value < 0;
+                WriteIntegerValue(negative ? (uint)-value : (uint)value, negative);
+            }
+        }
+
+        private void WriteIntegerValue(uint value, bool negative)
+        {
+            if (!negative & value <= 9)
+            {
+                _writer.Write((char)('0' + value));
+            }
+            else
+            {
+                int length = WriteNumberToBuffer(value, negative);
+                _writer.Write(_writeBuffer, 0, length);
+            }
+        }
+
+        private int WriteNumberToBuffer(uint value, bool negative)
+        {
+            EnsureWriteBuffer();
+            MiscellaneousUtils.Assert(_writeBuffer != null);
+
+            int totalLength = MathUtils.IntLength(value);
+
+            if (negative)
+            {
+                totalLength++;
+                _writeBuffer[0] = '-';
+            }
+
+            int index = totalLength;
+
+            do
+            {
+                uint quotient = value / 10;
+                uint digit = value - (quotient * 10);
+                _writeBuffer[--index] = (char)('0' + digit);
+                value = quotient;
+            } while (value != 0);
+
+            return totalLength;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonToken.cs b/Libs/Newtonsoft.Json/JsonToken.cs
new file mode 100644
index 0000000..9229cd3
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonToken.cs
@@ -0,0 +1,127 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies the type of JSON token.
+    /// </summary>
+    public enum JsonToken
+    {
+        /// <summary>
+        /// This is returned by the <see cref="JsonReader"/> if a read method has not been called.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// An object start token.
+        /// </summary>
+        StartObject = 1,
+
+        /// <summary>
+        /// An array start token.
+        /// </summary>
+        StartArray = 2,
+
+        /// <summary>
+        /// A constructor start token.
+        /// </summary>
+        StartConstructor = 3,
+
+        /// <summary>
+        /// An object property name.
+        /// </summary>
+        PropertyName = 4,
+
+        /// <summary>
+        /// A comment.
+        /// </summary>
+        Comment = 5,
+
+        /// <summary>
+        /// Raw JSON.
+        /// </summary>
+        Raw = 6,
+
+        /// <summary>
+        /// An integer.
+        /// </summary>
+        Integer = 7,
+
+        /// <summary>
+        /// A float.
+        /// </summary>
+        Float = 8,
+
+        /// <summary>
+        /// A string.
+        /// </summary>
+        String = 9,
+
+        /// <summary>
+        /// A boolean.
+        /// </summary>
+        Boolean = 10,
+
+        /// <summary>
+        /// A null token.
+        /// </summary>
+        Null = 11,
+
+        /// <summary>
+        /// An undefined token.
+        /// </summary>
+        Undefined = 12,
+
+        /// <summary>
+        /// An object end token.
+        /// </summary>
+        EndObject = 13,
+
+        /// <summary>
+        /// An array end token.
+        /// </summary>
+        EndArray = 14,
+
+        /// <summary>
+        /// A constructor end token.
+        /// </summary>
+        EndConstructor = 15,
+
+        /// <summary>
+        /// A Date.
+        /// </summary>
+        Date = 16,
+
+        /// <summary>
+        /// Byte data.
+        /// </summary>
+        Bytes = 17
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonValidatingReader.cs b/Libs/Newtonsoft.Json/JsonValidatingReader.cs
new file mode 100644
index 0000000..93efb46
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonValidatingReader.cs
@@ -0,0 +1,1025 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Schema;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.IO;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// <para>
+    /// Represents a reader that provides <see cref="JsonSchema"/> validation.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public class JsonValidatingReader : JsonReader, IJsonLineInfo
+    {
+        private class SchemaScope
+        {
+            private readonly JTokenType _tokenType;
+            private readonly IList<JsonSchemaModel> _schemas;
+            private readonly Dictionary<string, bool> _requiredProperties;
+
+            public string CurrentPropertyName { get; set; }
+            public int ArrayItemCount { get; set; }
+            public bool IsUniqueArray { get; }
+            public IList<JToken> UniqueArrayItems { get; }
+            public JTokenWriter CurrentItemWriter { get; set; }
+
+            public IList<JsonSchemaModel> Schemas => _schemas;
+
+            public Dictionary<string, bool> RequiredProperties => _requiredProperties;
+
+            public JTokenType TokenType => _tokenType;
+
+            public SchemaScope(JTokenType tokenType, IList<JsonSchemaModel> schemas)
+            {
+                _tokenType = tokenType;
+                _schemas = schemas;
+
+                _requiredProperties = schemas.SelectMany<JsonSchemaModel, string>(GetRequiredProperties).Distinct().ToDictionary(p => p, p => false);
+
+                if (tokenType == JTokenType.Array && schemas.Any(s => s.UniqueItems))
+                {
+                    IsUniqueArray = true;
+                    UniqueArrayItems = new List<JToken>();
+                }
+            }
+
+            private IEnumerable<string> GetRequiredProperties(JsonSchemaModel schema)
+            {
+                if (schema?.Properties == null)
+                {
+                    return Enumerable.Empty<string>();
+                }
+
+                return schema.Properties.Where(p => p.Value.Required).Select(p => p.Key);
+            }
+        }
+
+        private readonly JsonReader _reader;
+        private readonly Stack<SchemaScope> _stack;
+        private JsonSchema _schema;
+        private JsonSchemaModel _model;
+        private SchemaScope _currentScope;
+
+        /// <summary>
+        /// Sets an event handler for receiving schema validation errors.
+        /// </summary>
+        public event ValidationEventHandler ValidationEventHandler;
+
+        /// <summary>
+        /// Gets the text value of the current JSON token.
+        /// </summary>
+        /// <value></value>
+        public override object Value => _reader.Value;
+
+        /// <summary>
+        /// Gets the depth of the current token in the JSON document.
+        /// </summary>
+        /// <value>The depth of the current token in the JSON document.</value>
+        public override int Depth => _reader.Depth;
+
+        /// <summary>
+        /// Gets the path of the current JSON token. 
+        /// </summary>
+        public override string Path => _reader.Path;
+
+        /// <summary>
+        /// Gets the quotation mark character used to enclose the value of a string.
+        /// </summary>
+        /// <value></value>
+        public override char QuoteChar
+        {
+            get { return _reader.QuoteChar; }
+            protected internal set { }
+        }
+
+        /// <summary>
+        /// Gets the type of the current JSON token.
+        /// </summary>
+        /// <value></value>
+        public override JsonToken TokenType => _reader.TokenType;
+
+        /// <summary>
+        /// Gets the .NET type for the current JSON token.
+        /// </summary>
+        /// <value></value>
+        public override Type ValueType => _reader.ValueType;
+
+        private void Push(SchemaScope scope)
+        {
+            _stack.Push(scope);
+            _currentScope = scope;
+        }
+
+        private SchemaScope Pop()
+        {
+            SchemaScope poppedScope = _stack.Pop();
+            _currentScope = (_stack.Count != 0)
+                ? _stack.Peek()
+                : null;
+
+            return poppedScope;
+        }
+
+        private IList<JsonSchemaModel> CurrentSchemas => _currentScope.Schemas;
+
+        private static readonly IList<JsonSchemaModel> EmptySchemaList = new List<JsonSchemaModel>();
+
+        private IList<JsonSchemaModel> CurrentMemberSchemas
+        {
+            get
+            {
+                if (_currentScope == null)
+                {
+                    return new List<JsonSchemaModel>(new[] { _model });
+                }
+
+                if (_currentScope.Schemas == null || _currentScope.Schemas.Count == 0)
+                {
+                    return EmptySchemaList;
+                }
+
+                switch (_currentScope.TokenType)
+                {
+                    case JTokenType.None:
+                        return _currentScope.Schemas;
+                    case JTokenType.Object:
+                        {
+                            if (_currentScope.CurrentPropertyName == null)
+                            {
+                                throw new JsonReaderException("CurrentPropertyName has not been set on scope.");
+                            }
+
+                            IList<JsonSchemaModel> schemas = new List<JsonSchemaModel>();
+
+                            foreach (JsonSchemaModel schema in CurrentSchemas)
+                            {
+                                if (schema.Properties != null && schema.Properties.TryGetValue(_currentScope.CurrentPropertyName, out JsonSchemaModel propertySchema))
+                                {
+                                    schemas.Add(propertySchema);
+                                }
+                                if (schema.PatternProperties != null)
+                                {
+                                    foreach (KeyValuePair<string, JsonSchemaModel> patternProperty in schema.PatternProperties)
+                                    {
+                                        if (Regex.IsMatch(_currentScope.CurrentPropertyName, patternProperty.Key))
+                                        {
+                                            schemas.Add(patternProperty.Value);
+                                        }
+                                    }
+                                }
+
+                                if (schemas.Count == 0 && schema.AllowAdditionalProperties && schema.AdditionalProperties != null)
+                                {
+                                    schemas.Add(schema.AdditionalProperties);
+                                }
+                            }
+
+                            return schemas;
+                        }
+                    case JTokenType.Array:
+                        {
+                            IList<JsonSchemaModel> schemas = new List<JsonSchemaModel>();
+
+                            foreach (JsonSchemaModel schema in CurrentSchemas)
+                            {
+                                if (!schema.PositionalItemsValidation)
+                                {
+                                    if (schema.Items != null && schema.Items.Count > 0)
+                                    {
+                                        schemas.Add(schema.Items[0]);
+                                    }
+                                }
+                                else
+                                {
+                                    if (schema.Items != null && schema.Items.Count > 0)
+                                    {
+                                        if (schema.Items.Count > (_currentScope.ArrayItemCount - 1))
+                                        {
+                                            schemas.Add(schema.Items[_currentScope.ArrayItemCount - 1]);
+                                        }
+                                    }
+
+                                    if (schema.AllowAdditionalItems && schema.AdditionalItems != null)
+                                    {
+                                        schemas.Add(schema.AdditionalItems);
+                                    }
+                                }
+                            }
+
+                            return schemas;
+                        }
+                    case JTokenType.Constructor:
+                        return EmptySchemaList;
+                    default:
+                        throw new ArgumentOutOfRangeException("TokenType", "Unexpected token type: {0}".FormatWith(CultureInfo.InvariantCulture, _currentScope.TokenType));
+                }
+            }
+        }
+
+        private void RaiseError(string message, JsonSchemaModel schema)
+        {
+            IJsonLineInfo lineInfo = this;
+
+            string exceptionMessage = (lineInfo.HasLineInfo())
+                ? message + " Line {0}, position {1}.".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition)
+                : message;
+
+            OnValidationEvent(new JsonSchemaException(exceptionMessage, null, Path, lineInfo.LineNumber, lineInfo.LinePosition));
+        }
+
+        private void OnValidationEvent(JsonSchemaException exception)
+        {
+            ValidationEventHandler handler = ValidationEventHandler;
+            if (handler != null)
+            {
+                handler(this, new ValidationEventArgs(exception));
+            }
+            else
+            {
+                throw exception;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonValidatingReader"/> class that
+        /// validates the content returned from the given <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from while validating.</param>
+        public JsonValidatingReader(JsonReader reader)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+            _reader = reader;
+            _stack = new Stack<SchemaScope>();
+        }
+
+        /// <summary>
+        /// Gets or sets the schema.
+        /// </summary>
+        /// <value>The schema.</value>
+        public JsonSchema Schema
+        {
+            get => _schema;
+            set
+            {
+                if (TokenType != JsonToken.None)
+                {
+                    throw new InvalidOperationException("Cannot change schema while validating JSON.");
+                }
+
+                _schema = value;
+                _model = null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JsonReader"/> used to construct this <see cref="JsonValidatingReader"/>.
+        /// </summary>
+        /// <value>The <see cref="JsonReader"/> specified in the constructor.</value>
+        public JsonReader Reader => _reader;
+
+        /// <summary>
+        /// Changes the reader's state to <see cref="JsonReader.State.Closed"/>.
+        /// If <see cref="JsonReader.CloseInput"/> is set to <c>true</c>, the underlying <see cref="JsonReader"/> is also closed.
+        /// </summary>
+        public override void Close()
+        {
+            base.Close();
+            if (CloseInput)
+            {
+                _reader?.Close();
+            }
+        }
+
+        private void ValidateNotDisallowed(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            JsonSchemaType? currentNodeType = GetCurrentNodeSchemaType();
+            if (currentNodeType != null)
+            {
+                if (JsonSchemaGenerator.HasFlag(schema.Disallow, currentNodeType.GetValueOrDefault()))
+                {
+                    RaiseError("Type {0} is disallowed.".FormatWith(CultureInfo.InvariantCulture, currentNodeType), schema);
+                }
+            }
+        }
+
+        private JsonSchemaType? GetCurrentNodeSchemaType()
+        {
+            switch (_reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return JsonSchemaType.Object;
+                case JsonToken.StartArray:
+                    return JsonSchemaType.Array;
+                case JsonToken.Integer:
+                    return JsonSchemaType.Integer;
+                case JsonToken.Float:
+                    return JsonSchemaType.Float;
+                case JsonToken.String:
+                    return JsonSchemaType.String;
+                case JsonToken.Boolean:
+                    return JsonSchemaType.Boolean;
+                case JsonToken.Null:
+                    return JsonSchemaType.Null;
+                default:
+                    return null;
+            }
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="Nullable{T}"/> of <see cref="Int32"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Int32"/>.</returns>
+        public override int? ReadAsInt32()
+        {
+            int? i = _reader.ReadAsInt32();
+
+            ValidateCurrentToken();
+            return i;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="Byte"/>[].
+        /// </summary>
+        /// <returns>
+        /// A <see cref="Byte"/>[] or <c>null</c> if the next JSON token is null.
+        /// </returns>
+        public override byte[] ReadAsBytes()
+        {
+            byte[] data = _reader.ReadAsBytes();
+
+            ValidateCurrentToken();
+            return data;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="Nullable{T}"/> of <see cref="Decimal"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Decimal"/>.</returns>
+        public override decimal? ReadAsDecimal()
+        {
+            decimal? d = _reader.ReadAsDecimal();
+
+            ValidateCurrentToken();
+            return d;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="Nullable{T}"/> of <see cref="Double"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Double"/>.</returns>
+        public override double? ReadAsDouble()
+        {
+            double? d = _reader.ReadAsDouble();
+
+            ValidateCurrentToken();
+            return d;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="Nullable{T}"/> of <see cref="Boolean"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="Boolean"/>.</returns>
+        public override bool? ReadAsBoolean()
+        {
+            bool? b = _reader.ReadAsBoolean();
+
+            ValidateCurrentToken();
+            return b;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="String"/>.
+        /// </summary>
+        /// <returns>A <see cref="String"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override string ReadAsString()
+        {
+            string s = _reader.ReadAsString();
+
+            ValidateCurrentToken();
+            return s;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="Nullable{T}"/> of <see cref="DateTime"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="DateTime"/>. This method will return <c>null</c> at the end of an array.</returns>
+        public override DateTime? ReadAsDateTime()
+        {
+            DateTime? dateTime = _reader.ReadAsDateTime();
+
+            ValidateCurrentToken();
+            return dateTime;
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/> as a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>.
+        /// </summary>
+        /// <returns>A <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>.</returns>
+        public override DateTimeOffset? ReadAsDateTimeOffset()
+        {
+            DateTimeOffset? dateTimeOffset = _reader.ReadAsDateTimeOffset();
+
+            ValidateCurrentToken();
+            return dateTimeOffset;
+        }
+#endif
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JsonReader"/>.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the next token was read successfully; <c>false</c> if there are no more tokens to read.
+        /// </returns>
+        public override bool Read()
+        {
+            if (!_reader.Read())
+            {
+                return false;
+            }
+
+            if (_reader.TokenType == JsonToken.Comment)
+            {
+                return true;
+            }
+
+            ValidateCurrentToken();
+            return true;
+        }
+
+        private void ValidateCurrentToken()
+        {
+            // first time validate has been called. build model
+            if (_model == null)
+            {
+                JsonSchemaModelBuilder builder = new JsonSchemaModelBuilder();
+                _model = builder.Build(_schema);
+
+                if (!JsonTokenUtils.IsStartToken(_reader.TokenType))
+                {
+                    Push(new SchemaScope(JTokenType.None, CurrentMemberSchemas));
+                }
+            }
+
+            switch (_reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    ProcessValue();
+                    IList<JsonSchemaModel> objectSchemas = CurrentMemberSchemas.Where(ValidateObject).ToList();
+                    Push(new SchemaScope(JTokenType.Object, objectSchemas));
+                    WriteToken(CurrentSchemas);
+                    break;
+                case JsonToken.StartArray:
+                    ProcessValue();
+                    IList<JsonSchemaModel> arraySchemas = CurrentMemberSchemas.Where(ValidateArray).ToList();
+                    Push(new SchemaScope(JTokenType.Array, arraySchemas));
+                    WriteToken(CurrentSchemas);
+                    break;
+                case JsonToken.StartConstructor:
+                    ProcessValue();
+                    Push(new SchemaScope(JTokenType.Constructor, null));
+                    WriteToken(CurrentSchemas);
+                    break;
+                case JsonToken.PropertyName:
+                    WriteToken(CurrentSchemas);
+                    foreach (JsonSchemaModel schema in CurrentSchemas)
+                    {
+                        ValidatePropertyName(schema);
+                    }
+                    break;
+                case JsonToken.Raw:
+                    ProcessValue();
+                    break;
+                case JsonToken.Integer:
+                    ProcessValue();
+                    WriteToken(CurrentMemberSchemas);
+                    foreach (JsonSchemaModel schema in CurrentMemberSchemas)
+                    {
+                        ValidateInteger(schema);
+                    }
+                    break;
+                case JsonToken.Float:
+                    ProcessValue();
+                    WriteToken(CurrentMemberSchemas);
+                    foreach (JsonSchemaModel schema in CurrentMemberSchemas)
+                    {
+                        ValidateFloat(schema);
+                    }
+                    break;
+                case JsonToken.String:
+                    ProcessValue();
+                    WriteToken(CurrentMemberSchemas);
+                    foreach (JsonSchemaModel schema in CurrentMemberSchemas)
+                    {
+                        ValidateString(schema);
+                    }
+                    break;
+                case JsonToken.Boolean:
+                    ProcessValue();
+                    WriteToken(CurrentMemberSchemas);
+                    foreach (JsonSchemaModel schema in CurrentMemberSchemas)
+                    {
+                        ValidateBoolean(schema);
+                    }
+                    break;
+                case JsonToken.Null:
+                    ProcessValue();
+                    WriteToken(CurrentMemberSchemas);
+                    foreach (JsonSchemaModel schema in CurrentMemberSchemas)
+                    {
+                        ValidateNull(schema);
+                    }
+                    break;
+                case JsonToken.EndObject:
+                    WriteToken(CurrentSchemas);
+                    foreach (JsonSchemaModel schema in CurrentSchemas)
+                    {
+                        ValidateEndObject(schema);
+                    }
+                    Pop();
+                    break;
+                case JsonToken.EndArray:
+                    WriteToken(CurrentSchemas);
+                    foreach (JsonSchemaModel schema in CurrentSchemas)
+                    {
+                        ValidateEndArray(schema);
+                    }
+                    Pop();
+                    break;
+                case JsonToken.EndConstructor:
+                    WriteToken(CurrentSchemas);
+                    Pop();
+                    break;
+                case JsonToken.Undefined:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                    // these have no equivalent in JSON schema
+                    WriteToken(CurrentMemberSchemas);
+                    break;
+                case JsonToken.None:
+                    // no content, do nothing
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        private void WriteToken(IList<JsonSchemaModel> schemas)
+        {
+            foreach (SchemaScope schemaScope in _stack)
+            {
+                bool isInUniqueArray = (schemaScope.TokenType == JTokenType.Array && schemaScope.IsUniqueArray && schemaScope.ArrayItemCount > 0);
+
+                if (isInUniqueArray || schemas.Any(s => s.Enum != null))
+                {
+                    if (schemaScope.CurrentItemWriter == null)
+                    {
+                        if (JsonTokenUtils.IsEndToken(_reader.TokenType))
+                        {
+                            continue;
+                        }
+
+                        schemaScope.CurrentItemWriter = new JTokenWriter();
+                    }
+
+                    schemaScope.CurrentItemWriter.WriteToken(_reader, false);
+
+                    // finished writing current item
+                    if (schemaScope.CurrentItemWriter.Top == 0 && _reader.TokenType != JsonToken.PropertyName)
+                    {
+                        JToken finishedItem = schemaScope.CurrentItemWriter.Token;
+
+                        // start next item with new writer
+                        schemaScope.CurrentItemWriter = null;
+
+                        if (isInUniqueArray)
+                        {
+                            if (schemaScope.UniqueArrayItems.Contains(finishedItem, JToken.EqualityComparer))
+                            {
+                                RaiseError("Non-unique array item at index {0}.".FormatWith(CultureInfo.InvariantCulture, schemaScope.ArrayItemCount - 1), schemaScope.Schemas.First(s => s.UniqueItems));
+                            }
+
+                            schemaScope.UniqueArrayItems.Add(finishedItem);
+                        }
+                        else if (schemas.Any(s => s.Enum != null))
+                        {
+                            foreach (JsonSchemaModel schema in schemas)
+                            {
+                                if (schema.Enum != null)
+                                {
+                                    if (!schema.Enum.ContainsValue(finishedItem, JToken.EqualityComparer))
+                                    {
+                                        StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
+                                        finishedItem.WriteTo(new JsonTextWriter(sw));
+
+                                        RaiseError("Value {0} is not defined in enum.".FormatWith(CultureInfo.InvariantCulture, sw.ToString()), schema);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void ValidateEndObject(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            Dictionary<string, bool> requiredProperties = _currentScope.RequiredProperties;
+
+            if (requiredProperties != null && requiredProperties.Values.Any(v => !v))
+            {
+                IEnumerable<string> unmatchedRequiredProperties = requiredProperties.Where(kv => !kv.Value).Select(kv => kv.Key);
+                RaiseError("Required properties are missing from object: {0}.".FormatWith(CultureInfo.InvariantCulture, string.Join(", ", unmatchedRequiredProperties
+#if !HAVE_STRING_JOIN_WITH_ENUMERABLE
+                    .ToArray()
+#endif
+                    )), schema);
+            }
+        }
+
+        private void ValidateEndArray(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            int arrayItemCount = _currentScope.ArrayItemCount;
+
+            if (schema.MaximumItems != null && arrayItemCount > schema.MaximumItems)
+            {
+                RaiseError("Array item count {0} exceeds maximum count of {1}.".FormatWith(CultureInfo.InvariantCulture, arrayItemCount, schema.MaximumItems), schema);
+            }
+
+            if (schema.MinimumItems != null && arrayItemCount < schema.MinimumItems)
+            {
+                RaiseError("Array item count {0} is less than minimum count of {1}.".FormatWith(CultureInfo.InvariantCulture, arrayItemCount, schema.MinimumItems), schema);
+            }
+        }
+
+        private void ValidateNull(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            if (!TestType(schema, JsonSchemaType.Null))
+            {
+                return;
+            }
+
+            ValidateNotDisallowed(schema);
+        }
+
+        private void ValidateBoolean(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            if (!TestType(schema, JsonSchemaType.Boolean))
+            {
+                return;
+            }
+
+            ValidateNotDisallowed(schema);
+        }
+
+        private void ValidateString(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            if (!TestType(schema, JsonSchemaType.String))
+            {
+                return;
+            }
+
+            ValidateNotDisallowed(schema);
+
+            string value = _reader.Value.ToString();
+
+            if (schema.MaximumLength != null && value.Length > schema.MaximumLength)
+            {
+                RaiseError("String '{0}' exceeds maximum length of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.MaximumLength), schema);
+            }
+
+            if (schema.MinimumLength != null && value.Length < schema.MinimumLength)
+            {
+                RaiseError("String '{0}' is less than minimum length of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.MinimumLength), schema);
+            }
+
+            if (schema.Patterns != null)
+            {
+                foreach (string pattern in schema.Patterns)
+                {
+                    if (!Regex.IsMatch(value, pattern))
+                    {
+                        RaiseError("String '{0}' does not match regex pattern '{1}'.".FormatWith(CultureInfo.InvariantCulture, value, pattern), schema);
+                    }
+                }
+            }
+        }
+
+        private void ValidateInteger(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            if (!TestType(schema, JsonSchemaType.Integer))
+            {
+                return;
+            }
+
+            ValidateNotDisallowed(schema);
+
+            object value = _reader.Value;
+
+            if (schema.Maximum != null)
+            {
+                if (JValue.Compare(JTokenType.Integer, value, schema.Maximum) > 0)
+                {
+                    RaiseError("Integer {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema);
+                }
+                if (schema.ExclusiveMaximum && JValue.Compare(JTokenType.Integer, value, schema.Maximum) == 0)
+                {
+                    RaiseError("Integer {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema);
+                }
+            }
+
+            if (schema.Minimum != null)
+            {
+                if (JValue.Compare(JTokenType.Integer, value, schema.Minimum) < 0)
+                {
+                    RaiseError("Integer {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema);
+                }
+                if (schema.ExclusiveMinimum && JValue.Compare(JTokenType.Integer, value, schema.Minimum) == 0)
+                {
+                    RaiseError("Integer {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema);
+                }
+            }
+
+            if (schema.DivisibleBy != null)
+            {
+                bool notDivisible;
+#if HAVE_BIG_INTEGER
+                if (value is BigInteger i)
+                {
+                    // not that this will lose any decimal point on DivisibleBy
+                    // so manually raise an error if DivisibleBy is not an integer and value is not zero
+                    bool divisibleNonInteger = !Math.Abs(schema.DivisibleBy.Value - Math.Truncate(schema.DivisibleBy.Value)).Equals(0);
+                    if (divisibleNonInteger)
+                    {
+                        notDivisible = i != 0;
+                    }
+                    else
+                    {
+                        notDivisible = i % new BigInteger(schema.DivisibleBy.Value) != 0;
+                    }
+                }
+                else
+#endif
+                {
+                    notDivisible = !IsZero(Convert.ToInt64(value, CultureInfo.InvariantCulture) % schema.DivisibleBy.GetValueOrDefault());
+                }
+
+                if (notDivisible)
+                {
+                    RaiseError("Integer {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.DivisibleBy), schema);
+                }
+            }
+        }
+
+        private void ProcessValue()
+        {
+            if (_currentScope != null && _currentScope.TokenType == JTokenType.Array)
+            {
+                _currentScope.ArrayItemCount++;
+
+                foreach (JsonSchemaModel currentSchema in CurrentSchemas)
+                {
+                    // if there is positional validation and the array index is past the number of item validation schemas and there are no additional items then error
+                    if (currentSchema != null
+                        && currentSchema.PositionalItemsValidation
+                        && !currentSchema.AllowAdditionalItems
+                        && (currentSchema.Items == null || _currentScope.ArrayItemCount - 1 >= currentSchema.Items.Count))
+                    {
+                        RaiseError("Index {0} has not been defined and the schema does not allow additional items.".FormatWith(CultureInfo.InvariantCulture, _currentScope.ArrayItemCount), currentSchema);
+                    }
+                }
+            }
+        }
+
+        private void ValidateFloat(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            if (!TestType(schema, JsonSchemaType.Float))
+            {
+                return;
+            }
+
+            ValidateNotDisallowed(schema);
+
+            double value = Convert.ToDouble(_reader.Value, CultureInfo.InvariantCulture);
+
+            if (schema.Maximum != null)
+            {
+                if (value > schema.Maximum)
+                {
+                    RaiseError("Float {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.Maximum), schema);
+                }
+                if (schema.ExclusiveMaximum && value == schema.Maximum)
+                {
+                    RaiseError("Float {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.Maximum), schema);
+                }
+            }
+
+            if (schema.Minimum != null)
+            {
+                if (value < schema.Minimum)
+                {
+                    RaiseError("Float {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.Minimum), schema);
+                }
+                if (schema.ExclusiveMinimum && value == schema.Minimum)
+                {
+                    RaiseError("Float {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.Minimum), schema);
+                }
+            }
+
+            if (schema.DivisibleBy != null)
+            {
+                double remainder = FloatingPointRemainder(value, schema.DivisibleBy.GetValueOrDefault());
+
+                if (!IsZero(remainder))
+                {
+                    RaiseError("Float {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.DivisibleBy), schema);
+                }
+            }
+        }
+
+        private static double FloatingPointRemainder(double dividend, double divisor)
+        {
+            return dividend - Math.Floor(dividend / divisor) * divisor;
+        }
+
+        private static bool IsZero(double value)
+        {
+            const double epsilon = 2.2204460492503131e-016;
+
+            return Math.Abs(value) < 20.0 * epsilon;
+        }
+
+        private void ValidatePropertyName(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return;
+            }
+
+            string propertyName = Convert.ToString(_reader.Value, CultureInfo.InvariantCulture);
+
+            if (_currentScope.RequiredProperties.ContainsKey(propertyName))
+            {
+                _currentScope.RequiredProperties[propertyName] = true;
+            }
+
+            if (!schema.AllowAdditionalProperties)
+            {
+                bool propertyDefinied = IsPropertyDefinied(schema, propertyName);
+
+                if (!propertyDefinied)
+                {
+                    RaiseError("Property '{0}' has not been defined and the schema does not allow additional properties.".FormatWith(CultureInfo.InvariantCulture, propertyName), schema);
+                }
+            }
+
+            _currentScope.CurrentPropertyName = propertyName;
+        }
+
+        private bool IsPropertyDefinied(JsonSchemaModel schema, string propertyName)
+        {
+            if (schema.Properties != null && schema.Properties.ContainsKey(propertyName))
+            {
+                return true;
+            }
+
+            if (schema.PatternProperties != null)
+            {
+                foreach (string pattern in schema.PatternProperties.Keys)
+                {
+                    if (Regex.IsMatch(propertyName, pattern))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private bool ValidateArray(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return true;
+            }
+
+            return (TestType(schema, JsonSchemaType.Array));
+        }
+
+        private bool ValidateObject(JsonSchemaModel schema)
+        {
+            if (schema == null)
+            {
+                return true;
+            }
+
+            return (TestType(schema, JsonSchemaType.Object));
+        }
+
+        private bool TestType(JsonSchemaModel currentSchema, JsonSchemaType currentType)
+        {
+            if (!JsonSchemaGenerator.HasFlag(currentSchema.Type, currentType))
+            {
+                RaiseError("Invalid type. Expected {0} but got {1}.".FormatWith(CultureInfo.InvariantCulture, currentSchema.Type, currentType), currentSchema);
+                return false;
+            }
+
+            return true;
+        }
+
+        bool IJsonLineInfo.HasLineInfo()
+        {
+            return _reader is IJsonLineInfo lineInfo && lineInfo.HasLineInfo();
+        }
+
+        int IJsonLineInfo.LineNumber => (_reader is IJsonLineInfo lineInfo) ? lineInfo.LineNumber : 0;
+
+        int IJsonLineInfo.LinePosition => (_reader is IJsonLineInfo lineInfo) ? lineInfo.LinePosition : 0;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonWriter.Async.cs b/Libs/Newtonsoft.Json/JsonWriter.Async.cs
new file mode 100644
index 0000000..bbeec12
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonWriter.Async.cs
@@ -0,0 +1,1797 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Globalization;
+using System.Threading;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json
+{
+    public abstract partial class JsonWriter
+    {
+        internal Task AutoCompleteAsync(JsonToken tokenBeingWritten, CancellationToken cancellationToken)
+        {
+            State oldState = _currentState;
+
+            // gets new state based on the current state and what is being written
+            State newState = StateArray[(int)tokenBeingWritten][(int)oldState];
+
+            if (newState == State.Error)
+            {
+                throw JsonWriterException.Create(this, "Token {0} in state {1} would result in an invalid JSON object.".FormatWith(CultureInfo.InvariantCulture, tokenBeingWritten.ToString(), oldState.ToString()), null);
+            }
+
+            _currentState = newState;
+
+            if (_formatting == Formatting.Indented)
+            {
+                switch (oldState)
+                {
+                    case State.Start:
+                        break;
+                    case State.Property:
+                        return WriteIndentSpaceAsync(cancellationToken);
+                    case State.ArrayStart:
+                    case State.ConstructorStart:
+                        return WriteIndentAsync(cancellationToken);
+                    case State.Array:
+                    case State.Constructor:
+                        return tokenBeingWritten == JsonToken.Comment ? WriteIndentAsync(cancellationToken) : AutoCompleteAsync(cancellationToken);
+                    case State.Object:
+                        switch (tokenBeingWritten)
+                        {
+                            case JsonToken.Comment:
+                                break;
+                            case JsonToken.PropertyName:
+                                return AutoCompleteAsync(cancellationToken);
+                            default:
+                                return WriteValueDelimiterAsync(cancellationToken);
+                        }
+
+                        break;
+                    default:
+                        if (tokenBeingWritten == JsonToken.PropertyName)
+                        {
+                            return WriteIndentAsync(cancellationToken);
+                        }
+
+                        break;
+                }
+            }
+            else if (tokenBeingWritten != JsonToken.Comment)
+            {
+                switch (oldState)
+                {
+                    case State.Object:
+                    case State.Array:
+                    case State.Constructor:
+                        return WriteValueDelimiterAsync(cancellationToken);
+                }
+            }
+
+            return AsyncUtils.CompletedTask;
+        }
+
+        private async Task AutoCompleteAsync(CancellationToken cancellationToken)
+        {
+            await WriteValueDelimiterAsync(cancellationToken).ConfigureAwait(false);
+            await WriteIndentAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously closes this writer.
+        /// If <see cref="JsonWriter.CloseOutput"/> is set to <c>true</c>, the destination is also closed.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task CloseAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            Close();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously flushes whatever is in the buffer to the destination and also flushes the destination.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task FlushAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            Flush();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the specified end token.
+        /// </summary>
+        /// <param name="token">The end token to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        protected virtual Task WriteEndAsync(JsonToken token, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteEnd(token);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes indent characters.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        protected virtual Task WriteIndentAsync(CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteIndent();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the JSON value delimiter.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        protected virtual Task WriteValueDelimiterAsync(CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValueDelimiter();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes an indent space.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        protected virtual Task WriteIndentSpaceAsync(CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteIndentSpace();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes raw JSON without changing the writer's state.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteRawAsync(string? json, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteRaw(json);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of the current JSON object or array.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteEndAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteEnd();
+            return AsyncUtils.CompletedTask;
+        }
+
+        internal Task WriteEndInternalAsync(CancellationToken cancellationToken)
+        {
+            JsonContainerType type = Peek();
+            switch (type)
+            {
+                case JsonContainerType.Object:
+                    return WriteEndObjectAsync(cancellationToken);
+                case JsonContainerType.Array:
+                    return WriteEndArrayAsync(cancellationToken);
+                case JsonContainerType.Constructor:
+                    return WriteEndConstructorAsync(cancellationToken);
+                default:
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        return cancellationToken.FromCanceled();
+                    }
+
+                    throw JsonWriterException.Create(this, "Unexpected type when writing end: " + type, null);
+            }
+        }
+
+        internal Task InternalWriteEndAsync(JsonContainerType type, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            int levelsToComplete = CalculateLevelsToComplete(type);
+            while (levelsToComplete-- > 0)
+            {
+                JsonToken token = GetCloseTokenForType(Pop());
+
+                Task t;
+                if (_currentState == State.Property)
+                {
+                    t = WriteNullAsync(cancellationToken);
+                    if (!t.IsCompletedSucessfully())
+                    {
+                        return AwaitProperty(t, levelsToComplete, token, cancellationToken);
+                    }
+                }
+
+                if (_formatting == Formatting.Indented)
+                {
+                    if (_currentState != State.ObjectStart && _currentState != State.ArrayStart)
+                    {
+                        t = WriteIndentAsync(cancellationToken);
+                        if (!t.IsCompletedSucessfully())
+                        {
+                            return AwaitIndent(t, levelsToComplete, token, cancellationToken);
+                        }
+                    }
+                }
+
+                t = WriteEndAsync(token, cancellationToken);
+                if (!t.IsCompletedSucessfully())
+                {
+                    return AwaitEnd(t, levelsToComplete, cancellationToken);
+                }
+
+                UpdateCurrentState();
+            }
+
+            return AsyncUtils.CompletedTask;
+
+            // Local functions, params renamed (capitalized) so as not to capture and allocate when calling async
+            async Task AwaitProperty(Task task, int LevelsToComplete, JsonToken token, CancellationToken CancellationToken)
+            {
+                await task.ConfigureAwait(false);
+
+                //  Finish current loop
+                if (_formatting == Formatting.Indented)
+                {
+                    if (_currentState != State.ObjectStart && _currentState != State.ArrayStart)
+                    {
+                        await WriteIndentAsync(CancellationToken).ConfigureAwait(false);
+                    }
+                }
+
+                await WriteEndAsync(token, CancellationToken).ConfigureAwait(false);
+
+                UpdateCurrentState();
+
+                await AwaitRemaining(LevelsToComplete, CancellationToken).ConfigureAwait(false);
+            }
+
+            async Task AwaitIndent(Task task, int LevelsToComplete, JsonToken token, CancellationToken CancellationToken)
+            {
+                await task.ConfigureAwait(false);
+
+                //  Finish current loop
+
+                await WriteEndAsync(token, CancellationToken).ConfigureAwait(false);
+
+                UpdateCurrentState();
+
+                await AwaitRemaining(LevelsToComplete, CancellationToken).ConfigureAwait(false);
+            }
+
+            async Task AwaitEnd(Task task, int LevelsToComplete, CancellationToken CancellationToken)
+            {
+                await task.ConfigureAwait(false);
+
+                //  Finish current loop
+
+                UpdateCurrentState();
+
+                await AwaitRemaining(LevelsToComplete, CancellationToken).ConfigureAwait(false);
+            }
+
+            async Task AwaitRemaining(int LevelsToComplete, CancellationToken CancellationToken)
+            {
+                while (LevelsToComplete-- > 0)
+                {
+                    JsonToken token = GetCloseTokenForType(Pop());
+
+                    if (_currentState == State.Property)
+                    {
+                        await WriteNullAsync(CancellationToken).ConfigureAwait(false);
+                    }
+
+                    if (_formatting == Formatting.Indented)
+                    {
+                        if (_currentState != State.ObjectStart && _currentState != State.ArrayStart)
+                        {
+                            await WriteIndentAsync(CancellationToken).ConfigureAwait(false);
+                        }
+                    }
+
+                    await WriteEndAsync(token, CancellationToken).ConfigureAwait(false);
+
+                    UpdateCurrentState();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of an array.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteEndArrayAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteEndArray();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of a constructor.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteEndConstructorAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteEndConstructor();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the end of a JSON object.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteEndObjectAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteEndObject();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a null value.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteNullAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteNull();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the property name of a name/value pair of a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WritePropertyNameAsync(string name, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WritePropertyName(name);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the property name of a name/value pair of a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        /// <param name="escape">A flag to indicate whether the text should be escaped when it is written as a JSON property name.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WritePropertyNameAsync(string name, bool escape, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WritePropertyName(name, escape);
+            return AsyncUtils.CompletedTask;
+        }
+
+        internal Task InternalWritePropertyNameAsync(string name, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            _currentPosition.PropertyName = name;
+            return AutoCompleteAsync(JsonToken.PropertyName, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the beginning of a JSON array.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteStartArrayAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteStartArray();
+            return AsyncUtils.CompletedTask;
+        }
+
+        internal async Task InternalWriteStartAsync(JsonToken token, JsonContainerType container, CancellationToken cancellationToken)
+        {
+            UpdateScopeWithFinishedValue();
+            await AutoCompleteAsync(token, cancellationToken).ConfigureAwait(false);
+            Push(container);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a comment <c>/*...*/</c> containing the specified text.
+        /// </summary>
+        /// <param name="text">Text to place inside the comment.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteCommentAsync(string? text, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteComment(text);
+            return AsyncUtils.CompletedTask;
+        }
+
+        internal Task InternalWriteCommentAsync(CancellationToken cancellationToken)
+        {
+            return AutoCompleteAsync(JsonToken.Comment, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes raw JSON where a value is expected and updates the writer's state.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteRawValueAsync(string? json, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteRawValue(json);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the start of a constructor with the given name.
+        /// </summary>
+        /// <param name="name">The name of the constructor.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteStartConstructorAsync(string name, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteStartConstructor(name);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the beginning of a JSON object.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteStartObjectAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteStartObject();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the current <see cref="JsonReader"/> token.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read the token from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public Task WriteTokenAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            return WriteTokenAsync(reader, true, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the current <see cref="JsonReader"/> token.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read the token from.</param>
+        /// <param name="writeChildren">A flag indicating whether the current token's children should be written.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public Task WriteTokenAsync(JsonReader reader, bool writeChildren, CancellationToken cancellationToken = default)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            return WriteTokenAsync(reader, writeChildren, true, true, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="JsonToken"/> token and its value.
+        /// </summary>
+        /// <param name="token">The <see cref="JsonToken"/> to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public Task WriteTokenAsync(JsonToken token, CancellationToken cancellationToken = default)
+        {
+            return WriteTokenAsync(token, null, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously writes the <see cref="JsonToken"/> token and its value.
+        /// </summary>
+        /// <param name="token">The <see cref="JsonToken"/> to write.</param>
+        /// <param name="value">
+        /// The value to write.
+        /// A value is only required for tokens that have an associated value, e.g. the <see cref="String"/> property name for <see cref="JsonToken.PropertyName"/>.
+        /// <c>null</c> can be passed to the method for tokens that don't have a value, e.g. <see cref="JsonToken.StartObject"/>.
+        /// </param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public Task WriteTokenAsync(JsonToken token, object? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            switch (token)
+            {
+                case JsonToken.None:
+                    // read to next
+                    return AsyncUtils.CompletedTask;
+                case JsonToken.StartObject:
+                    return WriteStartObjectAsync(cancellationToken);
+                case JsonToken.StartArray:
+                    return WriteStartArrayAsync(cancellationToken);
+                case JsonToken.StartConstructor:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    return WriteStartConstructorAsync(value.ToString(), cancellationToken);
+                case JsonToken.PropertyName:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    return WritePropertyNameAsync(value.ToString(), cancellationToken);
+                case JsonToken.Comment:
+                    return WriteCommentAsync(value?.ToString(), cancellationToken);
+                case JsonToken.Integer:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    return
+#if HAVE_BIG_INTEGER
+                        value is BigInteger integer ? WriteValueAsync(integer, cancellationToken) :
+#endif
+                        WriteValueAsync(Convert.ToInt64(value, CultureInfo.InvariantCulture), cancellationToken);
+                case JsonToken.Float:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    if (value is decimal dec)
+                    {
+                        return WriteValueAsync(dec, cancellationToken);
+                    }
+
+                    if (value is double doub)
+                    {
+                        return WriteValueAsync(doub, cancellationToken);
+                    }
+
+                    if (value is float f)
+                    {
+                        return WriteValueAsync(f, cancellationToken);
+                    }
+
+                    return WriteValueAsync(Convert.ToDouble(value, CultureInfo.InvariantCulture), cancellationToken);
+                case JsonToken.String:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    return WriteValueAsync(value.ToString(), cancellationToken);
+                case JsonToken.Boolean:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    return WriteValueAsync(Convert.ToBoolean(value, CultureInfo.InvariantCulture), cancellationToken);
+                case JsonToken.Null:
+                    return WriteNullAsync(cancellationToken);
+                case JsonToken.Undefined:
+                    return WriteUndefinedAsync(cancellationToken);
+                case JsonToken.EndObject:
+                    return WriteEndObjectAsync(cancellationToken);
+                case JsonToken.EndArray:
+                    return WriteEndArrayAsync(cancellationToken);
+                case JsonToken.EndConstructor:
+                    return WriteEndConstructorAsync(cancellationToken);
+                case JsonToken.Date:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    if (value is DateTimeOffset offset)
+                    {
+                        return WriteValueAsync(offset, cancellationToken);
+                    }
+
+                    return WriteValueAsync(Convert.ToDateTime(value, CultureInfo.InvariantCulture), cancellationToken);
+                case JsonToken.Raw:
+                    return WriteRawValueAsync(value?.ToString(), cancellationToken);
+                case JsonToken.Bytes:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    if (value is Guid guid)
+                    {
+                        return WriteValueAsync(guid, cancellationToken);
+                    }
+
+                    return WriteValueAsync((byte[]?)value, cancellationToken);
+                default:
+                    throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(token), token, "Unexpected token type.");
+            }
+        }
+
+        internal virtual async Task WriteTokenAsync(JsonReader reader, bool writeChildren, bool writeDateConstructorAsDate, bool writeComments, CancellationToken cancellationToken)
+        {
+            int initialDepth = CalculateWriteTokenInitialDepth(reader);
+
+            do
+            {
+                // write a JValue date when the constructor is for a date
+                if (writeDateConstructorAsDate && reader.TokenType == JsonToken.StartConstructor && string.Equals(reader.Value?.ToString(), "Date", StringComparison.Ordinal))
+                {
+                    await WriteConstructorDateAsync(reader, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    if (writeComments || reader.TokenType != JsonToken.Comment)
+                    {
+                        await WriteTokenAsync(reader.TokenType, reader.Value, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+            } while (
+                // stop if we have reached the end of the token being read
+                initialDepth - 1 < reader.Depth - (JsonTokenUtils.IsEndToken(reader.TokenType) ? 1 : 0)
+                && writeChildren
+                && await reader.ReadAsync(cancellationToken).ConfigureAwait(false));
+
+            if (IsWriteTokenIncomplete(reader, writeChildren, initialDepth))
+            {
+                throw JsonWriterException.Create(this, "Unexpected end when reading token.", null);
+            }
+        }
+
+        // For internal use, when we know the writer does not offer true async support (e.g. when backed
+        // by a StringWriter) and therefore async write methods are always in practice just a less efficient
+        // path through the sync version.
+        internal async Task WriteTokenSyncReadingAsync(JsonReader reader, CancellationToken cancellationToken)
+        {
+            int initialDepth = CalculateWriteTokenInitialDepth(reader);
+
+            do
+            {
+                // write a JValue date when the constructor is for a date
+                if (reader.TokenType == JsonToken.StartConstructor && string.Equals(reader.Value?.ToString(), "Date", StringComparison.Ordinal))
+                {
+                    WriteConstructorDate(reader);
+                }
+                else
+                {
+                    WriteToken(reader.TokenType, reader.Value);
+                }
+            } while (
+                // stop if we have reached the end of the token being read
+                initialDepth - 1 < reader.Depth - (JsonTokenUtils.IsEndToken(reader.TokenType) ? 1 : 0)
+                && await reader.ReadAsync(cancellationToken).ConfigureAwait(false));
+
+            if (initialDepth < CalculateWriteTokenFinalDepth(reader))
+            {
+                throw JsonWriterException.Create(this, "Unexpected end when reading token.", null);
+            }
+        }
+
+        private async Task WriteConstructorDateAsync(JsonReader reader, CancellationToken cancellationToken)
+        {
+            if (!await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
+            {
+                throw JsonWriterException.Create(this, "Unexpected end when reading date constructor.", null);
+            }
+            if (reader.TokenType != JsonToken.Integer)
+            {
+                throw JsonWriterException.Create(this, "Unexpected token when reading date constructor. Expected Integer, got " + reader.TokenType, null);
+            }
+
+            DateTime date = DateTimeUtils.ConvertJavaScriptTicksToDateTime((long)reader.Value!);
+
+            if (!await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
+            {
+                throw JsonWriterException.Create(this, "Unexpected end when reading date constructor.", null);
+            }
+            if (reader.TokenType != JsonToken.EndConstructor)
+            {
+                throw JsonWriterException.Create(this, "Unexpected token when reading date constructor. Expected EndConstructor, got " + reader.TokenType, null);
+            }
+
+            await WriteValueAsync(date, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="bool"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="bool"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(bool value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="bool"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="bool"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(bool? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="byte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(byte value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="byte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(byte? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="byte"/>[] value.
+        /// </summary>
+        /// <param name="value">The <see cref="byte"/>[] value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(byte[]? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="char"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(char value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="char"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(char? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(DateTime value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="DateTime"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(DateTime? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTimeOffset"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(DateTimeOffset value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(DateTimeOffset? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="decimal"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(decimal value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="decimal"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(decimal? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="double"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(double value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="double"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(double? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="float"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="float"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(float value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="float"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="float"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(float? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Guid"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(Guid value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Guid"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(Guid? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="int"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="int"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(int value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="int"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="int"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(int? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="long"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="long"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(long value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="long"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="long"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(long? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="object"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="object"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(object? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="sbyte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="sbyte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(sbyte value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="sbyte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="sbyte"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(sbyte? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="short"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="short"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(short value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="short"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="short"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(short? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="string"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="string"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(string? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="TimeSpan"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(TimeSpan value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="TimeSpan"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(TimeSpan? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="uint"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="uint"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(uint value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="uint"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="uint"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(uint? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="ulong"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="ulong"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(ulong value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="ulong"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="ulong"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(ulong? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Uri"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Uri"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteValueAsync(Uri? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="ushort"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="ushort"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(ushort value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes a <see cref="Nullable{T}"/> of <see cref="ushort"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="ushort"/> value to write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        [CLSCompliant(false)]
+        public virtual Task WriteValueAsync(ushort? value, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteValue(value);
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes an undefined value.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteUndefinedAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteUndefined();
+            return AsyncUtils.CompletedTask;
+        }
+
+        /// <summary>
+        /// Asynchronously writes the given white space.
+        /// </summary>
+        /// <param name="ws">The string of white space characters.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        public virtual Task WriteWhitespaceAsync(string ws, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            WriteWhitespace(ws);
+            return AsyncUtils.CompletedTask;
+        }
+
+        internal Task InternalWriteValueAsync(JsonToken token, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            UpdateScopeWithFinishedValue();
+            return AutoCompleteAsync(token, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously ets the state of the <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="token">The <see cref="JsonToken"/> being written.</param>
+        /// <param name="value">The value being written.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+        /// <remarks>The default behaviour is to execute synchronously, returning an already-completed task. Derived
+        /// classes can override this behaviour for true asynchronicity.</remarks>
+        protected Task SetWriteStateAsync(JsonToken token, object value, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            switch (token)
+            {
+                case JsonToken.StartObject:
+                    return InternalWriteStartAsync(token, JsonContainerType.Object, cancellationToken);
+                case JsonToken.StartArray:
+                    return InternalWriteStartAsync(token, JsonContainerType.Array, cancellationToken);
+                case JsonToken.StartConstructor:
+                    return InternalWriteStartAsync(token, JsonContainerType.Constructor, cancellationToken);
+                case JsonToken.PropertyName:
+                    if (!(value is string s))
+                    {
+                        throw new ArgumentException("A name is required when setting property name state.", nameof(value));
+                    }
+
+                    return InternalWritePropertyNameAsync(s, cancellationToken);
+                case JsonToken.Comment:
+                    return InternalWriteCommentAsync(cancellationToken);
+                case JsonToken.Raw:
+                    return AsyncUtils.CompletedTask;
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.String:
+                case JsonToken.Boolean:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                case JsonToken.Null:
+                case JsonToken.Undefined:
+                    return InternalWriteValueAsync(token, cancellationToken);
+                case JsonToken.EndObject:
+                    return InternalWriteEndAsync(JsonContainerType.Object, cancellationToken);
+                case JsonToken.EndArray:
+                    return InternalWriteEndAsync(JsonContainerType.Array, cancellationToken);
+                case JsonToken.EndConstructor:
+                    return InternalWriteEndAsync(JsonContainerType.Constructor, cancellationToken);
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(token));
+            }
+        }
+
+        internal static Task WriteValueAsync(JsonWriter writer, PrimitiveTypeCode typeCode, object value, CancellationToken cancellationToken)
+        {
+            while (true)
+            {
+                switch (typeCode)
+                {
+                    case PrimitiveTypeCode.Char:
+                        return writer.WriteValueAsync((char)value, cancellationToken);
+                    case PrimitiveTypeCode.CharNullable:
+                        return writer.WriteValueAsync(value == null ? (char?)null : (char)value, cancellationToken);
+                    case PrimitiveTypeCode.Boolean:
+                        return writer.WriteValueAsync((bool)value, cancellationToken);
+                    case PrimitiveTypeCode.BooleanNullable:
+                        return writer.WriteValueAsync(value == null ? (bool?)null : (bool)value, cancellationToken);
+                    case PrimitiveTypeCode.SByte:
+                        return writer.WriteValueAsync((sbyte)value, cancellationToken);
+                    case PrimitiveTypeCode.SByteNullable:
+                        return writer.WriteValueAsync(value == null ? (sbyte?)null : (sbyte)value, cancellationToken);
+                    case PrimitiveTypeCode.Int16:
+                        return writer.WriteValueAsync((short)value, cancellationToken);
+                    case PrimitiveTypeCode.Int16Nullable:
+                        return writer.WriteValueAsync(value == null ? (short?)null : (short)value, cancellationToken);
+                    case PrimitiveTypeCode.UInt16:
+                        return writer.WriteValueAsync((ushort)value, cancellationToken);
+                    case PrimitiveTypeCode.UInt16Nullable:
+                        return writer.WriteValueAsync(value == null ? (ushort?)null : (ushort)value, cancellationToken);
+                    case PrimitiveTypeCode.Int32:
+                        return writer.WriteValueAsync((int)value, cancellationToken);
+                    case PrimitiveTypeCode.Int32Nullable:
+                        return writer.WriteValueAsync(value == null ? (int?)null : (int)value, cancellationToken);
+                    case PrimitiveTypeCode.Byte:
+                        return writer.WriteValueAsync((byte)value, cancellationToken);
+                    case PrimitiveTypeCode.ByteNullable:
+                        return writer.WriteValueAsync(value == null ? (byte?)null : (byte)value, cancellationToken);
+                    case PrimitiveTypeCode.UInt32:
+                        return writer.WriteValueAsync((uint)value, cancellationToken);
+                    case PrimitiveTypeCode.UInt32Nullable:
+                        return writer.WriteValueAsync(value == null ? (uint?)null : (uint)value, cancellationToken);
+                    case PrimitiveTypeCode.Int64:
+                        return writer.WriteValueAsync((long)value, cancellationToken);
+                    case PrimitiveTypeCode.Int64Nullable:
+                        return writer.WriteValueAsync(value == null ? (long?)null : (long)value, cancellationToken);
+                    case PrimitiveTypeCode.UInt64:
+                        return writer.WriteValueAsync((ulong)value, cancellationToken);
+                    case PrimitiveTypeCode.UInt64Nullable:
+                        return writer.WriteValueAsync(value == null ? (ulong?)null : (ulong)value, cancellationToken);
+                    case PrimitiveTypeCode.Single:
+                        return writer.WriteValueAsync((float)value, cancellationToken);
+                    case PrimitiveTypeCode.SingleNullable:
+                        return writer.WriteValueAsync(value == null ? (float?)null : (float)value, cancellationToken);
+                    case PrimitiveTypeCode.Double:
+                        return writer.WriteValueAsync((double)value, cancellationToken);
+                    case PrimitiveTypeCode.DoubleNullable:
+                        return writer.WriteValueAsync(value == null ? (double?)null : (double)value, cancellationToken);
+                    case PrimitiveTypeCode.DateTime:
+                        return writer.WriteValueAsync((DateTime)value, cancellationToken);
+                    case PrimitiveTypeCode.DateTimeNullable:
+                        return writer.WriteValueAsync(value == null ? (DateTime?)null : (DateTime)value, cancellationToken);
+                    case PrimitiveTypeCode.DateTimeOffset:
+                        return writer.WriteValueAsync((DateTimeOffset)value, cancellationToken);
+                    case PrimitiveTypeCode.DateTimeOffsetNullable:
+                        return writer.WriteValueAsync(value == null ? (DateTimeOffset?)null : (DateTimeOffset)value, cancellationToken);
+                    case PrimitiveTypeCode.Decimal:
+                        return writer.WriteValueAsync((decimal)value, cancellationToken);
+                    case PrimitiveTypeCode.DecimalNullable:
+                        return writer.WriteValueAsync(value == null ? (decimal?)null : (decimal)value, cancellationToken);
+                    case PrimitiveTypeCode.Guid:
+                        return writer.WriteValueAsync((Guid)value, cancellationToken);
+                    case PrimitiveTypeCode.GuidNullable:
+                        return writer.WriteValueAsync(value == null ? (Guid?)null : (Guid)value, cancellationToken);
+                    case PrimitiveTypeCode.TimeSpan:
+                        return writer.WriteValueAsync((TimeSpan)value, cancellationToken);
+                    case PrimitiveTypeCode.TimeSpanNullable:
+                        return writer.WriteValueAsync(value == null ? (TimeSpan?)null : (TimeSpan)value, cancellationToken);
+#if HAVE_BIG_INTEGER
+                    case PrimitiveTypeCode.BigInteger:
+
+                        // this will call to WriteValueAsync(object)
+                        return writer.WriteValueAsync((BigInteger)value, cancellationToken);
+                    case PrimitiveTypeCode.BigIntegerNullable:
+
+                        // this will call to WriteValueAsync(object)
+                        return writer.WriteValueAsync(value == null ? (BigInteger?)null : (BigInteger)value, cancellationToken);
+#endif
+                    case PrimitiveTypeCode.Uri:
+                        return writer.WriteValueAsync((Uri)value, cancellationToken);
+                    case PrimitiveTypeCode.String:
+                        return writer.WriteValueAsync((string)value, cancellationToken);
+                    case PrimitiveTypeCode.Bytes:
+                        return writer.WriteValueAsync((byte[])value, cancellationToken);
+#if HAVE_DB_NULL_TYPE_CODE
+                    case PrimitiveTypeCode.DBNull:
+                        return writer.WriteNullAsync(cancellationToken);
+#endif
+                    default:
+#if HAVE_ICONVERTIBLE
+                        if (value is IConvertible convertible)
+                        {
+                            ResolveConvertibleValue(convertible, out typeCode, out value);
+                            continue;
+                        }
+#endif
+
+                        // write an unknown null value, fix https://github.com/JamesNK/Newtonsoft.Json/issues/1460
+                        if (value == null)
+                        {
+                            return writer.WriteNullAsync(cancellationToken);
+                        }
+
+                        throw CreateUnsupportedTypeException(writer, value);
+                }
+            }
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/JsonWriter.cs b/Libs/Newtonsoft.Json/JsonWriter.cs
new file mode 100644
index 0000000..3149fb4
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonWriter.cs
@@ -0,0 +1,1789 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data.
+    /// </summary>
+    public abstract partial class JsonWriter : IDisposable
+    {
+        internal enum State
+        {
+            Start = 0,
+            Property = 1,
+            ObjectStart = 2,
+            Object = 3,
+            ArrayStart = 4,
+            Array = 5,
+            ConstructorStart = 6,
+            Constructor = 7,
+            Closed = 8,
+            Error = 9
+        }
+
+        // array that gives a new state based on the current state an the token being written
+        private static readonly State[][] StateArray;
+
+        internal static readonly State[][] StateArrayTemplate = new[]
+        {
+            //                                      Start                    PropertyName            ObjectStart         Object            ArrayStart              Array                   ConstructorStart        Constructor             Closed       Error
+            //
+            /* None                        */new[] { State.Error,            State.Error,            State.Error,        State.Error,      State.Error,            State.Error,            State.Error,            State.Error,            State.Error, State.Error },
+            /* StartObject                 */new[] { State.ObjectStart,      State.ObjectStart,      State.Error,        State.Error,      State.ObjectStart,      State.ObjectStart,      State.ObjectStart,      State.ObjectStart,      State.Error, State.Error },
+            /* StartArray                  */new[] { State.ArrayStart,       State.ArrayStart,       State.Error,        State.Error,      State.ArrayStart,       State.ArrayStart,       State.ArrayStart,       State.ArrayStart,       State.Error, State.Error },
+            /* StartConstructor            */new[] { State.ConstructorStart, State.ConstructorStart, State.Error,        State.Error,      State.ConstructorStart, State.ConstructorStart, State.ConstructorStart, State.ConstructorStart, State.Error, State.Error },
+            /* Property                    */new[] { State.Property,         State.Error,            State.Property,     State.Property,   State.Error,            State.Error,            State.Error,            State.Error,            State.Error, State.Error },
+            /* Comment                     */new[] { State.Start,            State.Property,         State.ObjectStart,  State.Object,     State.ArrayStart,       State.Array,            State.Constructor,      State.Constructor,      State.Error, State.Error },
+            /* Raw                         */new[] { State.Start,            State.Property,         State.ObjectStart,  State.Object,     State.ArrayStart,       State.Array,            State.Constructor,      State.Constructor,      State.Error, State.Error },
+            /* Value (this will be copied) */new[] { State.Start,            State.Object,           State.Error,        State.Error,      State.Array,            State.Array,            State.Constructor,      State.Constructor,      State.Error, State.Error }
+        };
+
+        internal static State[][] BuildStateArray()
+        {
+            List<State[]> allStates = StateArrayTemplate.ToList();
+            State[] errorStates = StateArrayTemplate[0];
+            State[] valueStates = StateArrayTemplate[7];
+
+            EnumInfo enumValuesAndNames = EnumUtils.GetEnumValuesAndNames(typeof(JsonToken));
+
+            foreach (ulong valueToken in enumValuesAndNames.Values)
+            {
+                if (allStates.Count <= (int)valueToken)
+                {
+                    JsonToken token = (JsonToken)valueToken;
+                    switch (token)
+                    {
+                        case JsonToken.Integer:
+                        case JsonToken.Float:
+                        case JsonToken.String:
+                        case JsonToken.Boolean:
+                        case JsonToken.Null:
+                        case JsonToken.Undefined:
+                        case JsonToken.Date:
+                        case JsonToken.Bytes:
+                            allStates.Add(valueStates);
+                            break;
+                        default:
+                            allStates.Add(errorStates);
+                            break;
+                    }
+                }
+            }
+
+            return allStates.ToArray();
+        }
+
+        static JsonWriter()
+        {
+            StateArray = BuildStateArray();
+        }
+
+        private List<JsonPosition>? _stack;
+        private JsonPosition _currentPosition;
+        private State _currentState;
+        private Formatting _formatting;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the destination should be closed when this writer is closed.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> to close the destination when this writer is closed; otherwise <c>false</c>. The default is <c>true</c>.
+        /// </value>
+        public bool CloseOutput { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the JSON should be auto-completed when this writer is closed.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> to auto-complete the JSON when this writer is closed; otherwise <c>false</c>. The default is <c>true</c>.
+        /// </value>
+        public bool AutoCompleteOnClose { get; set; }
+
+        /// <summary>
+        /// Gets the top.
+        /// </summary>
+        /// <value>The top.</value>
+        protected internal int Top
+        {
+            get
+            {
+                int depth = _stack?.Count ?? 0;
+                if (Peek() != JsonContainerType.None)
+                {
+                    depth++;
+                }
+
+                return depth;
+            }
+        }
+
+        /// <summary>
+        /// Gets the state of the writer.
+        /// </summary>
+        public WriteState WriteState
+        {
+            get
+            {
+                switch (_currentState)
+                {
+                    case State.Error:
+                        return WriteState.Error;
+                    case State.Closed:
+                        return WriteState.Closed;
+                    case State.Object:
+                    case State.ObjectStart:
+                        return WriteState.Object;
+                    case State.Array:
+                    case State.ArrayStart:
+                        return WriteState.Array;
+                    case State.Constructor:
+                    case State.ConstructorStart:
+                        return WriteState.Constructor;
+                    case State.Property:
+                        return WriteState.Property;
+                    case State.Start:
+                        return WriteState.Start;
+                    default:
+                        throw JsonWriterException.Create(this, "Invalid state: " + _currentState, null);
+                }
+            }
+        }
+
+        internal string ContainerPath
+        {
+            get
+            {
+                if (_currentPosition.Type == JsonContainerType.None || _stack == null)
+                {
+                    return string.Empty;
+                }
+
+                return JsonPosition.BuildPath(_stack, null);
+            }
+        }
+
+        /// <summary>
+        /// Gets the path of the writer. 
+        /// </summary>
+        public string Path
+        {
+            get
+            {
+                if (_currentPosition.Type == JsonContainerType.None)
+                {
+                    return string.Empty;
+                }
+
+                bool insideContainer = (_currentState != State.ArrayStart
+                                        && _currentState != State.ConstructorStart
+                                        && _currentState != State.ObjectStart);
+
+                JsonPosition? current = insideContainer ? (JsonPosition?)_currentPosition : null;
+
+                return JsonPosition.BuildPath(_stack!, current);
+            }
+        }
+
+        private DateFormatHandling _dateFormatHandling;
+        private DateTimeZoneHandling _dateTimeZoneHandling;
+        private StringEscapeHandling _stringEscapeHandling;
+        private FloatFormatHandling _floatFormatHandling;
+        private string? _dateFormatString;
+        private CultureInfo? _culture;
+
+        /// <summary>
+        /// Gets or sets a value indicating how JSON text output should be formatted.
+        /// </summary>
+        public Formatting Formatting
+        {
+            get => _formatting;
+            set
+            {
+                if (value < Formatting.None || value > Formatting.Indented)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _formatting = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how dates are written to JSON text.
+        /// </summary>
+        public DateFormatHandling DateFormatHandling
+        {
+            get => _dateFormatHandling;
+            set
+            {
+                if (value < DateFormatHandling.IsoDateFormat || value > DateFormatHandling.MicrosoftDateFormat)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _dateFormatHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how <see cref="DateTime"/> time zones are handled when writing JSON text.
+        /// </summary>
+        public DateTimeZoneHandling DateTimeZoneHandling
+        {
+            get => _dateTimeZoneHandling;
+            set
+            {
+                if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _dateTimeZoneHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how strings are escaped when writing JSON text.
+        /// </summary>
+        public StringEscapeHandling StringEscapeHandling
+        {
+            get => _stringEscapeHandling;
+            set
+            {
+                if (value < StringEscapeHandling.Default || value > StringEscapeHandling.EscapeHtml)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _stringEscapeHandling = value;
+                OnStringEscapeHandlingChanged();
+            }
+        }
+
+        internal virtual void OnStringEscapeHandlingChanged()
+        {
+            // hacky but there is a calculated value that relies on StringEscapeHandling
+        }
+
+        /// <summary>
+        /// Gets or sets how special floating point numbers, e.g. <see cref="Double.NaN"/>,
+        /// <see cref="Double.PositiveInfinity"/> and <see cref="Double.NegativeInfinity"/>,
+        /// are written to JSON text.
+        /// </summary>
+        public FloatFormatHandling FloatFormatHandling
+        {
+            get => _floatFormatHandling;
+            set
+            {
+                if (value < FloatFormatHandling.String || value > FloatFormatHandling.DefaultValue)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _floatFormatHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how <see cref="DateTime"/> and <see cref="DateTimeOffset"/> values are formatted when writing JSON text.
+        /// </summary>
+        public string? DateFormatString
+        {
+            get => _dateFormatString;
+            set => _dateFormatString = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the culture used when writing JSON. Defaults to <see cref="CultureInfo.InvariantCulture"/>.
+        /// </summary>
+        public CultureInfo Culture
+        {
+            get => _culture ?? CultureInfo.InvariantCulture;
+            set => _culture = value;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonWriter"/> class.
+        /// </summary>
+        protected JsonWriter()
+        {
+            _currentState = State.Start;
+            _formatting = Formatting.None;
+            _dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
+
+            CloseOutput = true;
+            AutoCompleteOnClose = true;
+        }
+
+        internal void UpdateScopeWithFinishedValue()
+        {
+            if (_currentPosition.HasIndex)
+            {
+                _currentPosition.Position++;
+            }
+        }
+
+        private void Push(JsonContainerType value)
+        {
+            if (_currentPosition.Type != JsonContainerType.None)
+            {
+                if (_stack == null)
+                {
+                    _stack = new List<JsonPosition>();
+                }
+
+                _stack.Add(_currentPosition);
+            }
+
+            _currentPosition = new JsonPosition(value);
+        }
+
+        private JsonContainerType Pop()
+        {
+            JsonPosition oldPosition = _currentPosition;
+
+            if (_stack != null && _stack.Count > 0)
+            {
+                _currentPosition = _stack[_stack.Count - 1];
+                _stack.RemoveAt(_stack.Count - 1);
+            }
+            else
+            {
+                _currentPosition = new JsonPosition();
+            }
+
+            return oldPosition.Type;
+        }
+
+        private JsonContainerType Peek()
+        {
+            return _currentPosition.Type;
+        }
+
+        /// <summary>
+        /// Flushes whatever is in the buffer to the destination and also flushes the destination.
+        /// </summary>
+        public abstract void Flush();
+
+        /// <summary>
+        /// Closes this writer.
+        /// If <see cref="CloseOutput"/> is set to <c>true</c>, the destination is also closed.
+        /// If <see cref="AutoCompleteOnClose"/> is set to <c>true</c>, the JSON is auto-completed.
+        /// </summary>
+        public virtual void Close()
+        {
+            if (AutoCompleteOnClose)
+            {
+                AutoCompleteAll();
+            }
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON object.
+        /// </summary>
+        public virtual void WriteStartObject()
+        {
+            InternalWriteStart(JsonToken.StartObject, JsonContainerType.Object);
+        }
+
+        /// <summary>
+        /// Writes the end of a JSON object.
+        /// </summary>
+        public virtual void WriteEndObject()
+        {
+            InternalWriteEnd(JsonContainerType.Object);
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON array.
+        /// </summary>
+        public virtual void WriteStartArray()
+        {
+            InternalWriteStart(JsonToken.StartArray, JsonContainerType.Array);
+        }
+
+        /// <summary>
+        /// Writes the end of an array.
+        /// </summary>
+        public virtual void WriteEndArray()
+        {
+            InternalWriteEnd(JsonContainerType.Array);
+        }
+
+        /// <summary>
+        /// Writes the start of a constructor with the given name.
+        /// </summary>
+        /// <param name="name">The name of the constructor.</param>
+        public virtual void WriteStartConstructor(string name)
+        {
+            InternalWriteStart(JsonToken.StartConstructor, JsonContainerType.Constructor);
+        }
+
+        /// <summary>
+        /// Writes the end constructor.
+        /// </summary>
+        public virtual void WriteEndConstructor()
+        {
+            InternalWriteEnd(JsonContainerType.Constructor);
+        }
+
+        /// <summary>
+        /// Writes the property name of a name/value pair of a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        public virtual void WritePropertyName(string name)
+        {
+            InternalWritePropertyName(name);
+        }
+
+        /// <summary>
+        /// Writes the property name of a name/value pair of a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        /// <param name="escape">A flag to indicate whether the text should be escaped when it is written as a JSON property name.</param>
+        public virtual void WritePropertyName(string name, bool escape)
+        {
+            WritePropertyName(name);
+        }
+
+        /// <summary>
+        /// Writes the end of the current JSON object or array.
+        /// </summary>
+        public virtual void WriteEnd()
+        {
+            WriteEnd(Peek());
+        }
+
+        /// <summary>
+        /// Writes the current <see cref="JsonReader"/> token and its children.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read the token from.</param>
+        public void WriteToken(JsonReader reader)
+        {
+            WriteToken(reader, true);
+        }
+
+        /// <summary>
+        /// Writes the current <see cref="JsonReader"/> token.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read the token from.</param>
+        /// <param name="writeChildren">A flag indicating whether the current token's children should be written.</param>
+        public void WriteToken(JsonReader reader, bool writeChildren)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            WriteToken(reader, writeChildren, true, true);
+        }
+
+        /// <summary>
+        /// Writes the <see cref="JsonToken"/> token and its value.
+        /// </summary>
+        /// <param name="token">The <see cref="JsonToken"/> to write.</param>
+        /// <param name="value">
+        /// The value to write.
+        /// A value is only required for tokens that have an associated value, e.g. the <see cref="String"/> property name for <see cref="JsonToken.PropertyName"/>.
+        /// <c>null</c> can be passed to the method for tokens that don't have a value, e.g. <see cref="JsonToken.StartObject"/>.
+        /// </param>
+        public void WriteToken(JsonToken token, object? value)
+        {
+            switch (token)
+            {
+                case JsonToken.None:
+                    // read to next
+                    break;
+                case JsonToken.StartObject:
+                    WriteStartObject();
+                    break;
+                case JsonToken.StartArray:
+                    WriteStartArray();
+                    break;
+                case JsonToken.StartConstructor:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    WriteStartConstructor(value.ToString());
+                    break;
+                case JsonToken.PropertyName:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    WritePropertyName(value.ToString());
+                    break;
+                case JsonToken.Comment:
+                    WriteComment(value?.ToString());
+                    break;
+                case JsonToken.Integer:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+#if HAVE_BIG_INTEGER
+                    if (value is BigInteger integer)
+                    {
+                        WriteValue(integer);
+                    }
+                    else
+#endif
+                    {
+                        WriteValue(Convert.ToInt64(value, CultureInfo.InvariantCulture));
+                    }
+                    break;
+                case JsonToken.Float:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    if (value is decimal decimalValue)
+                    {
+                        WriteValue(decimalValue);
+                    }
+                    else if (value is double doubleValue)
+                    {
+                        WriteValue(doubleValue);
+                    }
+                    else if (value is float floatValue)
+                    {
+                        WriteValue(floatValue);
+                    }
+                    else
+                    {
+                        WriteValue(Convert.ToDouble(value, CultureInfo.InvariantCulture));
+                    }
+                    break;
+                case JsonToken.String:
+                    // Allow for a null string. This matches JTokenReader behavior which can read
+                    // a JsonToken.String with a null value.
+                    WriteValue(value?.ToString());
+                    break;
+                case JsonToken.Boolean:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    WriteValue(Convert.ToBoolean(value, CultureInfo.InvariantCulture));
+                    break;
+                case JsonToken.Null:
+                    WriteNull();
+                    break;
+                case JsonToken.Undefined:
+                    WriteUndefined();
+                    break;
+                case JsonToken.EndObject:
+                    WriteEndObject();
+                    break;
+                case JsonToken.EndArray:
+                    WriteEndArray();
+                    break;
+                case JsonToken.EndConstructor:
+                    WriteEndConstructor();
+                    break;
+                case JsonToken.Date:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+#if HAVE_DATE_TIME_OFFSET
+                    if (value is DateTimeOffset dt)
+                    {
+                        WriteValue(dt);
+                    }
+                    else
+#endif
+                    {
+                        WriteValue(Convert.ToDateTime(value, CultureInfo.InvariantCulture));
+                    }
+                    break;
+                case JsonToken.Raw:
+                    WriteRawValue(value?.ToString());
+                    break;
+                case JsonToken.Bytes:
+                    ValidationUtils.ArgumentNotNull(value, nameof(value));
+                    if (value is Guid guid)
+                    {
+                        WriteValue(guid);
+                    }
+                    else
+                    {
+                        WriteValue((byte[])value!);
+                    }
+                    break;
+                default:
+                    throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(token), token, "Unexpected token type.");
+            }
+        }
+
+        /// <summary>
+        /// Writes the <see cref="JsonToken"/> token.
+        /// </summary>
+        /// <param name="token">The <see cref="JsonToken"/> to write.</param>
+        public void WriteToken(JsonToken token)
+        {
+            WriteToken(token, null);
+        }
+
+        internal virtual void WriteToken(JsonReader reader, bool writeChildren, bool writeDateConstructorAsDate, bool writeComments)
+        {
+            int initialDepth = CalculateWriteTokenInitialDepth(reader);
+
+            do
+            {
+                // write a JValue date when the constructor is for a date
+                if (writeDateConstructorAsDate && reader.TokenType == JsonToken.StartConstructor && string.Equals(reader.Value?.ToString(), "Date", StringComparison.Ordinal))
+                {
+                    WriteConstructorDate(reader);
+                }
+                else
+                {
+                    if (writeComments || reader.TokenType != JsonToken.Comment)
+                    {
+                        WriteToken(reader.TokenType, reader.Value);
+                    }
+                }
+            } while (
+                // stop if we have reached the end of the token being read
+                initialDepth - 1 < reader.Depth - (JsonTokenUtils.IsEndToken(reader.TokenType) ? 1 : 0)
+                && writeChildren
+                && reader.Read());
+
+            if (IsWriteTokenIncomplete(reader, writeChildren, initialDepth))
+            {
+                throw JsonWriterException.Create(this, "Unexpected end when reading token.", null);
+            }
+        }
+
+        private bool IsWriteTokenIncomplete(JsonReader reader, bool writeChildren, int initialDepth)
+        {
+            int finalDepth = CalculateWriteTokenFinalDepth(reader);
+            return initialDepth < finalDepth ||
+                (writeChildren && initialDepth == finalDepth && JsonTokenUtils.IsStartToken(reader.TokenType));
+        }
+
+        private int CalculateWriteTokenInitialDepth(JsonReader reader)
+        {
+            JsonToken type = reader.TokenType;
+            if (type == JsonToken.None)
+            {
+                return -1;
+            }
+
+            return JsonTokenUtils.IsStartToken(type) ? reader.Depth : reader.Depth + 1;
+        }
+
+        private int CalculateWriteTokenFinalDepth(JsonReader reader)
+        {
+            JsonToken type = reader.TokenType;
+            if (type == JsonToken.None)
+            {
+                return -1;
+            }
+
+            return JsonTokenUtils.IsEndToken(type) ? reader.Depth - 1 : reader.Depth;
+        }
+
+        private void WriteConstructorDate(JsonReader reader)
+        {
+            if (!JavaScriptUtils.TryGetDateFromConstructorJson(reader, out DateTime dateTime, out string? errorMessage))
+            {
+                throw JsonWriterException.Create(this, errorMessage, null);
+            }
+
+            WriteValue(dateTime);
+        }
+
+        private void WriteEnd(JsonContainerType type)
+        {
+            switch (type)
+            {
+                case JsonContainerType.Object:
+                    WriteEndObject();
+                    break;
+                case JsonContainerType.Array:
+                    WriteEndArray();
+                    break;
+                case JsonContainerType.Constructor:
+                    WriteEndConstructor();
+                    break;
+                default:
+                    throw JsonWriterException.Create(this, "Unexpected type when writing end: " + type, null);
+            }
+        }
+
+        private void AutoCompleteAll()
+        {
+            while (Top > 0)
+            {
+                WriteEnd();
+            }
+        }
+
+        private JsonToken GetCloseTokenForType(JsonContainerType type)
+        {
+            switch (type)
+            {
+                case JsonContainerType.Object:
+                    return JsonToken.EndObject;
+                case JsonContainerType.Array:
+                    return JsonToken.EndArray;
+                case JsonContainerType.Constructor:
+                    return JsonToken.EndConstructor;
+                default:
+                    throw JsonWriterException.Create(this, "No close token for type: " + type, null);
+            }
+        }
+
+        private void AutoCompleteClose(JsonContainerType type)
+        {
+            int levelsToComplete = CalculateLevelsToComplete(type);
+
+            for (int i = 0; i < levelsToComplete; i++)
+            {
+                JsonToken token = GetCloseTokenForType(Pop());
+
+                if (_currentState == State.Property)
+                {
+                    WriteNull();
+                }
+
+                if (_formatting == Formatting.Indented)
+                {
+                    if (_currentState != State.ObjectStart && _currentState != State.ArrayStart)
+                    {
+                        WriteIndent();
+                    }
+                }
+
+                WriteEnd(token);
+
+                UpdateCurrentState();
+            }
+        }
+
+        private int CalculateLevelsToComplete(JsonContainerType type)
+        {
+            int levelsToComplete = 0;
+
+            if (_currentPosition.Type == type)
+            {
+                levelsToComplete = 1;
+            }
+            else
+            {
+                int top = Top - 2;
+                for (int i = top; i >= 0; i--)
+                {
+                    int currentLevel = top - i;
+
+                    if (_stack![currentLevel].Type == type)
+                    {
+                        levelsToComplete = i + 2;
+                        break;
+                    }
+                }
+            }
+
+            if (levelsToComplete == 0)
+            {
+                throw JsonWriterException.Create(this, "No token to close.", null);
+            }
+
+            return levelsToComplete;
+        }
+
+        private void UpdateCurrentState()
+        {
+            JsonContainerType currentLevelType = Peek();
+
+            switch (currentLevelType)
+            {
+                case JsonContainerType.Object:
+                    _currentState = State.Object;
+                    break;
+                case JsonContainerType.Array:
+                    _currentState = State.Array;
+                    break;
+                case JsonContainerType.Constructor:
+                    _currentState = State.Array;
+                    break;
+                case JsonContainerType.None:
+                    _currentState = State.Start;
+                    break;
+                default:
+                    throw JsonWriterException.Create(this, "Unknown JsonType: " + currentLevelType, null);
+            }
+        }
+
+        /// <summary>
+        /// Writes the specified end token.
+        /// </summary>
+        /// <param name="token">The end token to write.</param>
+        protected virtual void WriteEnd(JsonToken token)
+        {
+        }
+
+        /// <summary>
+        /// Writes indent characters.
+        /// </summary>
+        protected virtual void WriteIndent()
+        {
+        }
+
+        /// <summary>
+        /// Writes the JSON value delimiter.
+        /// </summary>
+        protected virtual void WriteValueDelimiter()
+        {
+        }
+
+        /// <summary>
+        /// Writes an indent space.
+        /// </summary>
+        protected virtual void WriteIndentSpace()
+        {
+        }
+
+        internal void AutoComplete(JsonToken tokenBeingWritten)
+        {
+            // gets new state based on the current state and what is being written
+            State newState = StateArray[(int)tokenBeingWritten][(int)_currentState];
+
+            if (newState == State.Error)
+            {
+                throw JsonWriterException.Create(this, "Token {0} in state {1} would result in an invalid JSON object.".FormatWith(CultureInfo.InvariantCulture, tokenBeingWritten.ToString(), _currentState.ToString()), null);
+            }
+
+            if ((_currentState == State.Object || _currentState == State.Array || _currentState == State.Constructor) && tokenBeingWritten != JsonToken.Comment)
+            {
+                WriteValueDelimiter();
+            }
+
+            if (_formatting == Formatting.Indented)
+            {
+                if (_currentState == State.Property)
+                {
+                    WriteIndentSpace();
+                }
+
+                // don't indent a property when it is the first token to be written (i.e. at the start)
+                if ((_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.Constructor || _currentState == State.ConstructorStart)
+                    || (tokenBeingWritten == JsonToken.PropertyName && _currentState != State.Start))
+                {
+                    WriteIndent();
+                }
+            }
+
+            _currentState = newState;
+        }
+
+        #region WriteValue methods
+        /// <summary>
+        /// Writes a null value.
+        /// </summary>
+        public virtual void WriteNull()
+        {
+            InternalWriteValue(JsonToken.Null);
+        }
+
+        /// <summary>
+        /// Writes an undefined value.
+        /// </summary>
+        public virtual void WriteUndefined()
+        {
+            InternalWriteValue(JsonToken.Undefined);
+        }
+
+        /// <summary>
+        /// Writes raw JSON without changing the writer's state.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        public virtual void WriteRaw(string? json)
+        {
+            InternalWriteRaw();
+        }
+
+        /// <summary>
+        /// Writes raw JSON where a value is expected and updates the writer's state.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        public virtual void WriteRawValue(string? json)
+        {
+            // hack. want writer to change state as if a value had been written
+            UpdateScopeWithFinishedValue();
+            AutoComplete(JsonToken.Undefined);
+            WriteRaw(json);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="String"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="String"/> value to write.</param>
+        public virtual void WriteValue(string? value)
+        {
+            InternalWriteValue(JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int32"/> value to write.</param>
+        public virtual void WriteValue(int value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt32"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(uint value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int64"/> value to write.</param>
+        public virtual void WriteValue(long value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt64"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(ulong value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Single"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Single"/> value to write.</param>
+        public virtual void WriteValue(float value)
+        {
+            InternalWriteValue(JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Double"/> value to write.</param>
+        public virtual void WriteValue(double value)
+        {
+            InternalWriteValue(JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Boolean"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Boolean"/> value to write.</param>
+        public virtual void WriteValue(bool value)
+        {
+            InternalWriteValue(JsonToken.Boolean);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int16"/> value to write.</param>
+        public virtual void WriteValue(short value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt16"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(ushort value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Char"/> value to write.</param>
+        public virtual void WriteValue(char value)
+        {
+            InternalWriteValue(JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/> value to write.</param>
+        public virtual void WriteValue(byte value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="SByte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="SByte"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(sbyte value)
+        {
+            InternalWriteValue(JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Decimal"/> value to write.</param>
+        public virtual void WriteValue(decimal value)
+        {
+            InternalWriteValue(JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
+        public virtual void WriteValue(DateTime value)
+        {
+            InternalWriteValue(JsonToken.Date);
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Writes a <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTimeOffset"/> value to write.</param>
+        public virtual void WriteValue(DateTimeOffset value)
+        {
+            InternalWriteValue(JsonToken.Date);
+        }
+#endif
+
+        /// <summary>
+        /// Writes a <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Guid"/> value to write.</param>
+        public virtual void WriteValue(Guid value)
+        {
+            InternalWriteValue(JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="TimeSpan"/> value to write.</param>
+        public virtual void WriteValue(TimeSpan value)
+        {
+            InternalWriteValue(JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Int32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Int32"/> value to write.</param>
+        public virtual void WriteValue(int? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="UInt32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="UInt32"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(uint? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Int64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Int64"/> value to write.</param>
+        public virtual void WriteValue(long? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="UInt64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="UInt64"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(ulong? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Single"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Single"/> value to write.</param>
+        public virtual void WriteValue(float? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Double"/> value to write.</param>
+        public virtual void WriteValue(double? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Boolean"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Boolean"/> value to write.</param>
+        public virtual void WriteValue(bool? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Int16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Int16"/> value to write.</param>
+        public virtual void WriteValue(short? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="UInt16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="UInt16"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(ushort? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Char"/> value to write.</param>
+        public virtual void WriteValue(char? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Byte"/> value to write.</param>
+        public virtual void WriteValue(byte? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="SByte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="SByte"/> value to write.</param>
+        [CLSCompliant(false)]
+        public virtual void WriteValue(sbyte? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Decimal"/> value to write.</param>
+        public virtual void WriteValue(decimal? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="DateTime"/> value to write.</param>
+        public virtual void WriteValue(DateTime? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/> value to write.</param>
+        public virtual void WriteValue(DateTimeOffset? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="Guid"/> value to write.</param>
+        public virtual void WriteValue(Guid? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Nullable{T}"/> of <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Nullable{T}"/> of <see cref="TimeSpan"/> value to write.</param>
+        public virtual void WriteValue(TimeSpan? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                WriteValue(value.GetValueOrDefault());
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/>[] value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/>[] value to write.</param>
+        public virtual void WriteValue(byte[]? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                InternalWriteValue(JsonToken.Bytes);
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Uri"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Uri"/> value to write.</param>
+        public virtual void WriteValue(Uri? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+                InternalWriteValue(JsonToken.String);
+            }
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Object"/> value.
+        /// An error will raised if the value cannot be written as a single JSON token.
+        /// </summary>
+        /// <param name="value">The <see cref="Object"/> value to write.</param>
+        public virtual void WriteValue(object? value)
+        {
+            if (value == null)
+            {
+                WriteNull();
+            }
+            else
+            {
+#if HAVE_BIG_INTEGER
+                // this is here because adding a WriteValue(BigInteger) to JsonWriter will
+                // mean the user has to add a reference to System.Numerics.dll
+                if (value is BigInteger)
+                {
+                    throw CreateUnsupportedTypeException(this, value);
+                }
+#endif
+
+                WriteValue(this, ConvertUtils.GetTypeCode(value.GetType()), value);
+            }
+        }
+        #endregion
+
+        /// <summary>
+        /// Writes a comment <c>/*...*/</c> containing the specified text.
+        /// </summary>
+        /// <param name="text">Text to place inside the comment.</param>
+        public virtual void WriteComment(string? text)
+        {
+            InternalWriteComment();
+        }
+
+        /// <summary>
+        /// Writes the given white space.
+        /// </summary>
+        /// <param name="ws">The string of white space characters.</param>
+        public virtual void WriteWhitespace(string ws)
+        {
+            InternalWriteWhitespace(ws);
+        }
+
+        void IDisposable.Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_currentState != State.Closed && disposing)
+            {
+                Close();
+            }
+        }
+
+        internal static void WriteValue(JsonWriter writer, PrimitiveTypeCode typeCode, object value)
+        {
+            while (true)
+            {
+                switch (typeCode)
+                {
+                    case PrimitiveTypeCode.Char:
+                        writer.WriteValue((char)value);
+                        return;
+
+                    case PrimitiveTypeCode.CharNullable:
+                        writer.WriteValue((value == null) ? (char?)null : (char)value);
+                        return;
+
+                    case PrimitiveTypeCode.Boolean:
+                        writer.WriteValue((bool)value);
+                        return;
+
+                    case PrimitiveTypeCode.BooleanNullable:
+                        writer.WriteValue((value == null) ? (bool?)null : (bool)value);
+                        return;
+
+                    case PrimitiveTypeCode.SByte:
+                        writer.WriteValue((sbyte)value);
+                        return;
+
+                    case PrimitiveTypeCode.SByteNullable:
+                        writer.WriteValue((value == null) ? (sbyte?)null : (sbyte)value);
+                        return;
+
+                    case PrimitiveTypeCode.Int16:
+                        writer.WriteValue((short)value);
+                        return;
+
+                    case PrimitiveTypeCode.Int16Nullable:
+                        writer.WriteValue((value == null) ? (short?)null : (short)value);
+                        return;
+
+                    case PrimitiveTypeCode.UInt16:
+                        writer.WriteValue((ushort)value);
+                        return;
+
+                    case PrimitiveTypeCode.UInt16Nullable:
+                        writer.WriteValue((value == null) ? (ushort?)null : (ushort)value);
+                        return;
+
+                    case PrimitiveTypeCode.Int32:
+                        writer.WriteValue((int)value);
+                        return;
+
+                    case PrimitiveTypeCode.Int32Nullable:
+                        writer.WriteValue((value == null) ? (int?)null : (int)value);
+                        return;
+
+                    case PrimitiveTypeCode.Byte:
+                        writer.WriteValue((byte)value);
+                        return;
+
+                    case PrimitiveTypeCode.ByteNullable:
+                        writer.WriteValue((value == null) ? (byte?)null : (byte)value);
+                        return;
+
+                    case PrimitiveTypeCode.UInt32:
+                        writer.WriteValue((uint)value);
+                        return;
+
+                    case PrimitiveTypeCode.UInt32Nullable:
+                        writer.WriteValue((value == null) ? (uint?)null : (uint)value);
+                        return;
+
+                    case PrimitiveTypeCode.Int64:
+                        writer.WriteValue((long)value);
+                        return;
+
+                    case PrimitiveTypeCode.Int64Nullable:
+                        writer.WriteValue((value == null) ? (long?)null : (long)value);
+                        return;
+
+                    case PrimitiveTypeCode.UInt64:
+                        writer.WriteValue((ulong)value);
+                        return;
+
+                    case PrimitiveTypeCode.UInt64Nullable:
+                        writer.WriteValue((value == null) ? (ulong?)null : (ulong)value);
+                        return;
+
+                    case PrimitiveTypeCode.Single:
+                        writer.WriteValue((float)value);
+                        return;
+
+                    case PrimitiveTypeCode.SingleNullable:
+                        writer.WriteValue((value == null) ? (float?)null : (float)value);
+                        return;
+
+                    case PrimitiveTypeCode.Double:
+                        writer.WriteValue((double)value);
+                        return;
+
+                    case PrimitiveTypeCode.DoubleNullable:
+                        writer.WriteValue((value == null) ? (double?)null : (double)value);
+                        return;
+
+                    case PrimitiveTypeCode.DateTime:
+                        writer.WriteValue((DateTime)value);
+                        return;
+
+                    case PrimitiveTypeCode.DateTimeNullable:
+                        writer.WriteValue((value == null) ? (DateTime?)null : (DateTime)value);
+                        return;
+
+#if HAVE_DATE_TIME_OFFSET
+                    case PrimitiveTypeCode.DateTimeOffset:
+                        writer.WriteValue((DateTimeOffset)value);
+                        return;
+
+                    case PrimitiveTypeCode.DateTimeOffsetNullable:
+                        writer.WriteValue((value == null) ? (DateTimeOffset?)null : (DateTimeOffset)value);
+                        return;
+#endif
+                    case PrimitiveTypeCode.Decimal:
+                        writer.WriteValue((decimal)value);
+                        return;
+
+                    case PrimitiveTypeCode.DecimalNullable:
+                        writer.WriteValue((value == null) ? (decimal?)null : (decimal)value);
+                        return;
+
+                    case PrimitiveTypeCode.Guid:
+                        writer.WriteValue((Guid)value);
+                        return;
+
+                    case PrimitiveTypeCode.GuidNullable:
+                        writer.WriteValue((value == null) ? (Guid?)null : (Guid)value);
+                        return;
+
+                    case PrimitiveTypeCode.TimeSpan:
+                        writer.WriteValue((TimeSpan)value);
+                        return;
+
+                    case PrimitiveTypeCode.TimeSpanNullable:
+                        writer.WriteValue((value == null) ? (TimeSpan?)null : (TimeSpan)value);
+                        return;
+
+#if HAVE_BIG_INTEGER
+                    case PrimitiveTypeCode.BigInteger:
+                        // this will call to WriteValue(object)
+                        writer.WriteValue((BigInteger)value);
+                        return;
+
+                    case PrimitiveTypeCode.BigIntegerNullable:
+                        // this will call to WriteValue(object)
+                        writer.WriteValue((value == null) ? (BigInteger?)null : (BigInteger)value);
+                        return;
+#endif
+                    case PrimitiveTypeCode.Uri:
+                        writer.WriteValue((Uri)value);
+                        return;
+
+                    case PrimitiveTypeCode.String:
+                        writer.WriteValue((string)value);
+                        return;
+
+                    case PrimitiveTypeCode.Bytes:
+                        writer.WriteValue((byte[])value);
+                        return;
+
+#if HAVE_DB_NULL_TYPE_CODE
+                    case PrimitiveTypeCode.DBNull:
+                        writer.WriteNull();
+                        return;
+#endif
+                    default:
+#if HAVE_ICONVERTIBLE
+                        if (value is IConvertible convertible)
+                        {
+                            ResolveConvertibleValue(convertible, out typeCode, out value);
+                            continue;
+                        }
+#endif
+
+                        // write an unknown null value, fix https://github.com/JamesNK/Newtonsoft.Json/issues/1460
+                        if (value == null)
+                        {
+                            writer.WriteNull();
+                            return;
+                        }
+
+                        throw CreateUnsupportedTypeException(writer, value);
+                }
+            }
+        }
+
+#if HAVE_ICONVERTIBLE
+        private static void ResolveConvertibleValue(IConvertible convertible, out PrimitiveTypeCode typeCode, out object value)
+        {
+            // the value is a non-standard IConvertible
+            // convert to the underlying value and retry
+            TypeInformation typeInformation = ConvertUtils.GetTypeInformation(convertible);
+
+            // if convertible has an underlying typecode of Object then attempt to convert it to a string
+            typeCode = typeInformation.TypeCode == PrimitiveTypeCode.Object ? PrimitiveTypeCode.String : typeInformation.TypeCode;
+            Type resolvedType = typeInformation.TypeCode == PrimitiveTypeCode.Object ? typeof(string) : typeInformation.Type;
+            value = convertible.ToType(resolvedType, CultureInfo.InvariantCulture);
+        }
+#endif
+
+        private static JsonWriterException CreateUnsupportedTypeException(JsonWriter writer, object value)
+        {
+            return JsonWriterException.Create(writer, "Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType()), null);
+        }
+
+        /// <summary>
+        /// Sets the state of the <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="token">The <see cref="JsonToken"/> being written.</param>
+        /// <param name="value">The value being written.</param>
+        protected void SetWriteState(JsonToken token, object value)
+        {
+            switch (token)
+            {
+                case JsonToken.StartObject:
+                    InternalWriteStart(token, JsonContainerType.Object);
+                    break;
+                case JsonToken.StartArray:
+                    InternalWriteStart(token, JsonContainerType.Array);
+                    break;
+                case JsonToken.StartConstructor:
+                    InternalWriteStart(token, JsonContainerType.Constructor);
+                    break;
+                case JsonToken.PropertyName:
+                    if (!(value is string s))
+                    {
+                        throw new ArgumentException("A name is required when setting property name state.", nameof(value));
+                    }
+
+                    InternalWritePropertyName(s);
+                    break;
+                case JsonToken.Comment:
+                    InternalWriteComment();
+                    break;
+                case JsonToken.Raw:
+                    InternalWriteRaw();
+                    break;
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.String:
+                case JsonToken.Boolean:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                case JsonToken.Null:
+                case JsonToken.Undefined:
+                    InternalWriteValue(token);
+                    break;
+                case JsonToken.EndObject:
+                    InternalWriteEnd(JsonContainerType.Object);
+                    break;
+                case JsonToken.EndArray:
+                    InternalWriteEnd(JsonContainerType.Array);
+                    break;
+                case JsonToken.EndConstructor:
+                    InternalWriteEnd(JsonContainerType.Constructor);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(token));
+            }
+        }
+
+        internal void InternalWriteEnd(JsonContainerType container)
+        {
+            AutoCompleteClose(container);
+        }
+
+        internal void InternalWritePropertyName(string name)
+        {
+            _currentPosition.PropertyName = name;
+            AutoComplete(JsonToken.PropertyName);
+        }
+
+        internal void InternalWriteRaw()
+        {
+        }
+
+        internal void InternalWriteStart(JsonToken token, JsonContainerType container)
+        {
+            UpdateScopeWithFinishedValue();
+            AutoComplete(token);
+            Push(container);
+        }
+
+        internal void InternalWriteValue(JsonToken token)
+        {
+            UpdateScopeWithFinishedValue();
+            AutoComplete(token);
+        }
+
+        internal void InternalWriteWhitespace(string ws)
+        {
+            if (ws != null)
+            {
+                if (!StringUtils.IsWhiteSpace(ws))
+                {
+                    throw JsonWriterException.Create(this, "Only white space characters should be used.", null);
+                }
+            }
+        }
+
+        internal void InternalWriteComment()
+        {
+            AutoComplete(JsonToken.Comment);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/JsonWriterException.cs b/Libs/Newtonsoft.Json/JsonWriterException.cs
new file mode 100644
index 0000000..a2c8d34
--- /dev/null
+++ b/Libs/Newtonsoft.Json/JsonWriterException.cs
@@ -0,0 +1,114 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// The exception thrown when an error occurs while writing JSON text.
+    /// </summary>
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+    [Serializable]
+#endif
+    public class JsonWriterException : JsonException
+    {
+        /// <summary>
+        /// Gets the path to the JSON where the error occurred.
+        /// </summary>
+        /// <value>The path to the JSON where the error occurred.</value>
+        public string? Path { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonWriterException"/> class.
+        /// </summary>
+        public JsonWriterException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonWriterException"/> class
+        /// with a specified error message.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public JsonWriterException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonWriterException"/> class
+        /// with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonWriterException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonWriterException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="info"/> parameter is <c>null</c>.</exception>
+        /// <exception cref="SerializationException">The class name is <c>null</c> or <see cref="Exception.HResult"/> is zero (0).</exception>
+        public JsonWriterException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonWriterException"/> class
+        /// with a specified error message, JSON path and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="path">The path to the JSON where the error occurred.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonWriterException(string message, string path, Exception? innerException)
+            : base(message, innerException)
+        {
+            Path = path;
+        }
+
+        internal static JsonWriterException Create(JsonWriter writer, string message, Exception? ex)
+        {
+            return Create(writer.ContainerPath, message, ex);
+        }
+
+        internal static JsonWriterException Create(string path, string message, Exception? ex)
+        {
+            message = JsonPosition.FormatMessage(null, path, message);
+
+            return new JsonWriterException(message, path, ex);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/LC.Newtonsoft.Json.csproj b/Libs/Newtonsoft.Json/LC.Newtonsoft.Json.csproj
new file mode 100644
index 0000000..d4472c7
--- /dev/null
+++ b/Libs/Newtonsoft.Json/LC.Newtonsoft.Json.csproj
@@ -0,0 +1,86 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">netstandard2.0</TargetFrameworks>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'!=''">$(LibraryFrameworks)</TargetFrameworks>
+    <LangVersion>9.0</LangVersion>
+    <!-- version numbers will be updated by build -->
+    <AssemblyVersion>11.0.0.0</AssemblyVersion>
+    <FileVersion>11.0.1</FileVersion>
+    <VersionPrefix>11.0.1</VersionPrefix>
+    <VersionSuffix>beta2</VersionSuffix>
+    <Authors>James Newton-King</Authors>
+    <Company>Newtonsoft</Company>
+    <Product>Json.NET</Product>
+    <Description>Json.NET is a popular high-performance JSON framework for .NET</Description>
+    <Copyright>Copyright © James Newton-King 2008</Copyright>
+    <Summary>Json.NET is a popular high-performance JSON framework for .NET</Summary>
+    <NeutralLanguage>en-US</NeutralLanguage>
+    <Title>Json.NET</Title>
+    <PackageId>LC.Newtonsoft.Json</PackageId>
+    <PackageTags>json</PackageTags>
+    <PackageIcon>packageIcon.png</PackageIcon>
+    <PackageIconFullPath>$(MSBuildThisFileDirectory)packageIcon.png</PackageIconFullPath>
+    <PackageProjectUrl>https://www.newtonsoft.com/json</PackageProjectUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl> 
+    <RootNamespace>LC.Newtonsoft.Json</RootNamespace>
+    <AssemblyName>LC.Newtonsoft.Json</AssemblyName>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <Nullable>enable</Nullable>
+    <MinClientVersion>2.12</MinClientVersion>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <CodeAnalysisRuleset>Newtonsoft.Json.ruleset</CodeAnalysisRuleset>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <ReleaseVersion>0.7.1</ReleaseVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <None Remove="**\*.orig" />
+    <None Include="..\..\LICENSE.md" Pack="true" PackagePath="LICENSE.md" />
+    <None Include="$(PackageIconFullPath)" Pack="true" PackagePath="\" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="$(MicrosoftCodeAnalysisNetAnalyzersPackageVersion)" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="$(MicrosoftSourceLinkGitHubPackageVersion)" PrivateAssets="All" />
+  </ItemGroup>
+  <PropertyGroup Condition="'$(TargetFramework)'=='net45'">
+    <AssemblyTitle>Json.NET</AssemblyTitle>
+    <DefineConstants>HAVE_ADO_NET;HAVE_APP_DOMAIN;HAVE_ASYNC;HAVE_BIG_INTEGER;HAVE_BINARY_FORMATTER;HAVE_BINARY_SERIALIZATION;HAVE_BINARY_EXCEPTION_SERIALIZATION;HAVE_CAS;HAVE_CHAR_TO_LOWER_WITH_CULTURE;HAVE_CHAR_TO_STRING_WITH_CULTURE;HAVE_COM_ATTRIBUTES;HAVE_COMPONENT_MODEL;HAVE_CONCURRENT_COLLECTIONS;HAVE_COVARIANT_GENERICS;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DB_NULL_TYPE_CODE;HAVE_DYNAMIC;HAVE_EMPTY_TYPES;HAVE_ENTITY_FRAMEWORK;HAVE_EXPRESSIONS;HAVE_FAST_REVERSE;HAVE_FSHARP_TYPES;HAVE_FULL_REFLECTION;HAVE_GUID_TRY_PARSE;HAVE_HASH_SET;HAVE_ICLONEABLE;HAVE_ICONVERTIBLE;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;HAVE_INOTIFY_COLLECTION_CHANGED;HAVE_INOTIFY_PROPERTY_CHANGING;HAVE_ISET;HAVE_LINQ;HAVE_MEMORY_BARRIER;HAVE_METHOD_IMPL_ATTRIBUTE;HAVE_NON_SERIALIZED_ATTRIBUTE;HAVE_READ_ONLY_COLLECTIONS;HAVE_REFLECTION_EMIT;HAVE_REGEX_TIMEOUTS;HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE;HAVE_SERIALIZATION_BINDER_BIND_TO_NAME;HAVE_STREAM_READER_WRITER_CLOSE;HAVE_STRING_JOIN_WITH_ENUMERABLE;HAVE_TIME_SPAN_PARSE_WITH_CULTURE;HAVE_TIME_SPAN_TO_STRING_WITH_CULTURE;HAVE_TIME_ZONE_INFO;HAVE_TRACE_WRITER;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;HAVE_XLINQ;HAVE_XML_DOCUMENT;HAVE_XML_DOCUMENT_TYPE;HAVE_CONCURRENT_DICTIONARY;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)'=='net40'">
+    <AssemblyTitle>Json.NET .NET 4.0</AssemblyTitle>
+    <DefineConstants>NET40;HAVE_ADO_NET;HAVE_APP_DOMAIN;HAVE_BIG_INTEGER;HAVE_BINARY_FORMATTER;HAVE_BINARY_SERIALIZATION;HAVE_BINARY_EXCEPTION_SERIALIZATION;HAVE_CAS;HAVE_CHAR_TO_STRING_WITH_CULTURE;HAVE_CHAR_TO_LOWER_WITH_CULTURE;HAVE_COM_ATTRIBUTES;HAVE_COMPONENT_MODEL;HAVE_CONCURRENT_COLLECTIONS;HAVE_COVARIANT_GENERICS;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DB_NULL_TYPE_CODE;HAVE_DYNAMIC;HAVE_EMPTY_TYPES;HAVE_ENTITY_FRAMEWORK;HAVE_EXPRESSIONS;HAVE_FAST_REVERSE;HAVE_FSHARP_TYPES;HAVE_FULL_REFLECTION;HAVE_GUID_TRY_PARSE;HAVE_HASH_SET;HAVE_ICLONEABLE;HAVE_ICONVERTIBLE;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;HAVE_INOTIFY_COLLECTION_CHANGED;HAVE_INOTIFY_PROPERTY_CHANGING;HAVE_ISET;HAVE_LINQ;HAVE_MEMORY_BARRIER;HAVE_NON_SERIALIZED_ATTRIBUTE;HAVE_REFLECTION_EMIT;HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE;HAVE_SERIALIZATION_BINDER_BIND_TO_NAME;HAVE_STREAM_READER_WRITER_CLOSE;HAVE_STRING_JOIN_WITH_ENUMERABLE;HAVE_TIME_SPAN_PARSE_WITH_CULTURE;HAVE_TIME_SPAN_TO_STRING_WITH_CULTURE;HAVE_TIME_ZONE_INFO;HAVE_TRACE_WRITER;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;HAVE_XLINQ;HAVE_XML_DOCUMENT;HAVE_XML_DOCUMENT_TYPE;HAVE_CONCURRENT_DICTIONARY;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)'=='net35'">
+    <AssemblyTitle>Json.NET .NET 3.5</AssemblyTitle>
+    <DefineConstants>NET35;HAVE_ADO_NET;HAVE_APP_DOMAIN;HAVE_BINARY_FORMATTER;HAVE_BINARY_SERIALIZATION;HAVE_BINARY_EXCEPTION_SERIALIZATION;HAVE_CAS;HAVE_CHAR_TO_STRING_WITH_CULTURE;HAVE_CHAR_TO_LOWER_WITH_CULTURE;HAVE_COM_ATTRIBUTES;HAVE_COMPONENT_MODEL;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DB_NULL_TYPE_CODE;HAVE_EMPTY_TYPES;HAVE_ENTITY_FRAMEWORK;HAVE_FAST_REVERSE;HAVE_FULL_REFLECTION;HAVE_HASH_SET;HAVE_ICLONEABLE;HAVE_ICONVERTIBLE;HAVE_INOTIFY_PROPERTY_CHANGING;HAVE_LINQ;HAVE_MEMORY_BARRIER;HAVE_NON_SERIALIZED_ATTRIBUTE;HAVE_REFLECTION_EMIT;HAVE_STREAM_READER_WRITER_CLOSE;HAVE_TIME_ZONE_INFO;HAVE_TRACE_WRITER;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_XLINQ;HAVE_XML_DOCUMENT;HAVE_XML_DOCUMENT_TYPE;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)'=='net20'">
+    <AssemblyTitle>Json.NET .NET 2.0</AssemblyTitle>
+    <DefineConstants>NET20;HAVE_ADO_NET;HAVE_APP_DOMAIN;HAVE_BINARY_FORMATTER;HAVE_BINARY_SERIALIZATION;HAVE_BINARY_EXCEPTION_SERIALIZATION;HAVE_CAS;HAVE_CHAR_TO_LOWER_WITH_CULTURE;HAVE_CHAR_TO_STRING_WITH_CULTURE;HAVE_COM_ATTRIBUTES;HAVE_COMPONENT_MODEL;HAVE_DB_NULL_TYPE_CODE;HAVE_EMPTY_TYPES;HAVE_FAST_REVERSE;HAVE_FULL_REFLECTION;HAVE_ICLONEABLE;HAVE_ICONVERTIBLE;HAVE_MEMORY_BARRIER;HAVE_NON_SERIALIZED_ATTRIBUTE;HAVE_REFLECTION_EMIT;HAVE_STREAM_READER_WRITER_CLOSE;HAVE_TRACE_WRITER;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_XML_DOCUMENT;HAVE_XML_DOCUMENT_TYPE;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard1.0' OR '$(TargetFramework)' == 'netstandard1.3'">
+    <PackageReference Include="Microsoft.CSharp" Version="$(MicrosoftCSharpPackageVersion)" />
+    <PackageReference Include="System.ComponentModel.TypeConverter" Version="$(SystemComponentModelTypeConverterPackageVersion)" />
+    <PackageReference Include="System.Runtime.Serialization.Primitives" Version="$(SystemRuntimeSerializationPrimitivesPackageVersion)" />
+  </ItemGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard1.0'">
+    <AssemblyTitle>Json.NET .NET Standard 1.0</AssemblyTitle>
+    <DefineConstants>NETSTANDARD1_0;PORTABLE;HAVE_ASYNC;HAVE_COVARIANT_GENERICS;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DYNAMIC;HAVE_EXPRESSIONS;HAVE_FSHARP_TYPES;HAVE_GUID_TRY_PARSE;HAVE_HASH_SET;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;HAVE_INOTIFY_COLLECTION_CHANGED;HAVE_ISET;HAVE_LINQ;HAVE_METHOD_IMPL_ATTRIBUTE;HAVE_READ_ONLY_COLLECTIONS;HAVE_REFLECTION_BINDER;HAVE_SERIALIZATION_BINDER_BIND_TO_NAME;HAVE_STRING_JOIN_WITH_ENUMERABLE;HAVE_TIME_SPAN_PARSE_WITH_CULTURE;HAVE_TIME_SPAN_TO_STRING_WITH_CULTURE;HAVE_TIME_ZONE_INFO;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;HAVE_XLINQ;HAVE_OBSOLETE_FORMATTER_ASSEMBLY_STYLE;HAVE_REGEX_TIMEOUTS;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard1.3'">
+    <PackageReference Include="System.Runtime.Serialization.Formatters" Version="$(SystemRuntimeSerializationFormattersPackageVersion)" />
+    <PackageReference Include="System.Xml.XmlDocument" Version="$(SystemXmlXmlDocumentPackageVersion)" />
+  </ItemGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard1.3'">
+    <AssemblyTitle>Json.NET .NET Standard 1.3</AssemblyTitle>
+    <DefineConstants>NETSTANDARD1_3;PORTABLE;HAVE_ASYNC;HAVE_BIG_INTEGER;HAVE_BINARY_SERIALIZATION;HAVE_COVARIANT_GENERICS;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DYNAMIC;HAVE_EXPRESSIONS;HAVE_FSHARP_TYPES;HAVE_GUID_TRY_PARSE;HAVE_HASH_SET;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;HAVE_INOTIFY_COLLECTION_CHANGED;HAVE_INOTIFY_PROPERTY_CHANGING;HAVE_ISET;HAVE_LINQ;HAVE_METHOD_IMPL_ATTRIBUTE;HAVE_NON_SERIALIZED_ATTRIBUTE;HAVE_READ_ONLY_COLLECTIONS;HAVE_REFLECTION_BINDER;HAVE_SERIALIZATION_BINDER_BIND_TO_NAME;HAVE_STRING_JOIN_WITH_ENUMERABLE;HAVE_TIME_SPAN_PARSE_WITH_CULTURE;HAVE_TIME_SPAN_TO_STRING_WITH_CULTURE;HAVE_TIME_ZONE_INFO;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;HAVE_XLINQ;HAVE_OBSOLETE_FORMATTER_ASSEMBLY_STYLE;HAVE_XML_DOCUMENT;HAVE_CONCURRENT_DICTIONARY;HAVE_ICONVERTIBLE;HAVE_REGEX_TIMEOUTS;HAVE_REGEX_TIMEOUTS;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <AssemblyTitle>Json.NET .NET Standard 2.0</AssemblyTitle>
+    <DefineConstants>NETSTANDARD2_0;HAVE_ADO_NET;HAVE_APP_DOMAIN;HAVE_ASYNC;HAVE_BIG_INTEGER;HAVE_BINARY_FORMATTER;HAVE_BINARY_SERIALIZATION;HAVE_BINARY_EXCEPTION_SERIALIZATION;HAVE_CHAR_TO_LOWER_WITH_CULTURE;HAVE_CHAR_TO_STRING_WITH_CULTURE;HAVE_COM_ATTRIBUTES;HAVE_COMPONENT_MODEL;HAVE_CONCURRENT_COLLECTIONS;HAVE_COVARIANT_GENERICS;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DB_NULL_TYPE_CODE;HAVE_DYNAMIC;HAVE_EMPTY_TYPES;HAVE_ENTITY_FRAMEWORK;HAVE_EXPRESSIONS;HAVE_FAST_REVERSE;HAVE_FSHARP_TYPES;HAVE_FULL_REFLECTION;HAVE_GUID_TRY_PARSE;HAVE_HASH_SET;HAVE_ICLONEABLE;HAVE_ICONVERTIBLE;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;HAVE_INOTIFY_COLLECTION_CHANGED;HAVE_INOTIFY_PROPERTY_CHANGING;HAVE_ISET;HAVE_LINQ;HAVE_MEMORY_BARRIER;HAVE_METHOD_IMPL_ATTRIBUTE;HAVE_NON_SERIALIZED_ATTRIBUTE;HAVE_READ_ONLY_COLLECTIONS;HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE;HAVE_SERIALIZATION_BINDER_BIND_TO_NAME;HAVE_STREAM_READER_WRITER_CLOSE;HAVE_STRING_JOIN_WITH_ENUMERABLE;HAVE_TIME_SPAN_PARSE_WITH_CULTURE;HAVE_TIME_SPAN_TO_STRING_WITH_CULTURE;HAVE_TIME_ZONE_INFO;HAVE_TRACE_WRITER;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;HAVE_XLINQ;HAVE_XML_DOCUMENT;HAVE_XML_DOCUMENT_TYPE;HAVE_CONCURRENT_DICTIONARY;HAVE_REGEX_TIMEOUTS;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DefineConstants>HAVE_ADO_NET;HAVE_APP_DOMAIN;HAVE_ASYNC;HAVE_BIG_INTEGER;HAVE_BINARY_FORMATTER;HAVE_BINARY_SERIALIZATION;HAVE_BINARY_EXCEPTION_SERIALIZATION;HAVE_CHAR_TO_LOWER_WITH_CULTURE;HAVE_CHAR_TO_STRING_WITH_CULTURE;HAVE_COM_ATTRIBUTES;HAVE_COMPONENT_MODEL;HAVE_CONCURRENT_COLLECTIONS;HAVE_COVARIANT_GENERICS;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DB_NULL_TYPE_CODE;HAVE_DYNAMIC;HAVE_EMPTY_TYPES;HAVE_ENTITY_FRAMEWORK;HAVE_EXPRESSIONS;HAVE_FAST_REVERSE;HAVE_FSHARP_TYPES;HAVE_FULL_REFLECTION;HAVE_GUID_TRY_PARSE;HAVE_HASH_SET;HAVE_ICLONEABLE;HAVE_ICONVERTIBLE;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;HAVE_INOTIFY_COLLECTION_CHANGED;HAVE_INOTIFY_PROPERTY_CHANGING;HAVE_ISET;HAVE_LINQ;HAVE_MEMORY_BARRIER;HAVE_METHOD_IMPL_ATTRIBUTE;HAVE_NON_SERIALIZED_ATTRIBUTE;HAVE_READ_ONLY_COLLECTIONS;HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE;HAVE_SERIALIZATION_BINDER_BIND_TO_NAME;HAVE_STREAM_READER_WRITER_CLOSE;HAVE_STRING_JOIN_WITH_ENUMERABLE;HAVE_TIME_SPAN_PARSE_WITH_CULTURE;HAVE_TIME_SPAN_TO_STRING_WITH_CULTURE;HAVE_TIME_ZONE_INFO;HAVE_TRACE_WRITER;HAVE_TYPE_DESCRIPTOR;HAVE_UNICODE_SURROGATE_DETECTION;HAVE_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;HAVE_XLINQ;HAVE_XML_DOCUMENT;HAVE_XML_DOCUMENT_TYPE;HAVE_CONCURRENT_DICTIONARY;HAVE_REGEX_TIMEOUTS;;DEBUG;NETSTANDARD;NETSTANDARD2_0;</DefineConstants>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/CommentHandling.cs b/Libs/Newtonsoft.Json/Linq/CommentHandling.cs
new file mode 100644
index 0000000..c849d8f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/CommentHandling.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies how JSON comments are handled when loading JSON.
+    /// </summary>
+    public enum CommentHandling
+    {
+        /// <summary>
+        /// Ignore comments.
+        /// </summary>
+        Ignore = 0,
+
+        /// <summary>
+        /// Load comments as a <see cref="JValue"/> with type <see cref="JTokenType.Comment"/>.
+        /// </summary>
+        Load = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/DuplicatePropertyNameHandling.cs b/Libs/Newtonsoft.Json/Linq/DuplicatePropertyNameHandling.cs
new file mode 100644
index 0000000..14c3232
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/DuplicatePropertyNameHandling.cs
@@ -0,0 +1,46 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies how duplicate property names are handled when loading JSON.
+    /// </summary>
+    public enum DuplicatePropertyNameHandling
+    {
+        /// <summary>
+        /// Replace the existing value when there is a duplicate property. The value of the last property in the JSON object will be used.
+        /// </summary>
+        Replace = 0,
+        /// <summary>
+        /// Ignore the new value when there is a duplicate property. The value of the first property in the JSON object will be used.
+        /// </summary>
+        Ignore = 1,
+        /// <summary>
+        /// Throw a <see cref="JsonReaderException"/> when a duplicate property is encountered.
+        /// </summary>
+        Error = 2
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/Extensions.cs b/Libs/Newtonsoft.Json/Linq/Extensions.cs
new file mode 100644
index 0000000..e401a5c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/Extensions.cs
@@ -0,0 +1,336 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Contains the LINQ to JSON extension methods.
+    /// </summary>
+    public static class Extensions
+    {
+        /// <summary>
+        /// Returns a collection of tokens that contains the ancestors of every token in the source collection.
+        /// </summary>
+        /// <typeparam name="T">The type of the objects in source, constrained to <see cref="JToken"/>.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the ancestors of every token in the source collection.</returns>
+        public static IJEnumerable<JToken> Ancestors<T>(this IEnumerable<T> source) where T : JToken
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            return source.SelectMany(j => j.Ancestors()).AsJEnumerable();
+        }
+
+        /// <summary>
+        /// Returns a collection of tokens that contains every token in the source collection, and the ancestors of every token in the source collection.
+        /// </summary>
+        /// <typeparam name="T">The type of the objects in source, constrained to <see cref="JToken"/>.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains every token in the source collection, the ancestors of every token in the source collection.</returns>
+        public static IJEnumerable<JToken> AncestorsAndSelf<T>(this IEnumerable<T> source) where T : JToken
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            return source.SelectMany(j => j.AncestorsAndSelf()).AsJEnumerable();
+        }
+
+        /// <summary>
+        /// Returns a collection of tokens that contains the descendants of every token in the source collection.
+        /// </summary>
+        /// <typeparam name="T">The type of the objects in source, constrained to <see cref="JContainer"/>.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the descendants of every token in the source collection.</returns>
+        public static IJEnumerable<JToken> Descendants<T>(this IEnumerable<T> source) where T : JContainer
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            return source.SelectMany(j => j.Descendants()).AsJEnumerable();
+        }
+
+        /// <summary>
+        /// Returns a collection of tokens that contains every token in the source collection, and the descendants of every token in the source collection.
+        /// </summary>
+        /// <typeparam name="T">The type of the objects in source, constrained to <see cref="JContainer"/>.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains every token in the source collection, and the descendants of every token in the source collection.</returns>
+        public static IJEnumerable<JToken> DescendantsAndSelf<T>(this IEnumerable<T> source) where T : JContainer
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            return source.SelectMany(j => j.DescendantsAndSelf()).AsJEnumerable();
+        }
+
+        /// <summary>
+        /// Returns a collection of child properties of every object in the source collection.
+        /// </summary>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JObject"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JProperty"/> that contains the properties of every object in the source collection.</returns>
+        public static IJEnumerable<JProperty> Properties(this IEnumerable<JObject> source)
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            return source.SelectMany(d => d.Properties()).AsJEnumerable();
+        }
+
+        /// <summary>
+        /// Returns a collection of child values of every object in the source collection with the given key.
+        /// </summary>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <param name="key">The token key.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the values of every token in the source collection with the given key.</returns>
+        public static IJEnumerable<JToken> Values(this IEnumerable<JToken> source, object? key)
+        {
+            return Values<JToken, JToken>(source, key)!.AsJEnumerable();
+        }
+
+        /// <summary>
+        /// Returns a collection of child values of every object in the source collection.
+        /// </summary>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the values of every token in the source collection.</returns>
+        public static IJEnumerable<JToken> Values(this IEnumerable<JToken> source)
+        {
+            return source.Values(null);
+        }
+
+        /// <summary>
+        /// Returns a collection of converted child values of every object in the source collection with the given key.
+        /// </summary>
+        /// <typeparam name="U">The type to convert the values to.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <param name="key">The token key.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> that contains the converted values of every token in the source collection with the given key.</returns>
+        public static IEnumerable<U?> Values<U>(this IEnumerable<JToken> source, object key)
+        {
+            return Values<JToken, U>(source, key);
+        }
+
+        /// <summary>
+        /// Returns a collection of converted child values of every object in the source collection.
+        /// </summary>
+        /// <typeparam name="U">The type to convert the values to.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> that contains the converted values of every token in the source collection.</returns>
+        public static IEnumerable<U?> Values<U>(this IEnumerable<JToken> source)
+        {
+            return Values<JToken, U>(source, null);
+        }
+
+        /// <summary>
+        /// Converts the value.
+        /// </summary>
+        /// <typeparam name="U">The type to convert the value to.</typeparam>
+        /// <param name="value">A <see cref="JToken"/> cast as a <see cref="IEnumerable{T}"/> of <see cref="JToken"/>.</param>
+        /// <returns>A converted value.</returns>
+        public static U? Value<U>(this IEnumerable<JToken> value)
+        {
+            return value.Value<JToken, U>();
+        }
+
+        /// <summary>
+        /// Converts the value.
+        /// </summary>
+        /// <typeparam name="T">The source collection type.</typeparam>
+        /// <typeparam name="U">The type to convert the value to.</typeparam>
+        /// <param name="value">A <see cref="JToken"/> cast as a <see cref="IEnumerable{T}"/> of <see cref="JToken"/>.</param>
+        /// <returns>A converted value.</returns>
+        public static U? Value<T, U>(this IEnumerable<T> value) where T : JToken
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+
+            if (!(value is JToken token))
+            {
+                throw new ArgumentException("Source value must be a JToken.");
+            }
+
+            return token.Convert<JToken, U>();
+        }
+
+        internal static IEnumerable<U?> Values<T, U>(this IEnumerable<T> source, object? key) where T : JToken
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            if (key == null)
+            {
+                foreach (T token in source)
+                {
+                    if (token is JValue value)
+                    {
+                        yield return Convert<JValue, U>(value);
+                    }
+                    else
+                    {
+                        foreach (JToken t in token.Children())
+                        {
+                            yield return t.Convert<JToken, U>();
+                        }
+                    }
+                }
+            }
+            else
+            {
+                foreach (T token in source)
+                {
+                    JToken? value = token[key];
+                    if (value != null)
+                    {
+                        yield return value.Convert<JToken, U>();
+                    }
+                }
+            }
+        }
+
+        //TODO
+        //public static IEnumerable<T> InDocumentOrder<T>(this IEnumerable<T> source) where T : JObject;
+
+        /// <summary>
+        /// Returns a collection of child tokens of every array in the source collection.
+        /// </summary>
+        /// <typeparam name="T">The source collection type.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the values of every token in the source collection.</returns>
+        public static IJEnumerable<JToken> Children<T>(this IEnumerable<T> source) where T : JToken
+        {
+            return Children<T, JToken>(source)!.AsJEnumerable();
+        }
+
+        /// <summary>
+        /// Returns a collection of converted child tokens of every array in the source collection.
+        /// </summary>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <typeparam name="U">The type to convert the values to.</typeparam>
+        /// <typeparam name="T">The source collection type.</typeparam>
+        /// <returns>An <see cref="IEnumerable{T}"/> that contains the converted values of every token in the source collection.</returns>
+        public static IEnumerable<U?> Children<T, U>(this IEnumerable<T> source) where T : JToken
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            return source.SelectMany(c => c.Children()).Convert<JToken, U>();
+        }
+
+        internal static IEnumerable<U?> Convert<T, U>(this IEnumerable<T> source) where T : JToken
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+
+            foreach (T token in source)
+            {
+                yield return Convert<JToken, U>(token);
+            }
+        }
+
+        internal static U? Convert<T, U>(this T token) where T : JToken?
+        {
+            if (token == null)
+            {
+#pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
+                return default;
+#pragma warning restore CS8653 // A default expression introduces a null value for a type parameter.
+            }
+
+            if (token is U castValue
+                // don't want to cast JValue to its interfaces, want to get the internal value
+                && typeof(U) != typeof(IComparable) && typeof(U) != typeof(IFormattable))
+            {
+                return castValue;
+            }
+            else
+            {
+                if (!(token is JValue value))
+                {
+                    throw new InvalidCastException("Cannot cast {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, token.GetType(), typeof(T)));
+                }
+
+                if (value.Value is U u)
+                {
+                    return u;
+                }
+
+                Type targetType = typeof(U);
+
+                if (ReflectionUtils.IsNullableType(targetType))
+                {
+                    if (value.Value == null)
+                    {
+#pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
+                        return default;
+#pragma warning restore CS8653 // A default expression introduces a null value for a type parameter.
+                    }
+
+                    targetType = Nullable.GetUnderlyingType(targetType);
+                }
+
+                return (U)System.Convert.ChangeType(value.Value, targetType, CultureInfo.InvariantCulture);
+            }
+        }
+
+        //TODO
+        //public static void Remove<T>(this IEnumerable<T> source) where T : JContainer;
+
+        /// <summary>
+        /// Returns the input typed as <see cref="IJEnumerable{T}"/>.
+        /// </summary>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>The input typed as <see cref="IJEnumerable{T}"/>.</returns>
+        public static IJEnumerable<JToken> AsJEnumerable(this IEnumerable<JToken> source)
+        {
+            return source.AsJEnumerable<JToken>();
+        }
+
+        /// <summary>
+        /// Returns the input typed as <see cref="IJEnumerable{T}"/>.
+        /// </summary>
+        /// <typeparam name="T">The source collection type.</typeparam>
+        /// <param name="source">An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the source collection.</param>
+        /// <returns>The input typed as <see cref="IJEnumerable{T}"/>.</returns>
+        public static IJEnumerable<T> AsJEnumerable<T>(this IEnumerable<T> source) where T : JToken
+        {
+            if (source == null)
+            {
+                return null!;
+            }
+            else if (source is IJEnumerable<T> customEnumerable)
+            {
+                return customEnumerable;
+            }
+            else
+            {
+                return new JEnumerable<T>(source);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/IJEnumerable.cs b/Libs/Newtonsoft.Json/Linq/IJEnumerable.cs
new file mode 100644
index 0000000..a99f446
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/IJEnumerable.cs
@@ -0,0 +1,46 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a collection of <see cref="JToken"/> objects.
+    /// </summary>
+    /// <typeparam name="T">The type of token.</typeparam>
+    public interface IJEnumerable<
+#if HAVE_VARIANT_TYPE_PARAMETERS
+        out
+#endif
+            T> : IEnumerable<T> where T : JToken
+    {
+        /// <summary>
+        /// Gets the <see cref="IJEnumerable{T}"/> of <see cref="JToken"/> with the specified key.
+        /// </summary>
+        /// <value></value>
+        IJEnumerable<JToken> this[object key] { get; }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JArray.Async.cs b/Libs/Newtonsoft.Json/Linq/JArray.Async.cs
new file mode 100644
index 0000000..85e9b28
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JArray.Async.cs
@@ -0,0 +1,103 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public partial class JArray
+    {
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/> asynchronously.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        public override async Task WriteToAsync(JsonWriter writer, CancellationToken cancellationToken, params JsonConverter[] converters)
+        {
+            await writer.WriteStartArrayAsync(cancellationToken).ConfigureAwait(false);
+
+            for (int i = 0; i < _values.Count; i++)
+            {
+                await _values[i].WriteToAsync(writer, cancellationToken, converters).ConfigureAwait(false);
+            }
+
+            await writer.WriteEndArrayAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JArray"/> from a <see cref="JsonReader"/>. 
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JArray"/>.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> representing the asynchronous load. The <see cref="Task{TResult}.Result"/> property contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static Task<JArray> LoadAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            return LoadAsync(reader, null, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JArray"/> from a <see cref="JsonReader"/>. 
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JArray"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> representing the asynchronous load. The <see cref="Task{TResult}.Result"/> property contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static async Task<JArray> LoadAsync(JsonReader reader, JsonLoadSettings? settings, CancellationToken cancellationToken = default)
+        {
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JArray from JsonReader.");
+                }
+            }
+
+            await reader.MoveToContentAsync(cancellationToken).ConfigureAwait(false);
+
+            if (reader.TokenType != JsonToken.StartArray)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JArray from JsonReader. Current JsonReader item is not an array: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JArray a = new JArray();
+            a.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            await a.ReadTokenFromAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+
+            return a;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JArray.cs b/Libs/Newtonsoft.Json/Linq/JArray.cs
new file mode 100644
index 0000000..070cbc8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JArray.cs
@@ -0,0 +1,403 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Utilities;
+using System.IO;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a JSON array.
+    /// </summary>
+    /// <example>
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\LinqToJsonTests.cs" region="LinqToJsonCreateParseArray" title="Parsing a JSON Array from Text" />
+    /// </example>
+    public partial class JArray : JContainer, IList<JToken>
+    {
+        private readonly List<JToken> _values = new List<JToken>();
+
+        /// <summary>
+        /// Gets the container's children tokens.
+        /// </summary>
+        /// <value>The container's children tokens.</value>
+        protected override IList<JToken> ChildrenTokens => _values;
+
+        /// <summary>
+        /// Gets the node type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <value>The type.</value>
+        public override JTokenType Type => JTokenType.Array;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JArray"/> class.
+        /// </summary>
+        public JArray()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JArray"/> class from another <see cref="JArray"/> object.
+        /// </summary>
+        /// <param name="other">A <see cref="JArray"/> object to copy from.</param>
+        public JArray(JArray other)
+            : base(other)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JArray"/> class with the specified content.
+        /// </summary>
+        /// <param name="content">The contents of the array.</param>
+        public JArray(params object[] content)
+            : this((object)content)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JArray"/> class with the specified content.
+        /// </summary>
+        /// <param name="content">The contents of the array.</param>
+        public JArray(object content)
+        {
+            Add(content);
+        }
+
+        internal override bool DeepEquals(JToken node)
+        {
+            return (node is JArray t && ContentsEqual(t));
+        }
+
+        internal override JToken CloneToken()
+        {
+            return new JArray(this);
+        }
+
+        /// <summary>
+        /// Loads an <see cref="JArray"/> from a <see cref="JsonReader"/>. 
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JArray"/>.</param>
+        /// <returns>A <see cref="JArray"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static JArray Load(JsonReader reader)
+        {
+            return Load(reader, null);
+        }
+
+        /// <summary>
+        /// Loads an <see cref="JArray"/> from a <see cref="JsonReader"/>. 
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JArray"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>A <see cref="JArray"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static JArray Load(JsonReader reader, JsonLoadSettings? settings)
+        {
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!reader.Read())
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JArray from JsonReader.");
+                }
+            }
+
+            reader.MoveToContent();
+
+            if (reader.TokenType != JsonToken.StartArray)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JArray from JsonReader. Current JsonReader item is not an array: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JArray a = new JArray();
+            a.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            a.ReadTokenFrom(reader, settings);
+
+            return a;
+        }
+
+        /// <summary>
+        /// Load a <see cref="JArray"/> from a string that contains JSON.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON.</param>
+        /// <returns>A <see cref="JArray"/> populated from the string that contains JSON.</returns>
+        /// <example>
+        ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\LinqToJsonTests.cs" region="LinqToJsonCreateParseArray" title="Parsing a JSON Array from Text" />
+        /// </example>
+        public new static JArray Parse(string json)
+        {
+            return Parse(json, null);
+        }
+
+        /// <summary>
+        /// Load a <see cref="JArray"/> from a string that contains JSON.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>A <see cref="JArray"/> populated from the string that contains JSON.</returns>
+        /// <example>
+        ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\LinqToJsonTests.cs" region="LinqToJsonCreateParseArray" title="Parsing a JSON Array from Text" />
+        /// </example>
+        public new static JArray Parse(string json, JsonLoadSettings? settings)
+        {
+            using (JsonReader reader = new JsonTextReader(new StringReader(json)))
+            {
+                JArray a = Load(reader, settings);
+
+                while (reader.Read())
+                {
+                    // Any content encountered here other than a comment will throw in the reader.
+                }
+
+                return a;
+            }
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JArray"/> from an object.
+        /// </summary>
+        /// <param name="o">The object that will be used to create <see cref="JArray"/>.</param>
+        /// <returns>A <see cref="JArray"/> with the values of the specified object.</returns>
+        public new static JArray FromObject(object o)
+        {
+            return FromObject(o, JsonSerializer.CreateDefault());
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JArray"/> from an object.
+        /// </summary>
+        /// <param name="o">The object that will be used to create <see cref="JArray"/>.</param>
+        /// <param name="jsonSerializer">The <see cref="JsonSerializer"/> that will be used to read the object.</param>
+        /// <returns>A <see cref="JArray"/> with the values of the specified object.</returns>
+        public new static JArray FromObject(object o, JsonSerializer jsonSerializer)
+        {
+            JToken token = FromObjectInternal(o, jsonSerializer);
+
+            if (token.Type != JTokenType.Array)
+            {
+                throw new ArgumentException("Object serialized to {0}. JArray instance expected.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+            }
+
+            return (JArray)token;
+        }
+
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
+        {
+            writer.WriteStartArray();
+
+            for (int i = 0; i < _values.Count; i++)
+            {
+                _values[i].WriteTo(writer, converters);
+            }
+
+            writer.WriteEndArray();
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JToken"/> with the specified key.
+        /// </summary>
+        /// <value>The <see cref="JToken"/> with the specified key.</value>
+        public override JToken? this[object key]
+        {
+            get
+            {
+                ValidationUtils.ArgumentNotNull(key, nameof(key));
+
+                if (!(key is int))
+                {
+                    throw new ArgumentException("Accessed JArray values with invalid key value: {0}. Int32 array index expected.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(key)));
+                }
+
+                return GetItem((int)key);
+            }
+            set
+            {
+                ValidationUtils.ArgumentNotNull(key, nameof(key));
+
+                if (!(key is int))
+                {
+                    throw new ArgumentException("Set JArray values with invalid key value: {0}. Int32 array index expected.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(key)));
+                }
+
+                SetItem((int)key, value);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Newtonsoft.Json.Linq.JToken"/> at the specified index.
+        /// </summary>
+        /// <value></value>
+        public JToken this[int index]
+        {
+            get => GetItem(index);
+            set => SetItem(index, value);
+        }
+
+        internal override int IndexOfItem(JToken? item)
+        {
+            if (item == null)
+            {
+                return -1;
+            }
+
+            return _values.IndexOfReference(item);
+        }
+
+        internal override void MergeItem(object content, JsonMergeSettings? settings)
+        {
+            IEnumerable? a = (IsMultiContent(content) || content is JArray)
+                ? (IEnumerable)content
+                : null;
+            if (a == null)
+            {
+                return;
+            }
+
+            MergeEnumerableContent(this, a, settings);
+        }
+
+        #region IList<JToken> Members
+        /// <summary>
+        /// Determines the index of a specific item in the <see cref="JArray"/>.
+        /// </summary>
+        /// <param name="item">The object to locate in the <see cref="JArray"/>.</param>
+        /// <returns>
+        /// The index of <paramref name="item"/> if found in the list; otherwise, -1.
+        /// </returns>
+        public int IndexOf(JToken item)
+        {
+            return IndexOfItem(item);
+        }
+
+        /// <summary>
+        /// Inserts an item to the <see cref="JArray"/> at the specified index.
+        /// </summary>
+        /// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+        /// <param name="item">The object to insert into the <see cref="JArray"/>.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="index"/> is not a valid index in the <see cref="JArray"/>.
+        /// </exception>
+        public void Insert(int index, JToken item)
+        {
+            InsertItem(index, item, false);
+        }
+
+        /// <summary>
+        /// Removes the <see cref="JArray"/> item at the specified index.
+        /// </summary>
+        /// <param name="index">The zero-based index of the item to remove.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="index"/> is not a valid index in the <see cref="JArray"/>.
+        /// </exception>
+        public void RemoveAt(int index)
+        {
+            RemoveItemAt(index);
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="IEnumerator{T}"/> of <see cref="JToken"/> that can be used to iterate through the collection.
+        /// </returns>
+        public IEnumerator<JToken> GetEnumerator()
+        {
+            return Children().GetEnumerator();
+        }
+        #endregion
+
+        #region ICollection<JToken> Members
+        /// <summary>
+        /// Adds an item to the <see cref="JArray"/>.
+        /// </summary>
+        /// <param name="item">The object to add to the <see cref="JArray"/>.</param>
+        public void Add(JToken item)
+        {
+            Add((object)item);
+        }
+
+        /// <summary>
+        /// Removes all items from the <see cref="JArray"/>.
+        /// </summary>
+        public void Clear()
+        {
+            ClearItems();
+        }
+
+        /// <summary>
+        /// Determines whether the <see cref="JArray"/> contains a specific value.
+        /// </summary>
+        /// <param name="item">The object to locate in the <see cref="JArray"/>.</param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="item"/> is found in the <see cref="JArray"/>; otherwise, <c>false</c>.
+        /// </returns>
+        public bool Contains(JToken item)
+        {
+            return ContainsItem(item);
+        }
+
+        /// <summary>
+        /// Copies the elements of the <see cref="JArray"/> to an array, starting at a particular array index.
+        /// </summary>
+        /// <param name="array">The array.</param>
+        /// <param name="arrayIndex">Index of the array.</param>
+        public void CopyTo(JToken[] array, int arrayIndex)
+        {
+            CopyItemsTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="JArray"/> is read-only.
+        /// </summary>
+        /// <returns><c>true</c> if the <see cref="JArray"/> is read-only; otherwise, <c>false</c>.</returns>
+        public bool IsReadOnly => false;
+
+        /// <summary>
+        /// Removes the first occurrence of a specific object from the <see cref="JArray"/>.
+        /// </summary>
+        /// <param name="item">The object to remove from the <see cref="JArray"/>.</param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="item"/> was successfully removed from the <see cref="JArray"/>; otherwise, <c>false</c>. This method also returns <c>false</c> if <paramref name="item"/> is not found in the original <see cref="JArray"/>.
+        /// </returns>
+        public bool Remove(JToken item)
+        {
+            return RemoveItem(item);
+        }
+        #endregion
+
+        internal override int GetDeepHashCode()
+        {
+            return ContentsHashCode();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JConstructor.Async.cs b/Libs/Newtonsoft.Json/Linq/JConstructor.Async.cs
new file mode 100644
index 0000000..1feb80f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JConstructor.Async.cs
@@ -0,0 +1,106 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public partial class JConstructor
+    {
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/> asynchronously.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        public override async Task WriteToAsync(JsonWriter writer, CancellationToken cancellationToken, params JsonConverter[] converters)
+        {
+            await writer.WriteStartConstructorAsync(_name ?? string.Empty, cancellationToken).ConfigureAwait(false);
+
+            for (int i = 0; i < _values.Count; i++)
+            {
+                await _values[i].WriteToAsync(writer, cancellationToken, converters).ConfigureAwait(false);
+            }
+
+            await writer.WriteEndConstructorAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JConstructor"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JConstructor"/>.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous load. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JConstructor"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static Task<JConstructor> LoadAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            return LoadAsync(reader, null, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JConstructor"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JConstructor"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous load. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JConstructor"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static async Task<JConstructor> LoadAsync(JsonReader reader, JsonLoadSettings? settings, CancellationToken cancellationToken = default)
+        {
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JConstructor from JsonReader.");
+                }
+            }
+
+            await reader.MoveToContentAsync(cancellationToken).ConfigureAwait(false);
+
+            if (reader.TokenType != JsonToken.StartConstructor)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JConstructor from JsonReader. Current JsonReader item is not a constructor: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JConstructor c = new JConstructor((string)reader.Value!);
+            c.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            await c.ReadTokenFromAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+
+            return c;
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/Linq/JConstructor.cs b/Libs/Newtonsoft.Json/Linq/JConstructor.cs
new file mode 100644
index 0000000..62c7875
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JConstructor.cs
@@ -0,0 +1,250 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a JSON constructor.
+    /// </summary>
+    public partial class JConstructor : JContainer
+    {
+        private string? _name;
+        private readonly List<JToken> _values = new List<JToken>();
+
+        /// <summary>
+        /// Gets the container's children tokens.
+        /// </summary>
+        /// <value>The container's children tokens.</value>
+        protected override IList<JToken> ChildrenTokens => _values;
+
+        internal override int IndexOfItem(JToken? item)
+        {
+            if (item == null)
+            {
+                return -1;
+            }
+
+            return _values.IndexOfReference(item);
+        }
+
+        internal override void MergeItem(object content, JsonMergeSettings? settings)
+        {
+            if (!(content is JConstructor c))
+            {
+                return;
+            }
+
+            if (c.Name != null)
+            {
+                Name = c.Name;
+            }
+            MergeEnumerableContent(this, c, settings);
+        }
+
+        /// <summary>
+        /// Gets or sets the name of this constructor.
+        /// </summary>
+        /// <value>The constructor name.</value>
+        public string? Name
+        {
+            get => _name;
+            set => _name = value;
+        }
+
+        /// <summary>
+        /// Gets the node type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <value>The type.</value>
+        public override JTokenType Type => JTokenType.Constructor;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JConstructor"/> class.
+        /// </summary>
+        public JConstructor()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JConstructor"/> class from another <see cref="JConstructor"/> object.
+        /// </summary>
+        /// <param name="other">A <see cref="JConstructor"/> object to copy from.</param>
+        public JConstructor(JConstructor other)
+            : base(other)
+        {
+            _name = other.Name;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JConstructor"/> class with the specified name and content.
+        /// </summary>
+        /// <param name="name">The constructor name.</param>
+        /// <param name="content">The contents of the constructor.</param>
+        public JConstructor(string name, params object[] content)
+            : this(name, (object)content)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JConstructor"/> class with the specified name and content.
+        /// </summary>
+        /// <param name="name">The constructor name.</param>
+        /// <param name="content">The contents of the constructor.</param>
+        public JConstructor(string name, object content)
+            : this(name)
+        {
+            Add(content);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JConstructor"/> class with the specified name.
+        /// </summary>
+        /// <param name="name">The constructor name.</param>
+        public JConstructor(string name)
+        {
+            if (name == null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+
+            if (name.Length == 0)
+            {
+                throw new ArgumentException("Constructor name cannot be empty.", nameof(name));
+            }
+
+            _name = name;
+        }
+
+        internal override bool DeepEquals(JToken node)
+        {
+            return (node is JConstructor c && _name == c.Name && ContentsEqual(c));
+        }
+
+        internal override JToken CloneToken()
+        {
+            return new JConstructor(this);
+        }
+
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
+        {
+            writer.WriteStartConstructor(_name!);
+
+            int count = _values.Count;
+            for (int i = 0; i < count; i++)
+            {
+                _values[i].WriteTo(writer, converters);
+            }
+
+            writer.WriteEndConstructor();
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JToken"/> with the specified key.
+        /// </summary>
+        /// <value>The <see cref="JToken"/> with the specified key.</value>
+        public override JToken? this[object key]
+        {
+            get
+            {
+                ValidationUtils.ArgumentNotNull(key, nameof(key));
+
+                if (!(key is int i))
+                {
+                    throw new ArgumentException("Accessed JConstructor values with invalid key value: {0}. Argument position index expected.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(key)));
+                }
+
+                return GetItem(i);
+            }
+            set
+            {
+                ValidationUtils.ArgumentNotNull(key, nameof(key));
+
+                if (!(key is int i))
+                {
+                    throw new ArgumentException("Set JConstructor values with invalid key value: {0}. Argument position index expected.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(key)));
+                }
+
+                SetItem(i, value);
+            }
+        }
+
+        internal override int GetDeepHashCode()
+        {
+            return (_name?.GetHashCode() ?? 0) ^ ContentsHashCode();
+        }
+
+        /// <summary>
+        /// Loads a <see cref="JConstructor"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JConstructor"/>.</param>
+        /// <returns>A <see cref="JConstructor"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static JConstructor Load(JsonReader reader)
+        {
+            return Load(reader, null);
+        }
+
+        /// <summary>
+        /// Loads a <see cref="JConstructor"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JConstructor"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>A <see cref="JConstructor"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static JConstructor Load(JsonReader reader, JsonLoadSettings? settings)
+        {
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!reader.Read())
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JConstructor from JsonReader.");
+                }
+            }
+
+            reader.MoveToContent();
+
+            if (reader.TokenType != JsonToken.StartConstructor)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JConstructor from JsonReader. Current JsonReader item is not a constructor: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JConstructor c = new JConstructor((string)reader.Value!);
+            c.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            c.ReadTokenFrom(reader, settings);
+
+            return c;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JContainer.Async.cs b/Libs/Newtonsoft.Json/Linq/JContainer.Async.cs
new file mode 100644
index 0000000..1b3a4e1
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JContainer.Async.cs
@@ -0,0 +1,172 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public abstract partial class JContainer
+    {
+        internal async Task ReadTokenFromAsync(JsonReader reader, JsonLoadSettings? options, CancellationToken cancellationToken = default)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+            int startDepth = reader.Depth;
+
+            if (!await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
+            {
+                throw JsonReaderException.Create(reader, "Error reading {0} from JsonReader.".FormatWith(CultureInfo.InvariantCulture, GetType().Name));
+            }
+
+            await ReadContentFromAsync(reader, options, cancellationToken).ConfigureAwait(false);
+
+            if (reader.Depth > startDepth)
+            {
+                throw JsonReaderException.Create(reader, "Unexpected end of content while loading {0}.".FormatWith(CultureInfo.InvariantCulture, GetType().Name));
+            }
+        }
+
+        private async Task ReadContentFromAsync(JsonReader reader, JsonLoadSettings? settings, CancellationToken cancellationToken = default)
+        {
+            IJsonLineInfo? lineInfo = reader as IJsonLineInfo;
+
+            JContainer? parent = this;
+
+            do
+            {
+                if (parent is JProperty p && p.Value != null)
+                {
+                    if (parent == this)
+                    {
+                        return;
+                    }
+
+                    parent = parent.Parent;
+                }
+
+                MiscellaneousUtils.Assert(parent != null);
+
+                switch (reader.TokenType)
+                {
+                    case JsonToken.None:
+                        // new reader. move to actual content
+                        break;
+                    case JsonToken.StartArray:
+                        JArray a = new JArray();
+                        a.SetLineInfo(lineInfo, settings);
+                        parent.Add(a);
+                        parent = a;
+                        break;
+
+                    case JsonToken.EndArray:
+                        if (parent == this)
+                        {
+                            return;
+                        }
+
+                        parent = parent.Parent;
+                        break;
+                    case JsonToken.StartObject:
+                        JObject o = new JObject();
+                        o.SetLineInfo(lineInfo, settings);
+                        parent.Add(o);
+                        parent = o;
+                        break;
+                    case JsonToken.EndObject:
+                        if (parent == this)
+                        {
+                            return;
+                        }
+
+                        parent = parent.Parent;
+                        break;
+                    case JsonToken.StartConstructor:
+                        JConstructor constructor = new JConstructor(reader.Value!.ToString());
+                        constructor.SetLineInfo(lineInfo, settings);
+                        parent.Add(constructor);
+                        parent = constructor;
+                        break;
+                    case JsonToken.EndConstructor:
+                        if (parent == this)
+                        {
+                            return;
+                        }
+
+                        parent = parent.Parent;
+                        break;
+                    case JsonToken.String:
+                    case JsonToken.Integer:
+                    case JsonToken.Float:
+                    case JsonToken.Date:
+                    case JsonToken.Boolean:
+                    case JsonToken.Bytes:
+                        JValue v = new JValue(reader.Value);
+                        v.SetLineInfo(lineInfo, settings);
+                        parent.Add(v);
+                        break;
+                    case JsonToken.Comment:
+                        if (settings != null && settings.CommentHandling == CommentHandling.Load)
+                        {
+                            v = JValue.CreateComment(reader.Value!.ToString());
+                            v.SetLineInfo(lineInfo, settings);
+                            parent.Add(v);
+                        }
+                        break;
+                    case JsonToken.Null:
+                        v = JValue.CreateNull();
+                        v.SetLineInfo(lineInfo, settings);
+                        parent.Add(v);
+                        break;
+                    case JsonToken.Undefined:
+                        v = JValue.CreateUndefined();
+                        v.SetLineInfo(lineInfo, settings);
+                        parent.Add(v);
+                        break;
+                    case JsonToken.PropertyName:
+                        JProperty? property = ReadProperty(reader, settings, lineInfo, parent);
+                        if (property != null)
+                        {
+                            parent = property;
+                        }
+                        else
+                        {
+                            await reader.SkipAsync().ConfigureAwait(false);
+                        }
+                        break;
+                    default:
+                        throw new InvalidOperationException("The JsonReader should not be on a token of type {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+                }
+            } while (await reader.ReadAsync(cancellationToken).ConfigureAwait(false));
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/Linq/JContainer.cs b/Libs/Newtonsoft.Json/Linq/JContainer.cs
new file mode 100644
index 0000000..8b17d56
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JContainer.cs
@@ -0,0 +1,1225 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+using System.Collections.Specialized;
+#endif
+using System.Threading;
+using LC.Newtonsoft.Json.Utilities;
+using System.Collections;
+using System.Globalization;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a token that can contain other tokens.
+    /// </summary>
+    public abstract partial class JContainer : JToken, IList<JToken>
+#if HAVE_COMPONENT_MODEL
+        , ITypedList, IBindingList
+#endif
+        , IList
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+        , INotifyCollectionChanged
+#endif
+    {
+#if HAVE_COMPONENT_MODEL
+        internal ListChangedEventHandler? _listChanged;
+        internal AddingNewEventHandler? _addingNew;
+
+        /// <summary>
+        /// Occurs when the list changes or an item in the list changes.
+        /// </summary>
+        public event ListChangedEventHandler ListChanged
+        {
+            add => _listChanged += value;
+            remove => _listChanged -= value;
+        }
+
+        /// <summary>
+        /// Occurs before an item is added to the collection.
+        /// </summary>
+        public event AddingNewEventHandler AddingNew
+        {
+            add => _addingNew += value;
+            remove => _addingNew -= value;
+        }
+#endif
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+        internal NotifyCollectionChangedEventHandler? _collectionChanged;
+
+        /// <summary>
+        /// Occurs when the items list of the collection has changed, or the collection is reset.
+        /// </summary>
+        public event NotifyCollectionChangedEventHandler CollectionChanged
+        {
+            add { _collectionChanged += value; }
+            remove { _collectionChanged -= value; }
+        }
+#endif
+
+        /// <summary>
+        /// Gets the container's children tokens.
+        /// </summary>
+        /// <value>The container's children tokens.</value>
+        protected abstract IList<JToken> ChildrenTokens { get; }
+
+        private object? _syncRoot;
+#if (HAVE_COMPONENT_MODEL || HAVE_INOTIFY_COLLECTION_CHANGED)
+        private bool _busy;
+#endif
+
+        internal JContainer()
+        {
+        }
+
+        internal JContainer(JContainer other)
+            : this()
+        {
+            ValidationUtils.ArgumentNotNull(other, nameof(other));
+
+            int i = 0;
+            foreach (JToken child in other)
+            {
+                TryAddInternal(i, child, false);
+                i++;
+            }
+
+            CopyAnnotations(this, other);
+        }
+
+        internal void CheckReentrancy()
+        {
+#if (HAVE_COMPONENT_MODEL || HAVE_INOTIFY_COLLECTION_CHANGED)
+            if (_busy)
+            {
+                throw new InvalidOperationException("Cannot change {0} during a collection change event.".FormatWith(CultureInfo.InvariantCulture, GetType()));
+            }
+#endif
+        }
+
+        internal virtual IList<JToken> CreateChildrenCollection()
+        {
+            return new List<JToken>();
+        }
+
+#if HAVE_COMPONENT_MODEL
+        /// <summary>
+        /// Raises the <see cref="AddingNew"/> event.
+        /// </summary>
+        /// <param name="e">The <see cref="AddingNewEventArgs"/> instance containing the event data.</param>
+        protected virtual void OnAddingNew(AddingNewEventArgs e)
+        {
+            _addingNew?.Invoke(this, e);
+        }
+
+        /// <summary>
+        /// Raises the <see cref="ListChanged"/> event.
+        /// </summary>
+        /// <param name="e">The <see cref="ListChangedEventArgs"/> instance containing the event data.</param>
+        protected virtual void OnListChanged(ListChangedEventArgs e)
+        {
+            ListChangedEventHandler? handler = _listChanged;
+
+            if (handler != null)
+            {
+                _busy = true;
+                try
+                {
+                    handler(this, e);
+                }
+                finally
+                {
+                    _busy = false;
+                }
+            }
+        }
+#endif
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+        /// <summary>
+        /// Raises the <see cref="CollectionChanged"/> event.
+        /// </summary>
+        /// <param name="e">The <see cref="NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
+        protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+        {
+            NotifyCollectionChangedEventHandler? handler = _collectionChanged;
+
+            if (handler != null)
+            {
+                _busy = true;
+                try
+                {
+                    handler(this, e);
+                }
+                finally
+                {
+                    _busy = false;
+                }
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Gets a value indicating whether this token has child tokens.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this token has child values; otherwise, <c>false</c>.
+        /// </value>
+        public override bool HasValues => ChildrenTokens.Count > 0;
+
+        internal bool ContentsEqual(JContainer container)
+        {
+            if (container == this)
+            {
+                return true;
+            }
+
+            IList<JToken> t1 = ChildrenTokens;
+            IList<JToken> t2 = container.ChildrenTokens;
+
+            if (t1.Count != t2.Count)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < t1.Count; i++)
+            {
+                if (!t1[i].DeepEquals(t2[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Get the first child token of this token.
+        /// </summary>
+        /// <value>
+        /// A <see cref="JToken"/> containing the first child token of the <see cref="JToken"/>.
+        /// </value>
+        public override JToken? First
+        {
+            get
+            {
+                IList<JToken> children = ChildrenTokens;
+                return (children.Count > 0) ? children[0] : null;
+            }
+        }
+
+        /// <summary>
+        /// Get the last child token of this token.
+        /// </summary>
+        /// <value>
+        /// A <see cref="JToken"/> containing the last child token of the <see cref="JToken"/>.
+        /// </value>
+        public override JToken? Last
+        {
+            get
+            {
+                IList<JToken> children = ChildrenTokens;
+                int count = children.Count;
+                return (count > 0) ? children[count - 1] : null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a collection of the child tokens of this token, in document order.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> containing the child tokens of this <see cref="JToken"/>, in document order.
+        /// </returns>
+        public override JEnumerable<JToken> Children()
+        {
+            return new JEnumerable<JToken>(ChildrenTokens);
+        }
+
+        /// <summary>
+        /// Returns a collection of the child values of this token, in document order.
+        /// </summary>
+        /// <typeparam name="T">The type to convert the values to.</typeparam>
+        /// <returns>
+        /// A <see cref="IEnumerable{T}"/> containing the child values of this <see cref="JToken"/>, in document order.
+        /// </returns>
+        public override IEnumerable<T?> Values<T>() where T : default
+        {
+            return ChildrenTokens.Convert<JToken, T>();
+        }
+
+        /// <summary>
+        /// Returns a collection of the descendant tokens for this token in document order.
+        /// </summary>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> containing the descendant tokens of the <see cref="JToken"/>.</returns>
+        public IEnumerable<JToken> Descendants()
+        {
+            return GetDescendants(false);
+        }
+
+        /// <summary>
+        /// Returns a collection of the tokens that contain this token, and all descendant tokens of this token, in document order.
+        /// </summary>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> containing this token, and all the descendant tokens of the <see cref="JToken"/>.</returns>
+        public IEnumerable<JToken> DescendantsAndSelf()
+        {
+            return GetDescendants(true);
+        }
+
+        internal IEnumerable<JToken> GetDescendants(bool self)
+        {
+            if (self)
+            {
+                yield return this;
+            }
+
+            foreach (JToken o in ChildrenTokens)
+            {
+                yield return o;
+                if (o is JContainer c)
+                {
+                    foreach (JToken d in c.Descendants())
+                    {
+                        yield return d;
+                    }
+                }
+            }
+        }
+
+        internal bool IsMultiContent([NotNullWhen(true)]object? content)
+        {
+            return (content is IEnumerable && !(content is string) && !(content is JToken) && !(content is byte[]));
+        }
+
+        internal JToken EnsureParentToken(JToken? item, bool skipParentCheck)
+        {
+            if (item == null)
+            {
+                return JValue.CreateNull();
+            }
+
+            if (skipParentCheck)
+            {
+                return item;
+            }
+
+            // to avoid a token having multiple parents or creating a recursive loop, create a copy if...
+            // the item already has a parent
+            // the item is being added to itself
+            // the item is being added to the root parent of itself
+            if (item.Parent != null || item == this || (item.HasValues && Root == item))
+            {
+                item = item.CloneToken();
+            }
+
+            return item;
+        }
+
+        internal abstract int IndexOfItem(JToken? item);
+
+        internal virtual bool InsertItem(int index, JToken? item, bool skipParentCheck)
+        {
+            IList<JToken> children = ChildrenTokens;
+
+            if (index > children.Count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), "Index must be within the bounds of the List.");
+            }
+
+            CheckReentrancy();
+
+            item = EnsureParentToken(item, skipParentCheck);
+
+            JToken? previous = (index == 0) ? null : children[index - 1];
+            // haven't inserted new token yet so next token is still at the inserting index
+            JToken? next = (index == children.Count) ? null : children[index];
+
+            ValidateToken(item, null);
+
+            item.Parent = this;
+
+            item.Previous = previous;
+            if (previous != null)
+            {
+                previous.Next = item;
+            }
+
+            item.Next = next;
+            if (next != null)
+            {
+                next.Previous = item;
+            }
+
+            children.Insert(index, item);
+
+#if HAVE_COMPONENT_MODEL
+            if (_listChanged != null)
+            {
+                OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, index));
+            }
+#endif
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+            if (_collectionChanged != null)
+            {
+                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
+            }
+#endif
+
+            return true;
+        }
+
+        internal virtual void RemoveItemAt(int index)
+        {
+            IList<JToken> children = ChildrenTokens;
+
+            if (index < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), "Index is less than 0.");
+            }
+            if (index >= children.Count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), "Index is equal to or greater than Count.");
+            }
+
+            CheckReentrancy();
+
+            JToken item = children[index];
+            JToken? previous = (index == 0) ? null : children[index - 1];
+            JToken? next = (index == children.Count - 1) ? null : children[index + 1];
+
+            if (previous != null)
+            {
+                previous.Next = next;
+            }
+            if (next != null)
+            {
+                next.Previous = previous;
+            }
+
+            item.Parent = null;
+            item.Previous = null;
+            item.Next = null;
+
+            children.RemoveAt(index);
+
+#if HAVE_COMPONENT_MODEL
+            if (_listChanged != null)
+            {
+                OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, index));
+            }
+#endif
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+            if (_collectionChanged != null)
+            {
+                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));
+            }
+#endif
+        }
+
+        internal virtual bool RemoveItem(JToken? item)
+        {
+            if (item != null)
+            {
+                int index = IndexOfItem(item);
+                if (index >= 0)
+                {
+                    RemoveItemAt(index);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        internal virtual JToken GetItem(int index)
+        {
+            return ChildrenTokens[index];
+        }
+
+        internal virtual void SetItem(int index, JToken? item)
+        {
+            IList<JToken> children = ChildrenTokens;
+
+            if (index < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), "Index is less than 0.");
+            }
+            if (index >= children.Count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), "Index is equal to or greater than Count.");
+            }
+
+            JToken existing = children[index];
+
+            if (IsTokenUnchanged(existing, item))
+            {
+                return;
+            }
+
+            CheckReentrancy();
+
+            item = EnsureParentToken(item, false);
+
+            ValidateToken(item, existing);
+
+            JToken? previous = (index == 0) ? null : children[index - 1];
+            JToken? next = (index == children.Count - 1) ? null : children[index + 1];
+
+            item.Parent = this;
+
+            item.Previous = previous;
+            if (previous != null)
+            {
+                previous.Next = item;
+            }
+
+            item.Next = next;
+            if (next != null)
+            {
+                next.Previous = item;
+            }
+
+            children[index] = item;
+
+            existing.Parent = null;
+            existing.Previous = null;
+            existing.Next = null;
+
+#if HAVE_COMPONENT_MODEL
+            if (_listChanged != null)
+            {
+                OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, index));
+            }
+#endif
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+            if (_collectionChanged != null)
+            {
+                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, item, existing, index));
+            }
+#endif
+        }
+
+        internal virtual void ClearItems()
+        {
+            CheckReentrancy();
+
+            IList<JToken> children = ChildrenTokens;
+
+            foreach (JToken item in children)
+            {
+                item.Parent = null;
+                item.Previous = null;
+                item.Next = null;
+            }
+
+            children.Clear();
+
+#if HAVE_COMPONENT_MODEL
+            if (_listChanged != null)
+            {
+                OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
+            }
+#endif
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+            if (_collectionChanged != null)
+            {
+                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            }
+#endif
+        }
+
+        internal virtual void ReplaceItem(JToken existing, JToken replacement)
+        {
+            if (existing == null || existing.Parent != this)
+            {
+                return;
+            }
+
+            int index = IndexOfItem(existing);
+            SetItem(index, replacement);
+        }
+
+        internal virtual bool ContainsItem(JToken? item)
+        {
+            return (IndexOfItem(item) != -1);
+        }
+
+        internal virtual void CopyItemsTo(Array array, int arrayIndex)
+        {
+            if (array == null)
+            {
+                throw new ArgumentNullException(nameof(array));
+            }
+            if (arrayIndex < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(arrayIndex), "arrayIndex is less than 0.");
+            }
+            if (arrayIndex >= array.Length && arrayIndex != 0)
+            {
+                throw new ArgumentException("arrayIndex is equal to or greater than the length of array.");
+            }
+            if (Count > array.Length - arrayIndex)
+            {
+                throw new ArgumentException("The number of elements in the source JObject is greater than the available space from arrayIndex to the end of the destination array.");
+            }
+
+            int index = 0;
+            foreach (JToken token in ChildrenTokens)
+            {
+                array.SetValue(token, arrayIndex + index);
+                index++;
+            }
+        }
+
+        internal static bool IsTokenUnchanged(JToken currentValue, JToken? newValue)
+        {
+            if (currentValue is JValue v1)
+            {
+                if (newValue == null)
+                {
+                    // null will get turned into a JValue of type null
+                    return v1.Type == JTokenType.Null;
+                }
+
+                return v1.Equals(newValue);
+            }
+
+            return false;
+        }
+
+        internal virtual void ValidateToken(JToken o, JToken? existing)
+        {
+            ValidationUtils.ArgumentNotNull(o, nameof(o));
+
+            if (o.Type == JTokenType.Property)
+            {
+                throw new ArgumentException("Can not add {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, o.GetType(), GetType()));
+            }
+        }
+
+        /// <summary>
+        /// Adds the specified content as children of this <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="content">The content to be added.</param>
+        public virtual void Add(object? content)
+        {
+            TryAddInternal(ChildrenTokens.Count, content, false);
+        }
+
+        internal bool TryAdd(object? content)
+        {
+            return TryAddInternal(ChildrenTokens.Count, content, false);
+        }
+
+        internal void AddAndSkipParentCheck(JToken token)
+        {
+            TryAddInternal(ChildrenTokens.Count, token, true);
+        }
+
+        /// <summary>
+        /// Adds the specified content as the first children of this <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="content">The content to be added.</param>
+        public void AddFirst(object? content)
+        {
+            TryAddInternal(0, content, false);
+        }
+
+        internal bool TryAddInternal(int index, object? content, bool skipParentCheck)
+        {
+            if (IsMultiContent(content))
+            {
+                IEnumerable enumerable = (IEnumerable)content;
+
+                int multiIndex = index;
+                foreach (object c in enumerable)
+                {
+                    TryAddInternal(multiIndex, c, skipParentCheck);
+                    multiIndex++;
+                }
+
+                return true;
+            }
+            else
+            {
+                JToken item = CreateFromContent(content);
+
+                return InsertItem(index, item, skipParentCheck);
+            }
+        }
+
+        internal static JToken CreateFromContent(object? content)
+        {
+            if (content is JToken token)
+            {
+                return token;
+            }
+
+            return new JValue(content);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JsonWriter"/> that can be used to add tokens to the <see cref="JToken"/>.
+        /// </summary>
+        /// <returns>A <see cref="JsonWriter"/> that is ready to have content written to it.</returns>
+        public JsonWriter CreateWriter()
+        {
+            return new JTokenWriter(this);
+        }
+
+        /// <summary>
+        /// Replaces the child nodes of this token with the specified content.
+        /// </summary>
+        /// <param name="content">The content.</param>
+        public void ReplaceAll(object content)
+        {
+            ClearItems();
+            Add(content);
+        }
+
+        /// <summary>
+        /// Removes the child nodes from this token.
+        /// </summary>
+        public void RemoveAll()
+        {
+            ClearItems();
+        }
+
+        internal abstract void MergeItem(object content, JsonMergeSettings? settings);
+
+        /// <summary>
+        /// Merge the specified content into this <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="content">The content to be merged.</param>
+        public void Merge(object content)
+        {
+            MergeItem(content, null);
+        }
+
+        /// <summary>
+        /// Merge the specified content into this <see cref="JToken"/> using <see cref="JsonMergeSettings"/>.
+        /// </summary>
+        /// <param name="content">The content to be merged.</param>
+        /// <param name="settings">The <see cref="JsonMergeSettings"/> used to merge the content.</param>
+        public void Merge(object content, JsonMergeSettings? settings)
+        {
+            MergeItem(content, settings);
+        }
+
+        internal void ReadTokenFrom(JsonReader reader, JsonLoadSettings? options)
+        {
+            int startDepth = reader.Depth;
+
+            if (!reader.Read())
+            {
+                throw JsonReaderException.Create(reader, "Error reading {0} from JsonReader.".FormatWith(CultureInfo.InvariantCulture, GetType().Name));
+            }
+
+            ReadContentFrom(reader, options);
+
+            int endDepth = reader.Depth;
+
+            if (endDepth > startDepth)
+            {
+                throw JsonReaderException.Create(reader, "Unexpected end of content while loading {0}.".FormatWith(CultureInfo.InvariantCulture, GetType().Name));
+            }
+        }
+
+        internal void ReadContentFrom(JsonReader r, JsonLoadSettings? settings)
+        {
+            ValidationUtils.ArgumentNotNull(r, nameof(r));
+            IJsonLineInfo? lineInfo = r as IJsonLineInfo;
+
+            JContainer? parent = this;
+
+            do
+            {
+                if (parent is JProperty p && p.Value != null)
+                {
+                    if (parent == this)
+                    {
+                        return;
+                    }
+
+                    parent = parent.Parent;
+                }
+
+                MiscellaneousUtils.Assert(parent != null);
+
+                switch (r.TokenType)
+                {
+                    case JsonToken.None:
+                        // new reader. move to actual content
+                        break;
+                    case JsonToken.StartArray:
+                        JArray a = new JArray();
+                        a.SetLineInfo(lineInfo, settings);
+                        parent.Add(a);
+                        parent = a;
+                        break;
+
+                    case JsonToken.EndArray:
+                        if (parent == this)
+                        {
+                            return;
+                        }
+
+                        parent = parent.Parent;
+                        break;
+                    case JsonToken.StartObject:
+                        JObject o = new JObject();
+                        o.SetLineInfo(lineInfo, settings);
+                        parent.Add(o);
+                        parent = o;
+                        break;
+                    case JsonToken.EndObject:
+                        if (parent == this)
+                        {
+                            return;
+                        }
+
+                        parent = parent.Parent;
+                        break;
+                    case JsonToken.StartConstructor:
+                        JConstructor constructor = new JConstructor(r.Value!.ToString());
+                        constructor.SetLineInfo(lineInfo, settings);
+                        parent.Add(constructor);
+                        parent = constructor;
+                        break;
+                    case JsonToken.EndConstructor:
+                        if (parent == this)
+                        {
+                            return;
+                        }
+
+                        parent = parent.Parent;
+                        break;
+                    case JsonToken.String:
+                    case JsonToken.Integer:
+                    case JsonToken.Float:
+                    case JsonToken.Date:
+                    case JsonToken.Boolean:
+                    case JsonToken.Bytes:
+                        JValue v = new JValue(r.Value);
+                        v.SetLineInfo(lineInfo, settings);
+                        parent.Add(v);
+                        break;
+                    case JsonToken.Comment:
+                        if (settings != null && settings.CommentHandling == CommentHandling.Load)
+                        {
+                            v = JValue.CreateComment(r.Value!.ToString());
+                            v.SetLineInfo(lineInfo, settings);
+                            parent.Add(v);
+                        }
+                        break;
+                    case JsonToken.Null:
+                        v = JValue.CreateNull();
+                        v.SetLineInfo(lineInfo, settings);
+                        parent.Add(v);
+                        break;
+                    case JsonToken.Undefined:
+                        v = JValue.CreateUndefined();
+                        v.SetLineInfo(lineInfo, settings);
+                        parent.Add(v);
+                        break;
+                    case JsonToken.PropertyName:
+                        JProperty? property = ReadProperty(r, settings, lineInfo, parent);
+                        if (property != null)
+                        {
+                            parent = property;
+                        }
+                        else
+                        {
+                            r.Skip();
+                        }
+                        break;
+                    default:
+                        throw new InvalidOperationException("The JsonReader should not be on a token of type {0}.".FormatWith(CultureInfo.InvariantCulture, r.TokenType));
+                }
+            } while (r.Read());
+        }
+
+        private static JProperty? ReadProperty(JsonReader r, JsonLoadSettings? settings, IJsonLineInfo? lineInfo, JContainer parent)
+        {
+            DuplicatePropertyNameHandling duplicatePropertyNameHandling = settings?.DuplicatePropertyNameHandling ?? DuplicatePropertyNameHandling.Replace;
+
+            JObject parentObject = (JObject)parent;
+            string propertyName = r.Value!.ToString();
+            JProperty? existingPropertyWithName = parentObject.Property(propertyName, StringComparison.Ordinal);
+            if (existingPropertyWithName != null)
+            {
+                if (duplicatePropertyNameHandling == DuplicatePropertyNameHandling.Ignore)
+                {
+                    return null;
+                }
+                else if (duplicatePropertyNameHandling == DuplicatePropertyNameHandling.Error)
+                {
+                    throw JsonReaderException.Create(r, "Property with the name '{0}' already exists in the current JSON object.".FormatWith(CultureInfo.InvariantCulture, propertyName));
+                }
+            }
+
+            JProperty property = new JProperty(propertyName);
+            property.SetLineInfo(lineInfo, settings);
+            // handle multiple properties with the same name in JSON
+            if (existingPropertyWithName == null)
+            {
+                parent.Add(property);
+            }
+            else
+            {
+                existingPropertyWithName.Replace(property);
+            }
+
+            return property;
+        }
+
+        internal int ContentsHashCode()
+        {
+            int hashCode = 0;
+            foreach (JToken item in ChildrenTokens)
+            {
+                hashCode ^= item.GetDeepHashCode();
+            }
+            return hashCode;
+        }
+
+#if HAVE_COMPONENT_MODEL
+        string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
+        {
+            return string.Empty;
+        }
+
+        PropertyDescriptorCollection? ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors)
+        {
+            ICustomTypeDescriptor? d = First as ICustomTypeDescriptor;
+            return d?.GetProperties();
+        }
+#endif
+
+        #region IList<JToken> Members
+        int IList<JToken>.IndexOf(JToken item)
+        {
+            return IndexOfItem(item);
+        }
+
+        void IList<JToken>.Insert(int index, JToken item)
+        {
+            InsertItem(index, item, false);
+        }
+
+        void IList<JToken>.RemoveAt(int index)
+        {
+            RemoveItemAt(index);
+        }
+
+        JToken IList<JToken>.this[int index]
+        {
+            get => GetItem(index);
+            set => SetItem(index, value);
+        }
+        #endregion
+
+        #region ICollection<JToken> Members
+        void ICollection<JToken>.Add(JToken item)
+        {
+            Add(item);
+        }
+
+        void ICollection<JToken>.Clear()
+        {
+            ClearItems();
+        }
+
+        bool ICollection<JToken>.Contains(JToken item)
+        {
+            return ContainsItem(item);
+        }
+
+        void ICollection<JToken>.CopyTo(JToken[] array, int arrayIndex)
+        {
+            CopyItemsTo(array, arrayIndex);
+        }
+
+        bool ICollection<JToken>.IsReadOnly => false;
+
+        bool ICollection<JToken>.Remove(JToken item)
+        {
+            return RemoveItem(item);
+        }
+        #endregion
+
+        private JToken? EnsureValue(object value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            if (value is JToken token)
+            {
+                return token;
+            }
+
+            throw new ArgumentException("Argument is not a JToken.");
+        }
+
+        #region IList Members
+        int IList.Add(object value)
+        {
+            Add(EnsureValue(value));
+            return Count - 1;
+        }
+
+        void IList.Clear()
+        {
+            ClearItems();
+        }
+
+        bool IList.Contains(object value)
+        {
+            return ContainsItem(EnsureValue(value));
+        }
+
+        int IList.IndexOf(object value)
+        {
+            return IndexOfItem(EnsureValue(value));
+        }
+
+        void IList.Insert(int index, object value)
+        {
+            InsertItem(index, EnsureValue(value), false);
+        }
+
+        bool IList.IsFixedSize => false;
+
+        bool IList.IsReadOnly => false;
+
+        void IList.Remove(object value)
+        {
+            RemoveItem(EnsureValue(value));
+        }
+
+        void IList.RemoveAt(int index)
+        {
+            RemoveItemAt(index);
+        }
+
+        object IList.this[int index]
+        {
+            get => GetItem(index);
+            set => SetItem(index, EnsureValue(value));
+        }
+        #endregion
+
+        #region ICollection Members
+        void ICollection.CopyTo(Array array, int index)
+        {
+            CopyItemsTo(array, index);
+        }
+
+        /// <summary>
+        /// Gets the count of child JSON tokens.
+        /// </summary>
+        /// <value>The count of child JSON tokens.</value>
+        public int Count => ChildrenTokens.Count;
+
+        bool ICollection.IsSynchronized => false;
+
+        object ICollection.SyncRoot
+        {
+            get
+            {
+                if (_syncRoot == null)
+                {
+                    Interlocked.CompareExchange(ref _syncRoot, new object(), null);
+                }
+
+                return _syncRoot;
+            }
+        }
+        #endregion
+
+        #region IBindingList Members
+#if HAVE_COMPONENT_MODEL
+        void IBindingList.AddIndex(PropertyDescriptor property)
+        {
+        }
+
+        object IBindingList.AddNew()
+        {
+            AddingNewEventArgs args = new AddingNewEventArgs();
+            OnAddingNew(args);
+
+            if (args.NewObject == null)
+            {
+                throw new JsonException("Could not determine new value to add to '{0}'.".FormatWith(CultureInfo.InvariantCulture, GetType()));
+            }
+
+            if (!(args.NewObject is JToken newItem))
+            {
+                throw new JsonException("New item to be added to collection must be compatible with {0}.".FormatWith(CultureInfo.InvariantCulture, typeof(JToken)));
+            }
+
+            Add(newItem);
+
+            return newItem;
+        }
+
+        bool IBindingList.AllowEdit => true;
+
+        bool IBindingList.AllowNew => true;
+
+        bool IBindingList.AllowRemove => true;
+
+        void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction)
+        {
+            throw new NotSupportedException();
+        }
+
+        int IBindingList.Find(PropertyDescriptor property, object key)
+        {
+            throw new NotSupportedException();
+        }
+
+        bool IBindingList.IsSorted => false;
+
+        void IBindingList.RemoveIndex(PropertyDescriptor property)
+        {
+        }
+
+        void IBindingList.RemoveSort()
+        {
+            throw new NotSupportedException();
+        }
+
+        ListSortDirection IBindingList.SortDirection => ListSortDirection.Ascending;
+
+        PropertyDescriptor? IBindingList.SortProperty => null;
+
+        bool IBindingList.SupportsChangeNotification => true;
+
+        bool IBindingList.SupportsSearching => false;
+
+        bool IBindingList.SupportsSorting => false;
+#endif
+        #endregion
+
+        internal static void MergeEnumerableContent(JContainer target, IEnumerable content, JsonMergeSettings? settings)
+        {
+            switch (settings?.MergeArrayHandling ?? MergeArrayHandling.Concat)
+            {
+                case MergeArrayHandling.Concat:
+                    foreach (JToken item in content)
+                    {
+                        target.Add(item);
+                    }
+                    break;
+                case MergeArrayHandling.Union:
+#if HAVE_HASH_SET
+                    HashSet<JToken> items = new HashSet<JToken>(target, EqualityComparer);
+
+                    foreach (JToken item in content)
+                    {
+                        if (items.Add(item))
+                        {
+                            target.Add(item);
+                        }
+                    }
+#else
+                    Dictionary<JToken, bool> items = new Dictionary<JToken, bool>(EqualityComparer);
+                    foreach (JToken t in target)
+                    {
+                        items[t] = true;
+                    }
+
+                    foreach (JToken item in content)
+                    {
+                        if (!items.ContainsKey(item))
+                        {
+                            items[item] = true;
+                            target.Add(item);
+                        }
+                    }
+#endif
+                    break;
+                case MergeArrayHandling.Replace:
+                    if (target == content)
+                    {
+                        break;
+                    }
+                    target.ClearItems();
+                    foreach (JToken item in content)
+                    {
+                        target.Add(item);
+                    }
+                    break;
+                case MergeArrayHandling.Merge:
+                    int i = 0;
+                    foreach (object targetItem in content)
+                    {
+                        if (i < target.Count)
+                        {
+                            JToken? sourceItem = target[i];
+
+                            if (sourceItem is JContainer existingContainer)
+                            {
+                                existingContainer.Merge(targetItem, settings);
+                            }
+                            else
+                            {
+                                if (targetItem != null)
+                                {
+                                    JToken contentValue = CreateFromContent(targetItem);
+                                    if (contentValue.Type != JTokenType.Null)
+                                    {
+                                        target[i] = contentValue;
+                                    }
+                                }
+                            }
+                        }
+                        else
+                        {
+                            target.Add(targetItem);
+                        }
+
+                        i++;
+                    }
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(settings), "Unexpected merge array handling when merging JSON.");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JEnumerable.cs b/Libs/Newtonsoft.Json/Linq/JEnumerable.cs
new file mode 100644
index 0000000..9bd3a49
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JEnumerable.cs
@@ -0,0 +1,140 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+using System.Collections;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a collection of <see cref="JToken"/> objects.
+    /// </summary>
+    /// <typeparam name="T">The type of token.</typeparam>
+    public readonly struct JEnumerable<T> : IJEnumerable<T>, IEquatable<JEnumerable<T>> where T : JToken
+    {
+        /// <summary>
+        /// An empty collection of <see cref="JToken"/> objects.
+        /// </summary>
+        public static readonly JEnumerable<T> Empty = new JEnumerable<T>(Enumerable.Empty<T>());
+
+        private readonly IEnumerable<T> _enumerable;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JEnumerable{T}"/> struct.
+        /// </summary>
+        /// <param name="enumerable">The enumerable.</param>
+        public JEnumerable(IEnumerable<T> enumerable)
+        {
+            ValidationUtils.ArgumentNotNull(enumerable, nameof(enumerable));
+
+            _enumerable = enumerable;
+        }
+
+        /// <summary>
+        /// Returns an enumerator that can be used to iterate through the collection.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="IEnumerator{T}"/> that can be used to iterate through the collection.
+        /// </returns>
+        public IEnumerator<T> GetEnumerator()
+        {
+            return (_enumerable ?? Empty).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// Gets the <see cref="IJEnumerable{T}"/> of <see cref="JToken"/> with the specified key.
+        /// </summary>
+        /// <value></value>
+        public IJEnumerable<JToken> this[object key]
+        {
+            get
+            {
+                if (_enumerable == null)
+                {
+                    return JEnumerable<JToken>.Empty;
+                }
+
+                return new JEnumerable<JToken>(_enumerable.Values<T, JToken>(key)!);
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="JEnumerable{T}"/> is equal to this instance.
+        /// </summary>
+        /// <param name="other">The <see cref="JEnumerable{T}"/> to compare with this instance.</param>
+        /// <returns>
+        /// 	<c>true</c> if the specified <see cref="JEnumerable{T}"/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public bool Equals(JEnumerable<T> other)
+        {
+            return Equals(_enumerable, other._enumerable);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="Object"/> is equal to this instance.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare with this instance.</param>
+        /// <returns>
+        /// 	<c>true</c> if the specified <see cref="Object"/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is JEnumerable<T> enumerable)
+            {
+                return Equals(enumerable);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode()
+        {
+            if (_enumerable == null)
+            {
+                return 0;
+            }
+
+            return _enumerable.GetHashCode();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JObject.Async.cs b/Libs/Newtonsoft.Json/Linq/JObject.Async.cs
new file mode 100644
index 0000000..0c5d6f9
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JObject.Async.cs
@@ -0,0 +1,129 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public partial class JObject
+    {
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/> asynchronously.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        public override Task WriteToAsync(JsonWriter writer, CancellationToken cancellationToken, params JsonConverter[] converters)
+        {
+            Task t = writer.WriteStartObjectAsync(cancellationToken);
+            if (!t.IsCompletedSucessfully())
+            {
+                return AwaitProperties(t, 0, writer, cancellationToken, converters);
+            }
+
+            for (int i = 0; i < _properties.Count; i++)
+            {
+                t = _properties[i].WriteToAsync(writer, cancellationToken, converters);
+                if (!t.IsCompletedSucessfully())
+                {
+                    return AwaitProperties(t, i + 1, writer, cancellationToken, converters);
+                }
+            }
+
+            return writer.WriteEndObjectAsync(cancellationToken);
+
+            // Local functions, params renamed (capitalized) so as not to capture and allocate when calling async
+            async Task AwaitProperties(Task task, int i, JsonWriter Writer, CancellationToken CancellationToken, JsonConverter[] Converters)
+            {
+                await task.ConfigureAwait(false);
+                for (; i < _properties.Count; i++)
+                {
+                    await _properties[i].WriteToAsync(Writer, CancellationToken, Converters).ConfigureAwait(false);
+                }
+
+                await Writer.WriteEndObjectAsync(CancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JObject"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JObject"/>.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous load. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JObject"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static Task<JObject> LoadAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            return LoadAsync(reader, null, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JObject"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JObject"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous load. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JObject"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static async Task<JObject> LoadAsync(JsonReader reader, JsonLoadSettings? settings, CancellationToken cancellationToken = default)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JObject from JsonReader.");
+                }
+            }
+
+            await reader.MoveToContentAsync(cancellationToken).ConfigureAwait(false);
+
+            if (reader.TokenType != JsonToken.StartObject)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JObject from JsonReader. Current JsonReader item is not an object: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JObject o = new JObject();
+            o.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            await o.ReadTokenFromAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+
+            return o;
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/Linq/JObject.cs b/Libs/Newtonsoft.Json/Linq/JObject.cs
new file mode 100644
index 0000000..0e63fcf
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JObject.cs
@@ -0,0 +1,857 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+#endif
+using System.ComponentModel;
+#if HAVE_DYNAMIC
+using System.Dynamic;
+using System.Linq.Expressions;
+#endif
+using System.IO;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a JSON object.
+    /// </summary>
+    /// <example>
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\LinqToJsonTests.cs" region="LinqToJsonCreateParse" title="Parsing a JSON Object from Text" />
+    /// </example>
+    public partial class JObject : JContainer, IDictionary<string, JToken?>, INotifyPropertyChanged
+#if HAVE_COMPONENT_MODEL
+        , ICustomTypeDescriptor
+#endif
+#if HAVE_INOTIFY_PROPERTY_CHANGING
+        , INotifyPropertyChanging
+#endif
+    {
+        private readonly JPropertyKeyedCollection _properties = new JPropertyKeyedCollection();
+
+        /// <summary>
+        /// Gets the container's children tokens.
+        /// </summary>
+        /// <value>The container's children tokens.</value>
+        protected override IList<JToken> ChildrenTokens => _properties;
+
+        /// <summary>
+        /// Occurs when a property value changes.
+        /// </summary>
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+#if HAVE_INOTIFY_PROPERTY_CHANGING
+        /// <summary>
+        /// Occurs when a property value is changing.
+        /// </summary>
+        public event PropertyChangingEventHandler? PropertyChanging;
+#endif
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JObject"/> class.
+        /// </summary>
+        public JObject()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JObject"/> class from another <see cref="JObject"/> object.
+        /// </summary>
+        /// <param name="other">A <see cref="JObject"/> object to copy from.</param>
+        public JObject(JObject other)
+            : base(other)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JObject"/> class with the specified content.
+        /// </summary>
+        /// <param name="content">The contents of the object.</param>
+        public JObject(params object[] content)
+            : this((object)content)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JObject"/> class with the specified content.
+        /// </summary>
+        /// <param name="content">The contents of the object.</param>
+        public JObject(object content)
+        {
+            Add(content);
+        }
+
+        internal override bool DeepEquals(JToken node)
+        {
+            if (!(node is JObject t))
+            {
+                return false;
+            }
+
+            return _properties.Compare(t._properties);
+        }
+
+        internal override int IndexOfItem(JToken? item)
+        {
+            if (item == null)
+            {
+                return -1;
+            }
+
+            return _properties.IndexOfReference(item);
+        }
+
+        internal override bool InsertItem(int index, JToken? item, bool skipParentCheck)
+        {
+            // don't add comments to JObject, no name to reference comment by
+            if (item != null && item.Type == JTokenType.Comment)
+            {
+                return false;
+            }
+
+            return base.InsertItem(index, item, skipParentCheck);
+        }
+
+        internal override void ValidateToken(JToken o, JToken? existing)
+        {
+            ValidationUtils.ArgumentNotNull(o, nameof(o));
+
+            if (o.Type != JTokenType.Property)
+            {
+                throw new ArgumentException("Can not add {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, o.GetType(), GetType()));
+            }
+
+            JProperty newProperty = (JProperty)o;
+
+            if (existing != null)
+            {
+                JProperty existingProperty = (JProperty)existing;
+
+                if (newProperty.Name == existingProperty.Name)
+                {
+                    return;
+                }
+            }
+
+            if (_properties.TryGetValue(newProperty.Name, out existing))
+            {
+                throw new ArgumentException("Can not add property {0} to {1}. Property with the same name already exists on object.".FormatWith(CultureInfo.InvariantCulture, newProperty.Name, GetType()));
+            }
+        }
+
+        internal override void MergeItem(object content, JsonMergeSettings? settings)
+        {
+            if (!(content is JObject o))
+            {
+                return;
+            }
+
+            foreach (KeyValuePair<string, JToken?> contentItem in o)
+            {
+                JProperty? existingProperty = Property(contentItem.Key, settings?.PropertyNameComparison ?? StringComparison.Ordinal);
+
+                if (existingProperty == null)
+                {
+                    Add(contentItem.Key, contentItem.Value);
+                }
+                else if (contentItem.Value != null)
+                {
+                    if (!(existingProperty.Value is JContainer existingContainer) || existingContainer.Type != contentItem.Value.Type)
+                    {
+                        if (!IsNull(contentItem.Value) || settings?.MergeNullValueHandling == MergeNullValueHandling.Merge)
+                        {
+                            existingProperty.Value = contentItem.Value;
+                        }
+                    }
+                    else
+                    {
+                        existingContainer.Merge(contentItem.Value, settings);
+                    }
+                }
+            }
+        }
+
+        private static bool IsNull(JToken token)
+        {
+            if (token.Type == JTokenType.Null)
+            {
+                return true;
+            }
+
+            if (token is JValue v && v.Value == null)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        internal void InternalPropertyChanged(JProperty childProperty)
+        {
+            OnPropertyChanged(childProperty.Name);
+#if HAVE_COMPONENT_MODEL
+            if (_listChanged != null)
+            {
+                OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, IndexOfItem(childProperty)));
+            }
+#endif
+#if HAVE_INOTIFY_COLLECTION_CHANGED
+            if (_collectionChanged != null)
+            {
+                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, childProperty, childProperty, IndexOfItem(childProperty)));
+            }
+#endif
+        }
+
+        internal void InternalPropertyChanging(JProperty childProperty)
+        {
+#if HAVE_INOTIFY_PROPERTY_CHANGING
+            OnPropertyChanging(childProperty.Name);
+#endif
+        }
+
+        internal override JToken CloneToken()
+        {
+            return new JObject(this);
+        }
+
+        /// <summary>
+        /// Gets the node type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <value>The type.</value>
+        public override JTokenType Type => JTokenType.Object;
+
+        /// <summary>
+        /// Gets an <see cref="IEnumerable{T}"/> of <see cref="JProperty"/> of this object's properties.
+        /// </summary>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JProperty"/> of this object's properties.</returns>
+        public IEnumerable<JProperty> Properties()
+        {
+            return _properties.Cast<JProperty>();
+        }
+
+        /// <summary>
+        /// Gets a <see cref="JProperty"/> with the specified name.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <returns>A <see cref="JProperty"/> with the specified name or <c>null</c>.</returns>
+        public JProperty? Property(string name)
+        {
+            return Property(name, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JProperty"/> with the specified name.
+        /// The exact name will be searched for first and if no matching property is found then
+        /// the <see cref="StringComparison"/> will be used to match a property.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <param name="comparison">One of the enumeration values that specifies how the strings will be compared.</param>
+        /// <returns>A <see cref="JProperty"/> matched with the specified name or <c>null</c>.</returns>
+        public JProperty? Property(string name, StringComparison comparison)
+        {
+            if (name == null)
+            {
+                return null;
+            }
+
+            if (_properties.TryGetValue(name, out JToken? property))
+            {
+                return (JProperty)property;
+            }
+
+            // test above already uses this comparison so no need to repeat
+            if (comparison != StringComparison.Ordinal)
+            {
+                for (int i = 0; i < _properties.Count; i++)
+                {
+                    JProperty p = (JProperty)_properties[i];
+                    if (string.Equals(p.Name, name, comparison))
+                    {
+                        return p;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="JEnumerable{T}"/> of <see cref="JToken"/> of this object's property values.
+        /// </summary>
+        /// <returns>A <see cref="JEnumerable{T}"/> of <see cref="JToken"/> of this object's property values.</returns>
+        public JEnumerable<JToken> PropertyValues()
+        {
+            return new JEnumerable<JToken>(Properties().Select(p => p.Value));
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JToken"/> with the specified key.
+        /// </summary>
+        /// <value>The <see cref="JToken"/> with the specified key.</value>
+        public override JToken? this[object key]
+        {
+            get
+            {
+                ValidationUtils.ArgumentNotNull(key, nameof(key));
+
+                if (!(key is string propertyName))
+                {
+                    throw new ArgumentException("Accessed JObject values with invalid key value: {0}. Object property name expected.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(key)));
+                }
+
+                return this[propertyName];
+            }
+            set
+            {
+                ValidationUtils.ArgumentNotNull(key, nameof(key));
+
+                if (!(key is string propertyName))
+                {
+                    throw new ArgumentException("Set JObject values with invalid key value: {0}. Object property name expected.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(key)));
+                }
+
+                this[propertyName] = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="JToken"/> with the specified property name.
+        /// </summary>
+        /// <value></value>
+        public JToken? this[string propertyName]
+        {
+            get
+            {
+                ValidationUtils.ArgumentNotNull(propertyName, nameof(propertyName));
+
+                JProperty? property = Property(propertyName, StringComparison.Ordinal);
+
+                return property?.Value;
+            }
+            set
+            {
+                JProperty? property = Property(propertyName, StringComparison.Ordinal);
+                if (property != null)
+                {
+                    property.Value = value!;
+                }
+                else
+                {
+#if HAVE_INOTIFY_PROPERTY_CHANGING
+                    OnPropertyChanging(propertyName);
+#endif
+                    Add(propertyName, value);
+                    OnPropertyChanged(propertyName);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Loads a <see cref="JObject"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JObject"/>.</param>
+        /// <returns>A <see cref="JObject"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        /// <exception cref="JsonReaderException">
+        ///     <paramref name="reader"/> is not valid JSON.
+        /// </exception>
+        public new static JObject Load(JsonReader reader)
+        {
+            return Load(reader, null);
+        }
+
+        /// <summary>
+        /// Loads a <see cref="JObject"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JObject"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>A <see cref="JObject"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        /// <exception cref="JsonReaderException">
+        ///     <paramref name="reader"/> is not valid JSON.
+        /// </exception>
+        public new static JObject Load(JsonReader reader, JsonLoadSettings? settings)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!reader.Read())
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JObject from JsonReader.");
+                }
+            }
+
+            reader.MoveToContent();
+
+            if (reader.TokenType != JsonToken.StartObject)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JObject from JsonReader. Current JsonReader item is not an object: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JObject o = new JObject();
+            o.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            o.ReadTokenFrom(reader, settings);
+
+            return o;
+        }
+
+        /// <summary>
+        /// Load a <see cref="JObject"/> from a string that contains JSON.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON.</param>
+        /// <returns>A <see cref="JObject"/> populated from the string that contains JSON.</returns>
+        /// <exception cref="JsonReaderException">
+        ///     <paramref name="json"/> is not valid JSON.
+        /// </exception>
+        /// <example>
+        ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\LinqToJsonTests.cs" region="LinqToJsonCreateParse" title="Parsing a JSON Object from Text" />
+        /// </example>
+        public new static JObject Parse(string json)
+        {
+            return Parse(json, null);
+        }
+
+        /// <summary>
+        /// Load a <see cref="JObject"/> from a string that contains JSON.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>A <see cref="JObject"/> populated from the string that contains JSON.</returns>
+        /// <exception cref="JsonReaderException">
+        ///     <paramref name="json"/> is not valid JSON.
+        /// </exception>
+        /// <example>
+        ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\LinqToJsonTests.cs" region="LinqToJsonCreateParse" title="Parsing a JSON Object from Text" />
+        /// </example>
+        public new static JObject Parse(string json, JsonLoadSettings? settings)
+        {
+            using (JsonReader reader = new JsonTextReader(new StringReader(json)))
+            {
+                JObject o = Load(reader, settings);
+
+                while (reader.Read())
+                {
+                    // Any content encountered here other than a comment will throw in the reader.
+                }
+
+                return o;
+            }
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JObject"/> from an object.
+        /// </summary>
+        /// <param name="o">The object that will be used to create <see cref="JObject"/>.</param>
+        /// <returns>A <see cref="JObject"/> with the values of the specified object.</returns>
+        public new static JObject FromObject(object o)
+        {
+            return FromObject(o, JsonSerializer.CreateDefault());
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JObject"/> from an object.
+        /// </summary>
+        /// <param name="o">The object that will be used to create <see cref="JObject"/>.</param>
+        /// <param name="jsonSerializer">The <see cref="JsonSerializer"/> that will be used to read the object.</param>
+        /// <returns>A <see cref="JObject"/> with the values of the specified object.</returns>
+        public new static JObject FromObject(object o, JsonSerializer jsonSerializer)
+        {
+            JToken token = FromObjectInternal(o, jsonSerializer);
+
+            if (token.Type != JTokenType.Object)
+            {
+                throw new ArgumentException("Object serialized to {0}. JObject instance expected.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+            }
+
+            return (JObject)token;
+        }
+
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
+        {
+            writer.WriteStartObject();
+
+            for (int i = 0; i < _properties.Count; i++)
+            {
+                _properties[i].WriteTo(writer, converters);
+            }
+
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Gets the <see cref="Newtonsoft.Json.Linq.JToken"/> with the specified property name.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <returns>The <see cref="Newtonsoft.Json.Linq.JToken"/> with the specified property name.</returns>
+        public JToken? GetValue(string? propertyName)
+        {
+            return GetValue(propertyName, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Gets the <see cref="Newtonsoft.Json.Linq.JToken"/> with the specified property name.
+        /// The exact property name will be searched for first and if no matching property is found then
+        /// the <see cref="StringComparison"/> will be used to match a property.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <param name="comparison">One of the enumeration values that specifies how the strings will be compared.</param>
+        /// <returns>The <see cref="Newtonsoft.Json.Linq.JToken"/> with the specified property name.</returns>
+        public JToken? GetValue(string? propertyName, StringComparison comparison)
+        {
+            if (propertyName == null)
+            {
+                return null;
+            }
+
+            // attempt to get value via dictionary first for performance
+            var property = Property(propertyName, comparison);
+
+            return property?.Value;
+        }
+
+        /// <summary>
+        /// Tries to get the <see cref="Newtonsoft.Json.Linq.JToken"/> with the specified property name.
+        /// The exact property name will be searched for first and if no matching property is found then
+        /// the <see cref="StringComparison"/> will be used to match a property.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="comparison">One of the enumeration values that specifies how the strings will be compared.</param>
+        /// <returns><c>true</c> if a value was successfully retrieved; otherwise, <c>false</c>.</returns>
+        public bool TryGetValue(string propertyName, StringComparison comparison, [NotNullWhen(true)]out JToken? value)
+        {
+            value = GetValue(propertyName, comparison);
+            return (value != null);
+        }
+
+        #region IDictionary<string,JToken> Members
+        /// <summary>
+        /// Adds the specified property name.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <param name="value">The value.</param>
+        public void Add(string propertyName, JToken? value)
+        {
+            Add(new JProperty(propertyName, value));
+        }
+
+        /// <summary>
+        /// Determines whether the JSON object has the specified property name.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <returns><c>true</c> if the JSON object has the specified property name; otherwise, <c>false</c>.</returns>
+        public bool ContainsKey(string propertyName)
+        {
+            ValidationUtils.ArgumentNotNull(propertyName, nameof(propertyName));
+
+            return _properties.Contains(propertyName);
+        }
+
+        ICollection<string> IDictionary<string, JToken?>.Keys => _properties.Keys;
+
+        /// <summary>
+        /// Removes the property with the specified name.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <returns><c>true</c> if item was successfully removed; otherwise, <c>false</c>.</returns>
+        public bool Remove(string propertyName)
+        {
+            JProperty? property = Property(propertyName, StringComparison.Ordinal);
+            if (property == null)
+            {
+                return false;
+            }
+
+            property.Remove();
+            return true;
+        }
+
+        /// <summary>
+        /// Tries to get the <see cref="Newtonsoft.Json.Linq.JToken"/> with the specified property name.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <param name="value">The value.</param>
+        /// <returns><c>true</c> if a value was successfully retrieved; otherwise, <c>false</c>.</returns>
+        public bool TryGetValue(string propertyName, [NotNullWhen(true)]out JToken? value)
+        {
+            JProperty? property = Property(propertyName, StringComparison.Ordinal);
+            if (property == null)
+            {
+                value = null;
+                return false;
+            }
+
+            value = property.Value;
+            return true;
+        }
+
+        ICollection<JToken?> IDictionary<string, JToken?>.Values => throw new NotImplementedException();
+
+        #endregion
+
+        #region ICollection<KeyValuePair<string,JToken>> Members
+        void ICollection<KeyValuePair<string, JToken?>>.Add(KeyValuePair<string, JToken?> item)
+        {
+            Add(new JProperty(item.Key, item.Value));
+        }
+
+        void ICollection<KeyValuePair<string, JToken?>>.Clear()
+        {
+            RemoveAll();
+        }
+
+        bool ICollection<KeyValuePair<string, JToken?>>.Contains(KeyValuePair<string, JToken?> item)
+        {
+            JProperty? property = Property(item.Key, StringComparison.Ordinal);
+            if (property == null)
+            {
+                return false;
+            }
+
+            return (property.Value == item.Value);
+        }
+
+        void ICollection<KeyValuePair<string, JToken?>>.CopyTo(KeyValuePair<string, JToken?>[] array, int arrayIndex)
+        {
+            if (array == null)
+            {
+                throw new ArgumentNullException(nameof(array));
+            }
+            if (arrayIndex < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(arrayIndex), "arrayIndex is less than 0.");
+            }
+            if (arrayIndex >= array.Length && arrayIndex != 0)
+            {
+                throw new ArgumentException("arrayIndex is equal to or greater than the length of array.");
+            }
+            if (Count > array.Length - arrayIndex)
+            {
+                throw new ArgumentException("The number of elements in the source JObject is greater than the available space from arrayIndex to the end of the destination array.");
+            }
+
+            int index = 0;
+            foreach (JProperty property in _properties)
+            {
+                array[arrayIndex + index] = new KeyValuePair<string, JToken?>(property.Name, property.Value);
+                index++;
+            }
+        }
+
+        bool ICollection<KeyValuePair<string, JToken?>>.IsReadOnly => false;
+
+        bool ICollection<KeyValuePair<string, JToken?>>.Remove(KeyValuePair<string, JToken?> item)
+        {
+            if (!((ICollection<KeyValuePair<string, JToken?>>)this).Contains(item))
+            {
+                return false;
+            }
+
+            ((IDictionary<string, JToken>)this).Remove(item.Key);
+            return true;
+        }
+        #endregion
+
+        internal override int GetDeepHashCode()
+        {
+            return ContentsHashCode();
+        }
+
+        /// <summary>
+        /// Returns an enumerator that can be used to iterate through the collection.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="IEnumerator{T}"/> that can be used to iterate through the collection.
+        /// </returns>
+        public IEnumerator<KeyValuePair<string, JToken?>> GetEnumerator()
+        {
+            foreach (JProperty property in _properties)
+            {
+                yield return new KeyValuePair<string, JToken?>(property.Name, property.Value);
+            }
+        }
+
+        /// <summary>
+        /// Raises the <see cref="PropertyChanged"/> event with the provided arguments.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        protected virtual void OnPropertyChanged(string propertyName)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+#if HAVE_INOTIFY_PROPERTY_CHANGING
+        /// <summary>
+        /// Raises the <see cref="PropertyChanging"/> event with the provided arguments.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        protected virtual void OnPropertyChanging(string propertyName)
+        {
+            PropertyChanging?.Invoke(this, new PropertyChangingEventArgs(propertyName));
+        }
+#endif
+
+#if HAVE_COMPONENT_MODEL
+        // include custom type descriptor on JObject rather than use a provider because the properties are specific to a type
+
+        #region ICustomTypeDescriptor
+        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
+        {
+            return ((ICustomTypeDescriptor)this).GetProperties(null);
+        }
+
+        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
+        {
+            PropertyDescriptor[] propertiesArray = new PropertyDescriptor[Count];
+            int i = 0;
+            foreach (KeyValuePair<string, JToken?> propertyValue in this)
+            {
+                propertiesArray[i] = new JPropertyDescriptor(propertyValue.Key);
+                i++;
+            }
+
+            return new PropertyDescriptorCollection(propertiesArray);
+        }
+
+        AttributeCollection ICustomTypeDescriptor.GetAttributes()
+        {
+            return AttributeCollection.Empty;
+        }
+
+        string? ICustomTypeDescriptor.GetClassName()
+        {
+            return null;
+        }
+
+        string? ICustomTypeDescriptor.GetComponentName()
+        {
+            return null;
+        }
+
+        TypeConverter ICustomTypeDescriptor.GetConverter()
+        {
+            return new TypeConverter();
+        }
+
+        EventDescriptor? ICustomTypeDescriptor.GetDefaultEvent()
+        {
+            return null;
+        }
+
+        PropertyDescriptor? ICustomTypeDescriptor.GetDefaultProperty()
+        {
+            return null;
+        }
+
+        object? ICustomTypeDescriptor.GetEditor(Type editorBaseType)
+        {
+            return null;
+        }
+
+        EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
+        {
+            return EventDescriptorCollection.Empty;
+        }
+
+        EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
+        {
+            return EventDescriptorCollection.Empty;
+        }
+
+        object? ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
+        {
+            if (pd is JPropertyDescriptor)
+            {
+                return this;
+            }
+
+            return null;
+        }
+        #endregion
+
+#endif
+
+#if HAVE_DYNAMIC                            
+        /// <summary>
+        /// Returns the <see cref="DynamicMetaObject"/> responsible for binding operations performed on this object.
+        /// </summary>
+        /// <param name="parameter">The expression tree representation of the runtime value.</param>
+        /// <returns>
+        /// The <see cref="DynamicMetaObject"/> to bind this object.
+        /// </returns>
+        protected override DynamicMetaObject GetMetaObject(Expression parameter)
+        {
+            return new DynamicProxyMetaObject<JObject>(parameter, this, new JObjectDynamicProxy());
+        }
+
+        private class JObjectDynamicProxy : DynamicProxy<JObject>
+        {
+            public override bool TryGetMember(JObject instance, GetMemberBinder binder, out object? result)
+            {
+                // result can be null
+                result = instance[binder.Name];
+                return true;
+            }
+
+            public override bool TrySetMember(JObject instance, SetMemberBinder binder, object value)
+            {
+                // this can throw an error if value isn't a valid for a JValue
+                if (!(value is JToken v))
+                {
+                    v = new JValue(value);
+                }
+
+                instance[binder.Name] = v;
+                return true;
+            }
+
+            public override IEnumerable<string> GetDynamicMemberNames(JObject instance)
+            {
+                return instance.Properties().Select(p => p.Name);
+            }
+        }
+#endif
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Linq/JProperty.Async.cs b/Libs/Newtonsoft.Json/Linq/JProperty.Async.cs
new file mode 100644
index 0000000..3047996
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JProperty.Async.cs
@@ -0,0 +1,118 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public partial class JProperty
+    {
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/> asynchronously.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        public override Task WriteToAsync(JsonWriter writer, CancellationToken cancellationToken, params JsonConverter[] converters)
+        {
+            Task task = writer.WritePropertyNameAsync(_name, cancellationToken);
+            if (task.IsCompletedSucessfully())
+            {
+                return WriteValueAsync(writer, cancellationToken, converters);
+            }
+
+            return WriteToAsync(task, writer, cancellationToken, converters);
+        }
+
+        private async Task WriteToAsync(Task task, JsonWriter writer, CancellationToken cancellationToken, params JsonConverter[] converters)
+        {
+            await task.ConfigureAwait(false);
+
+            await WriteValueAsync(writer, cancellationToken, converters).ConfigureAwait(false);
+        }
+
+        private Task WriteValueAsync(JsonWriter writer, CancellationToken cancellationToken, JsonConverter[] converters)
+        {
+            JToken value = Value;
+            return value != null
+                ? value.WriteToAsync(writer, cancellationToken, converters)
+                : writer.WriteNullAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JProperty"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JProperty"/>.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> representing the asynchronous creation. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JProperty"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static Task<JProperty> LoadAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            return LoadAsync(reader, null, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously loads a <see cref="JProperty"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JProperty"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> representing the asynchronous creation. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JProperty"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static async Task<JProperty> LoadAsync(JsonReader reader, JsonLoadSettings? settings, CancellationToken cancellationToken = default)
+        {
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JProperty from JsonReader.");
+                }
+            }
+
+            await reader.MoveToContentAsync(cancellationToken).ConfigureAwait(false);
+
+            if (reader.TokenType != JsonToken.PropertyName)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JProperty from JsonReader. Current JsonReader item is not a property: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JProperty p = new JProperty((string)reader.Value!);
+            p.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            await p.ReadTokenFromAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+
+            return p;
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/Linq/JProperty.cs b/Libs/Newtonsoft.Json/Linq/JProperty.cs
new file mode 100644
index 0000000..5745e2c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JProperty.cs
@@ -0,0 +1,401 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a JSON property.
+    /// </summary>
+    public partial class JProperty : JContainer
+    {
+        #region JPropertyList
+        private class JPropertyList : IList<JToken>
+        {
+            internal JToken? _token;
+
+            public IEnumerator<JToken> GetEnumerator()
+            {
+                if (_token != null)
+                {
+                    yield return _token;
+                }
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            public void Add(JToken item)
+            {
+                _token = item;
+            }
+
+            public void Clear()
+            {
+                _token = null;
+            }
+
+            public bool Contains(JToken item)
+            {
+                return (_token == item);
+            }
+
+            public void CopyTo(JToken[] array, int arrayIndex)
+            {
+                if (_token != null)
+                {
+                    array[arrayIndex] = _token;
+                }
+            }
+
+            public bool Remove(JToken item)
+            {
+                if (_token == item)
+                {
+                    _token = null;
+                    return true;
+                }
+                return false;
+            }
+
+            public int Count => (_token != null) ? 1 : 0;
+
+            public bool IsReadOnly => false;
+
+            public int IndexOf(JToken item)
+            {
+                return (_token == item) ? 0 : -1;
+            }
+
+            public void Insert(int index, JToken item)
+            {
+                if (index == 0)
+                {
+                    _token = item;
+                }
+            }
+
+            public void RemoveAt(int index)
+            {
+                if (index == 0)
+                {
+                    _token = null;
+                }
+            }
+
+            public JToken this[int index]
+            {
+                get
+                {
+                    if (index != 0)
+                    {
+                        throw new IndexOutOfRangeException();
+                    }
+
+                    MiscellaneousUtils.Assert(_token != null);
+                    return _token;
+                }
+                set
+                {
+                    if (index != 0)
+                    {
+                        throw new IndexOutOfRangeException();
+                    }
+
+                    _token = value;
+                }
+            }
+        }
+        #endregion
+
+        private readonly JPropertyList _content = new JPropertyList();
+        private readonly string _name;
+
+        /// <summary>
+        /// Gets the container's children tokens.
+        /// </summary>
+        /// <value>The container's children tokens.</value>
+        protected override IList<JToken> ChildrenTokens => _content;
+
+        /// <summary>
+        /// Gets the property name.
+        /// </summary>
+        /// <value>The property name.</value>
+        public string Name
+        {
+            [DebuggerStepThrough]
+            get { return _name; }
+        }
+
+        /// <summary>
+        /// Gets or sets the property value.
+        /// </summary>
+        /// <value>The property value.</value>
+        public JToken Value
+        {
+            [DebuggerStepThrough]
+            get { return _content._token!; }
+            set
+            {
+                CheckReentrancy();
+
+                JToken newValue = value ?? JValue.CreateNull();
+
+                if (_content._token == null)
+                {
+                    InsertItem(0, newValue, false);
+                }
+                else
+                {
+                    SetItem(0, newValue);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JProperty"/> class from another <see cref="JProperty"/> object.
+        /// </summary>
+        /// <param name="other">A <see cref="JProperty"/> object to copy from.</param>
+        public JProperty(JProperty other)
+            : base(other)
+        {
+            _name = other.Name;
+        }
+
+        internal override JToken GetItem(int index)
+        {
+            if (index != 0)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+
+            return Value;
+        }
+
+        internal override void SetItem(int index, JToken? item)
+        {
+            if (index != 0)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+
+            if (IsTokenUnchanged(Value, item))
+            {
+                return;
+            }
+
+            ((JObject?)Parent)?.InternalPropertyChanging(this);
+
+            base.SetItem(0, item);
+
+            ((JObject?)Parent)?.InternalPropertyChanged(this);
+        }
+
+        internal override bool RemoveItem(JToken? item)
+        {
+            throw new JsonException("Cannot add or remove items from {0}.".FormatWith(CultureInfo.InvariantCulture, typeof(JProperty)));
+        }
+
+        internal override void RemoveItemAt(int index)
+        {
+            throw new JsonException("Cannot add or remove items from {0}.".FormatWith(CultureInfo.InvariantCulture, typeof(JProperty)));
+        }
+
+        internal override int IndexOfItem(JToken? item)
+        {
+            if (item == null)
+            {
+                return -1;
+            }
+
+            return _content.IndexOf(item);
+        }
+
+        internal override bool InsertItem(int index, JToken? item, bool skipParentCheck)
+        {
+            // don't add comments to JProperty
+            if (item != null && item.Type == JTokenType.Comment)
+            {
+                return false;
+            }
+
+            if (Value != null)
+            {
+                throw new JsonException("{0} cannot have multiple values.".FormatWith(CultureInfo.InvariantCulture, typeof(JProperty)));
+            }
+
+            return base.InsertItem(0, item, false);
+        }
+
+        internal override bool ContainsItem(JToken? item)
+        {
+            return (Value == item);
+        }
+
+        internal override void MergeItem(object content, JsonMergeSettings? settings)
+        {
+            JToken? value = (content as JProperty)?.Value;
+
+            if (value != null && value.Type != JTokenType.Null)
+            {
+                Value = value;
+            }
+        }
+
+        internal override void ClearItems()
+        {
+            throw new JsonException("Cannot add or remove items from {0}.".FormatWith(CultureInfo.InvariantCulture, typeof(JProperty)));
+        }
+
+        internal override bool DeepEquals(JToken node)
+        {
+            return (node is JProperty t && _name == t.Name && ContentsEqual(t));
+        }
+
+        internal override JToken CloneToken()
+        {
+            return new JProperty(this);
+        }
+
+        /// <summary>
+        /// Gets the node type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <value>The type.</value>
+        public override JTokenType Type
+        {
+            [DebuggerStepThrough]
+            get { return JTokenType.Property; }
+        }
+
+        internal JProperty(string name)
+        {
+            // called from JTokenWriter
+            ValidationUtils.ArgumentNotNull(name, nameof(name));
+
+            _name = name;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JProperty"/> class.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <param name="content">The property content.</param>
+        public JProperty(string name, params object[] content)
+            : this(name, (object)content)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JProperty"/> class.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <param name="content">The property content.</param>
+        public JProperty(string name, object? content)
+        {
+            ValidationUtils.ArgumentNotNull(name, nameof(name));
+
+            _name = name;
+
+            Value = IsMultiContent(content)
+                ? new JArray(content)
+                : CreateFromContent(content);
+        }
+
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
+        {
+            writer.WritePropertyName(_name);
+
+            JToken value = Value;
+            if (value != null)
+            {
+                value.WriteTo(writer, converters);
+            }
+            else
+            {
+                writer.WriteNull();
+            }
+        }
+
+        internal override int GetDeepHashCode()
+        {
+            return _name.GetHashCode() ^ (Value?.GetDeepHashCode() ?? 0);
+        }
+
+        /// <summary>
+        /// Loads a <see cref="JProperty"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JProperty"/>.</param>
+        /// <returns>A <see cref="JProperty"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static JProperty Load(JsonReader reader)
+        {
+            return Load(reader, null);
+        }
+
+        /// <summary>
+        /// Loads a <see cref="JProperty"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> that will be read for the content of the <see cref="JProperty"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>A <see cref="JProperty"/> that contains the JSON that was read from the specified <see cref="JsonReader"/>.</returns>
+        public new static JProperty Load(JsonReader reader, JsonLoadSettings? settings)
+        {
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!reader.Read())
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JProperty from JsonReader.");
+                }
+            }
+
+            reader.MoveToContent();
+
+            if (reader.TokenType != JsonToken.PropertyName)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JProperty from JsonReader. Current JsonReader item is not a property: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            JProperty p = new JProperty((string)reader.Value!);
+            p.SetLineInfo(reader as IJsonLineInfo, settings);
+
+            p.ReadTokenFrom(reader, settings);
+
+            return p;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JPropertyDescriptor.cs b/Libs/Newtonsoft.Json/Linq/JPropertyDescriptor.cs
new file mode 100644
index 0000000..2ebbe94
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JPropertyDescriptor.cs
@@ -0,0 +1,156 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_COMPONENT_MODEL
+using System;
+using System.ComponentModel;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a view of a <see cref="JProperty"/>.
+    /// </summary>
+    public class JPropertyDescriptor : PropertyDescriptor
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JPropertyDescriptor"/> class.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        public JPropertyDescriptor(string name)
+            : base(name, null)
+        {
+        }
+
+        private static JObject CastInstance(object instance)
+        {
+            return (JObject)instance;
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, returns whether resetting an object changes its value.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if resetting the component changes its value; otherwise, <c>false</c>.
+        /// </returns>
+        /// <param name="component">The component to test for reset capability.</param>
+        public override bool CanResetValue(object component)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, gets the current value of the property on a component.
+        /// </summary>
+        /// <returns>
+        /// The value of a property for a given component.
+        /// </returns>
+        /// <param name="component">The component with the property for which to retrieve the value.</param>
+        public override object? GetValue(object component)
+        {
+            return (component as JObject)?[Name];
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, resets the value for this property of the component to the default value.
+        /// </summary>
+        /// <param name="component">The component with the property value that is to be reset to the default value.</param>
+        public override void ResetValue(object component)
+        {
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, sets the value of the component to a different value.
+        /// </summary>
+        /// <param name="component">The component with the property value that is to be set.</param>
+        /// <param name="value">The new value.</param>
+        public override void SetValue(object component, object value)
+        {
+            if (component is JObject o)
+            {
+                JToken token = value as JToken ?? new JValue(value);
+
+                o[Name] = token;
+            }
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, determines a value indicating whether the value of this property needs to be persisted.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the property should be persisted; otherwise, <c>false</c>.
+        /// </returns>
+        /// <param name="component">The component with the property to be examined for persistence.</param>
+        public override bool ShouldSerializeValue(object component)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, gets the type of the component this property is bound to.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="Type"/> that represents the type of component this property is bound to.
+        /// When the <see cref="PropertyDescriptor.GetValue(Object)"/> or
+        /// <see cref="PropertyDescriptor.SetValue(Object, Object)"/>
+        /// methods are invoked, the object specified might be an instance of this type.
+        /// </returns>
+        public override Type ComponentType => typeof(JObject);
+
+        /// <summary>
+        /// When overridden in a derived class, gets a value indicating whether this property is read-only.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the property is read-only; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool IsReadOnly => false;
+
+        /// <summary>
+        /// When overridden in a derived class, gets the type of the property.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="Type"/> that represents the type of the property.
+        /// </returns>
+        public override Type PropertyType => typeof(object);
+
+        /// <summary>
+        /// Gets the hash code for the name of the member.
+        /// </summary>
+        /// <value></value>
+        /// <returns>
+        /// The hash code for the name of the member.
+        /// </returns>
+        protected override int NameHashCode
+        {
+            get
+            {
+                // override property to fix up an error in its documentation
+                int nameHashCode = base.NameHashCode;
+                return nameHashCode;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JPropertyKeyedCollection.cs b/Libs/Newtonsoft.Json/Linq/JPropertyKeyedCollection.cs
new file mode 100644
index 0000000..61de800
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JPropertyKeyedCollection.cs
@@ -0,0 +1,284 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    internal class JPropertyKeyedCollection : Collection<JToken>
+    {
+        private static readonly IEqualityComparer<string> Comparer = StringComparer.Ordinal;
+
+        private Dictionary<string, JToken>? _dictionary;
+
+        public JPropertyKeyedCollection() : base(new List<JToken>())
+        {
+        }
+
+        private void AddKey(string key, JToken item)
+        {
+            EnsureDictionary();
+            _dictionary![key] = item;
+        }
+
+        protected void ChangeItemKey(JToken item, string newKey)
+        {
+            if (!ContainsItem(item))
+            {
+                throw new ArgumentException("The specified item does not exist in this KeyedCollection.");
+            }
+
+            string keyForItem = GetKeyForItem(item);
+            if (!Comparer.Equals(keyForItem, newKey))
+            {
+                if (newKey != null)
+                {
+                    AddKey(newKey, item);
+                }
+
+                if (keyForItem != null)
+                {
+                    RemoveKey(keyForItem);
+                }
+            }
+        }
+
+        protected override void ClearItems()
+        {
+            base.ClearItems();
+
+            _dictionary?.Clear();
+        }
+
+        public bool Contains(string key)
+        {
+            if (key == null)
+            {
+                throw new ArgumentNullException(nameof(key));
+            }
+
+            if (_dictionary != null)
+            {
+                return _dictionary.ContainsKey(key);
+            }
+
+            return false;
+        }
+
+        private bool ContainsItem(JToken item)
+        {
+            if (_dictionary == null)
+            {
+                return false;
+            }
+
+            string key = GetKeyForItem(item);
+            return _dictionary.TryGetValue(key, out _);
+        }
+
+        private void EnsureDictionary()
+        {
+            if (_dictionary == null)
+            {
+                _dictionary = new Dictionary<string, JToken>(Comparer);
+            }
+        }
+
+        private string GetKeyForItem(JToken item)
+        {
+            return ((JProperty)item).Name;
+        }
+
+        protected override void InsertItem(int index, JToken item)
+        {
+            AddKey(GetKeyForItem(item), item);
+            base.InsertItem(index, item);
+        }
+
+        public bool Remove(string key)
+        {
+            if (key == null)
+            {
+                throw new ArgumentNullException(nameof(key));
+            }
+
+            if (_dictionary != null)
+            {
+                return _dictionary.TryGetValue(key, out JToken value) && Remove(value);
+            }
+
+            return false;
+        }
+
+        protected override void RemoveItem(int index)
+        {
+            string keyForItem = GetKeyForItem(Items[index]);
+            RemoveKey(keyForItem);
+            base.RemoveItem(index);
+        }
+
+        private void RemoveKey(string key)
+        {
+            _dictionary?.Remove(key);
+        }
+
+        protected override void SetItem(int index, JToken item)
+        {
+            string keyForItem = GetKeyForItem(item);
+            string keyAtIndex = GetKeyForItem(Items[index]);
+
+            if (Comparer.Equals(keyAtIndex, keyForItem))
+            {
+                if (_dictionary != null)
+                {
+                    _dictionary[keyForItem] = item;
+                }
+            }
+            else
+            {
+                AddKey(keyForItem, item);
+
+                if (keyAtIndex != null)
+                {
+                    RemoveKey(keyAtIndex);
+                }
+            }
+            base.SetItem(index, item);
+        }
+
+        public JToken this[string key]
+        {
+            get
+            {
+                if (key == null)
+                {
+                    throw new ArgumentNullException(nameof(key));
+                }
+
+                if (_dictionary != null)
+                {
+                    return _dictionary[key];
+                }
+
+                throw new KeyNotFoundException();
+            }
+        }
+
+        public bool TryGetValue(string key, [NotNullWhen(true)]out JToken? value)
+        {
+            if (_dictionary == null)
+            {
+                value = null;
+                return false;
+            }
+
+            return _dictionary.TryGetValue(key, out value);
+        }
+
+        public ICollection<string> Keys
+        {
+            get
+            {
+                EnsureDictionary();
+                return _dictionary!.Keys;
+            }
+        }
+
+        public ICollection<JToken> Values
+        {
+            get
+            {
+                EnsureDictionary();
+                return _dictionary!.Values;
+            }
+        }
+
+        public int IndexOfReference(JToken t)
+        {
+            return ((List<JToken>)Items).IndexOfReference(t);
+        }
+
+        public bool Compare(JPropertyKeyedCollection other)
+        {
+            if (this == other)
+            {
+                return true;
+            }
+
+            // dictionaries in JavaScript aren't ordered
+            // ignore order when comparing properties
+            Dictionary<string, JToken>? d1 = _dictionary;
+            Dictionary<string, JToken>? d2 = other._dictionary;
+
+            if (d1 == null && d2 == null)
+            {
+                return true;
+            }
+
+            if (d1 == null)
+            {
+                return (d2!.Count == 0);
+            }
+
+            if (d2 == null)
+            {
+                return (d1.Count == 0);
+            }
+
+            if (d1.Count != d2.Count)
+            {
+                return false;
+            }
+
+            foreach (KeyValuePair<string, JToken> keyAndProperty in d1)
+            {
+                if (!d2.TryGetValue(keyAndProperty.Key, out JToken secondValue))
+                {
+                    return false;
+                }
+
+                JProperty p1 = (JProperty)keyAndProperty.Value;
+                JProperty p2 = (JProperty)secondValue;
+
+                if (p1.Value == null)
+                {
+                    return (p2.Value == null);
+                }
+
+                if (!p1.Value.DeepEquals(p2.Value))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JRaw.Async.cs b/Libs/Newtonsoft.Json/Linq/JRaw.Async.cs
new file mode 100644
index 0000000..93a669d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JRaw.Async.cs
@@ -0,0 +1,57 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System.Globalization;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public partial class JRaw
+    {
+        /// <summary>
+        /// Asynchronously creates an instance of <see cref="JRaw"/> with the content of the reader's current token.
+        /// </summary>
+        /// <param name="reader">The reader.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>A <see cref="Task{TResult}"/> representing the asynchronous creation. The <see cref="Task{TResult}.Result"/>
+        /// property returns an instance of <see cref="JRaw"/> with the content of the reader's current token.</returns>
+        public static async Task<JRaw> CreateAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            using (StringWriter sw = new StringWriter(CultureInfo.InvariantCulture))
+            using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
+            {
+                await jsonWriter.WriteTokenSyncReadingAsync(reader, cancellationToken).ConfigureAwait(false);
+
+                return new JRaw(sw.ToString());
+            }
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/Linq/JRaw.cs b/Libs/Newtonsoft.Json/Linq/JRaw.cs
new file mode 100644
index 0000000..cf3790b
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JRaw.cs
@@ -0,0 +1,75 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System.Globalization;
+using System.IO;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a raw JSON string.
+    /// </summary>
+    public partial class JRaw : JValue
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JRaw"/> class from another <see cref="JRaw"/> object.
+        /// </summary>
+        /// <param name="other">A <see cref="JRaw"/> object to copy from.</param>
+        public JRaw(JRaw other)
+            : base(other)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JRaw"/> class.
+        /// </summary>
+        /// <param name="rawJson">The raw json.</param>
+        public JRaw(object? rawJson)
+            : base(rawJson, JTokenType.Raw)
+        {
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="JRaw"/> with the content of the reader's current token.
+        /// </summary>
+        /// <param name="reader">The reader.</param>
+        /// <returns>An instance of <see cref="JRaw"/> with the content of the reader's current token.</returns>
+        public static JRaw Create(JsonReader reader)
+        {
+            using (StringWriter sw = new StringWriter(CultureInfo.InvariantCulture))
+            using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
+            {
+                jsonWriter.WriteToken(reader);
+
+                return new JRaw(sw.ToString());
+            }
+        }
+
+        internal override JToken CloneToken()
+        {
+            return new JRaw(this);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JToken.Async.cs b/Libs/Newtonsoft.Json/Linq/JToken.Async.cs
new file mode 100644
index 0000000..e18a6aa
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JToken.Async.cs
@@ -0,0 +1,178 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public abstract partial class JToken
+    {
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/> asynchronously.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        public virtual Task WriteToAsync(JsonWriter writer, CancellationToken cancellationToken, params JsonConverter[] converters)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/> asynchronously.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        public Task WriteToAsync(JsonWriter writer, params JsonConverter[] converters)
+        {
+            return WriteToAsync(writer, default, converters);
+        }
+
+        /// <summary>
+        /// Asynchronously creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">An <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous creation. The
+        /// <see cref="Task{TResult}.Result"/> property returns a <see cref="JToken"/> that contains 
+        /// the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static Task<JToken> ReadFromAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            return ReadFromAsync(reader, null, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">An <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous creation. The
+        /// <see cref="Task{TResult}.Result"/> property returns a <see cref="JToken"/> that contains 
+        /// the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static async Task<JToken> ReadFromAsync(JsonReader reader, JsonLoadSettings? settings, CancellationToken cancellationToken = default)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            if (reader.TokenType == JsonToken.None)
+            {
+                if (!await (settings != null && settings.CommentHandling == CommentHandling.Ignore ? reader.ReadAndMoveToContentAsync(cancellationToken) : reader.ReadAsync(cancellationToken)).ConfigureAwait(false))
+                {
+                    throw JsonReaderException.Create(reader, "Error reading JToken from JsonReader.");
+                }
+            }
+
+            IJsonLineInfo? lineInfo = reader as IJsonLineInfo;
+
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return await JObject.LoadAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+                case JsonToken.StartArray:
+                    return await JArray.LoadAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+                case JsonToken.StartConstructor:
+                    return await JConstructor.LoadAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+                case JsonToken.PropertyName:
+                    return await JProperty.LoadAsync(reader, settings, cancellationToken).ConfigureAwait(false);
+                case JsonToken.String:
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.Date:
+                case JsonToken.Boolean:
+                case JsonToken.Bytes:
+                    JValue v = new JValue(reader.Value);
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                case JsonToken.Comment:
+                    v = JValue.CreateComment(reader.Value?.ToString());
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                case JsonToken.Null:
+                    v = JValue.CreateNull();
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                case JsonToken.Undefined:
+                    v = JValue.CreateUndefined();
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                default:
+                    throw JsonReaderException.Create(reader, "Error reading JToken from JsonReader. Unexpected token: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous creation. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JToken"/> that contains the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static Task<JToken> LoadAsync(JsonReader reader, CancellationToken cancellationToken = default)
+        {
+            return LoadAsync(reader, null, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that represents the asynchronous creation. The <see cref="Task{TResult}.Result"/>
+        /// property returns a <see cref="JToken"/> that contains the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static Task<JToken> LoadAsync(JsonReader reader, JsonLoadSettings? settings, CancellationToken cancellationToken = default)
+        {
+            return ReadFromAsync(reader, settings, cancellationToken);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JToken.cs b/Libs/Newtonsoft.Json/Linq/JToken.cs
new file mode 100644
index 0000000..bb480af
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JToken.cs
@@ -0,0 +1,2750 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Linq.JsonPath;
+#if HAVE_DYNAMIC
+using System.Dynamic;
+using System.Linq.Expressions;
+#endif
+using System.IO;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+using System.Globalization;
+using System.Collections;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents an abstract JSON token.
+    /// </summary>
+    public abstract partial class JToken : IJEnumerable<JToken>, IJsonLineInfo
+#if HAVE_ICLONEABLE
+        , ICloneable
+#endif
+#if HAVE_DYNAMIC
+        , IDynamicMetaObjectProvider
+#endif
+    {
+        private static JTokenEqualityComparer? _equalityComparer;
+
+        private JContainer? _parent;
+        private JToken? _previous;
+        private JToken? _next;
+        private object? _annotations;
+
+        private static readonly JTokenType[] BooleanTypes = new[] { JTokenType.Integer, JTokenType.Float, JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.Boolean };
+        private static readonly JTokenType[] NumberTypes = new[] { JTokenType.Integer, JTokenType.Float, JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.Boolean };
+#if HAVE_BIG_INTEGER
+        private static readonly JTokenType[] BigIntegerTypes = new[] { JTokenType.Integer, JTokenType.Float, JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.Boolean, JTokenType.Bytes };
+#endif
+        private static readonly JTokenType[] StringTypes = new[] { JTokenType.Date, JTokenType.Integer, JTokenType.Float, JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.Boolean, JTokenType.Bytes, JTokenType.Guid, JTokenType.TimeSpan, JTokenType.Uri };
+        private static readonly JTokenType[] GuidTypes = new[] { JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.Guid, JTokenType.Bytes };
+        private static readonly JTokenType[] TimeSpanTypes = new[] { JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.TimeSpan };
+        private static readonly JTokenType[] UriTypes = new[] { JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.Uri };
+        private static readonly JTokenType[] CharTypes = new[] { JTokenType.Integer, JTokenType.Float, JTokenType.String, JTokenType.Comment, JTokenType.Raw };
+        private static readonly JTokenType[] DateTimeTypes = new[] { JTokenType.Date, JTokenType.String, JTokenType.Comment, JTokenType.Raw };
+        private static readonly JTokenType[] BytesTypes = new[] { JTokenType.Bytes, JTokenType.String, JTokenType.Comment, JTokenType.Raw, JTokenType.Integer };
+
+        /// <summary>
+        /// Gets a comparer that can compare two tokens for value equality.
+        /// </summary>
+        /// <value>A <see cref="JTokenEqualityComparer"/> that can compare two nodes for value equality.</value>
+        public static JTokenEqualityComparer EqualityComparer
+        {
+            get
+            {
+                if (_equalityComparer == null)
+                {
+                    _equalityComparer = new JTokenEqualityComparer();
+                }
+
+                return _equalityComparer;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the parent.
+        /// </summary>
+        /// <value>The parent.</value>
+        public JContainer? Parent
+        {
+            [DebuggerStepThrough]
+            get { return _parent; }
+            internal set { _parent = value; }
+        }
+
+        /// <summary>
+        /// Gets the root <see cref="JToken"/> of this <see cref="JToken"/>.
+        /// </summary>
+        /// <value>The root <see cref="JToken"/> of this <see cref="JToken"/>.</value>
+        public JToken Root
+        {
+            get
+            {
+                JContainer? parent = Parent;
+                if (parent == null)
+                {
+                    return this;
+                }
+
+                while (parent.Parent != null)
+                {
+                    parent = parent.Parent;
+                }
+
+                return parent;
+            }
+        }
+
+        internal abstract JToken CloneToken();
+        internal abstract bool DeepEquals(JToken node);
+
+        /// <summary>
+        /// Gets the node type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <value>The type.</value>
+        public abstract JTokenType Type { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether this token has child tokens.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this token has child values; otherwise, <c>false</c>.
+        /// </value>
+        public abstract bool HasValues { get; }
+
+        /// <summary>
+        /// Compares the values of two tokens, including the values of all descendant tokens.
+        /// </summary>
+        /// <param name="t1">The first <see cref="JToken"/> to compare.</param>
+        /// <param name="t2">The second <see cref="JToken"/> to compare.</param>
+        /// <returns><c>true</c> if the tokens are equal; otherwise <c>false</c>.</returns>
+        public static bool DeepEquals(JToken? t1, JToken? t2)
+        {
+            return (t1 == t2 || (t1 != null && t2 != null && t1.DeepEquals(t2)));
+        }
+
+        /// <summary>
+        /// Gets the next sibling token of this node.
+        /// </summary>
+        /// <value>The <see cref="JToken"/> that contains the next sibling token.</value>
+        public JToken? Next
+        {
+            get => _next;
+            internal set => _next = value;
+        }
+
+        /// <summary>
+        /// Gets the previous sibling token of this node.
+        /// </summary>
+        /// <value>The <see cref="JToken"/> that contains the previous sibling token.</value>
+        public JToken? Previous
+        {
+            get => _previous;
+            internal set => _previous = value;
+        }
+
+        /// <summary>
+        /// Gets the path of the JSON token. 
+        /// </summary>
+        public string Path
+        {
+            get
+            {
+                if (Parent == null)
+                {
+                    return string.Empty;
+                }
+
+                List<JsonPosition> positions = new List<JsonPosition>();
+                JToken? previous = null;
+                for (JToken? current = this; current != null; current = current.Parent)
+                {
+                    switch (current.Type)
+                    {
+                        case JTokenType.Property:
+                            JProperty property = (JProperty)current;
+                            positions.Add(new JsonPosition(JsonContainerType.Object) { PropertyName = property.Name });
+                            break;
+                        case JTokenType.Array:
+                        case JTokenType.Constructor:
+                            if (previous != null)
+                            {
+                                int index = ((IList<JToken>)current).IndexOf(previous);
+
+                                positions.Add(new JsonPosition(JsonContainerType.Array) { Position = index });
+                            }
+                            break;
+                    }
+
+                    previous = current;
+                }
+
+#if HAVE_FAST_REVERSE
+                positions.FastReverse();
+#else
+                positions.Reverse();
+#endif
+
+                return JsonPosition.BuildPath(positions, null);
+            }
+        }
+
+        internal JToken()
+        {
+        }
+
+        /// <summary>
+        /// Adds the specified content immediately after this token.
+        /// </summary>
+        /// <param name="content">A content object that contains simple content or a collection of content objects to be added after this token.</param>
+        public void AddAfterSelf(object? content)
+        {
+            if (_parent == null)
+            {
+                throw new InvalidOperationException("The parent is missing.");
+            }
+
+            int index = _parent.IndexOfItem(this);
+            _parent.TryAddInternal(index + 1, content, false);
+        }
+
+        /// <summary>
+        /// Adds the specified content immediately before this token.
+        /// </summary>
+        /// <param name="content">A content object that contains simple content or a collection of content objects to be added before this token.</param>
+        public void AddBeforeSelf(object? content)
+        {
+            if (_parent == null)
+            {
+                throw new InvalidOperationException("The parent is missing.");
+            }
+
+            int index = _parent.IndexOfItem(this);
+            _parent.TryAddInternal(index, content, false);
+        }
+
+        /// <summary>
+        /// Returns a collection of the ancestor tokens of this token.
+        /// </summary>
+        /// <returns>A collection of the ancestor tokens of this token.</returns>
+        public IEnumerable<JToken> Ancestors()
+        {
+            return GetAncestors(false);
+        }
+
+        /// <summary>
+        /// Returns a collection of tokens that contain this token, and the ancestors of this token.
+        /// </summary>
+        /// <returns>A collection of tokens that contain this token, and the ancestors of this token.</returns>
+        public IEnumerable<JToken> AncestorsAndSelf()
+        {
+            return GetAncestors(true);
+        }
+
+        internal IEnumerable<JToken> GetAncestors(bool self)
+        {
+            for (JToken? current = self ? this : Parent; current != null; current = current.Parent)
+            {
+                yield return current;
+            }
+        }
+
+        /// <summary>
+        /// Returns a collection of the sibling tokens after this token, in document order.
+        /// </summary>
+        /// <returns>A collection of the sibling tokens after this tokens, in document order.</returns>
+        public IEnumerable<JToken> AfterSelf()
+        {
+            if (Parent == null)
+            {
+                yield break;
+            }
+
+            for (JToken? o = Next; o != null; o = o.Next)
+            {
+                yield return o;
+            }
+        }
+
+        /// <summary>
+        /// Returns a collection of the sibling tokens before this token, in document order.
+        /// </summary>
+        /// <returns>A collection of the sibling tokens before this token, in document order.</returns>
+        public IEnumerable<JToken> BeforeSelf()
+        {
+            if (Parent == null)
+            {
+                yield break;
+            }
+
+            for (JToken? o = Parent.First; o != this && o != null; o = o.Next)
+            {
+                yield return o;
+            }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JToken"/> with the specified key.
+        /// </summary>
+        /// <value>The <see cref="JToken"/> with the specified key.</value>
+        public virtual JToken? this[object key]
+        {
+            get => throw new InvalidOperationException("Cannot access child value on {0}.".FormatWith(CultureInfo.InvariantCulture, GetType()));
+            set => throw new InvalidOperationException("Cannot set child value on {0}.".FormatWith(CultureInfo.InvariantCulture, GetType()));
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JToken"/> with the specified key converted to the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type to convert the token to.</typeparam>
+        /// <param name="key">The token key.</param>
+        /// <returns>The converted token value.</returns>
+        public virtual T? Value<T>(object key)
+        {
+            JToken? token = this[key];
+
+            // null check to fix MonoTouch issue - https://github.com/dolbz/Newtonsoft.Json/commit/a24e3062846b30ee505f3271ac08862bb471b822
+            return token == null ? default : Extensions.Convert<JToken, T>(token);
+        }
+
+        /// <summary>
+        /// Get the first child token of this token.
+        /// </summary>
+        /// <value>A <see cref="JToken"/> containing the first child token of the <see cref="JToken"/>.</value>
+        public virtual JToken? First => throw new InvalidOperationException("Cannot access child value on {0}.".FormatWith(CultureInfo.InvariantCulture, GetType()));
+
+        /// <summary>
+        /// Get the last child token of this token.
+        /// </summary>
+        /// <value>A <see cref="JToken"/> containing the last child token of the <see cref="JToken"/>.</value>
+        public virtual JToken? Last => throw new InvalidOperationException("Cannot access child value on {0}.".FormatWith(CultureInfo.InvariantCulture, GetType()));
+
+        /// <summary>
+        /// Returns a collection of the child tokens of this token, in document order.
+        /// </summary>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> containing the child tokens of this <see cref="JToken"/>, in document order.</returns>
+        public virtual JEnumerable<JToken> Children()
+        {
+            return JEnumerable<JToken>.Empty;
+        }
+
+        /// <summary>
+        /// Returns a collection of the child tokens of this token, in document order, filtered by the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type to filter the child tokens on.</typeparam>
+        /// <returns>A <see cref="JEnumerable{T}"/> containing the child tokens of this <see cref="JToken"/>, in document order.</returns>
+        public JEnumerable<T> Children<T>() where T : JToken
+        {
+            return new JEnumerable<T>(Children().OfType<T>());
+        }
+
+        /// <summary>
+        /// Returns a collection of the child values of this token, in document order.
+        /// </summary>
+        /// <typeparam name="T">The type to convert the values to.</typeparam>
+        /// <returns>A <see cref="IEnumerable{T}"/> containing the child values of this <see cref="JToken"/>, in document order.</returns>
+        public virtual IEnumerable<T?> Values<T>()
+        {
+            throw new InvalidOperationException("Cannot access child value on {0}.".FormatWith(CultureInfo.InvariantCulture, GetType()));
+        }
+
+        /// <summary>
+        /// Removes this token from its parent.
+        /// </summary>
+        public void Remove()
+        {
+            if (_parent == null)
+            {
+                throw new InvalidOperationException("The parent is missing.");
+            }
+
+            _parent.RemoveItem(this);
+        }
+
+        /// <summary>
+        /// Replaces this token with the specified token.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public void Replace(JToken value)
+        {
+            if (_parent == null)
+            {
+                throw new InvalidOperationException("The parent is missing.");
+            }
+
+            _parent.ReplaceItem(this, value);
+        }
+
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        public abstract void WriteTo(JsonWriter writer, params JsonConverter[] converters);
+
+        /// <summary>
+        /// Returns the indented JSON for this token.
+        /// </summary>
+        /// <remarks>
+        /// <c>ToString()</c> returns a non-JSON string value for tokens with a type of <see cref="JTokenType.String"/>.
+        /// If you want the JSON for all token types then you should use <see cref="WriteTo(JsonWriter, JsonConverter[])"/>.
+        /// </remarks>
+        /// <returns>
+        /// The indented JSON for this token.
+        /// </returns>
+        public override string ToString()
+        {
+            return ToString(Formatting.Indented);
+        }
+
+        /// <summary>
+        /// Returns the JSON for this token using the given formatting and converters.
+        /// </summary>
+        /// <param name="formatting">Indicates how the output should be formatted.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/>s which will be used when writing the token.</param>
+        /// <returns>The JSON for this token using the given formatting and converters.</returns>
+        public string ToString(Formatting formatting, params JsonConverter[] converters)
+        {
+            using (StringWriter sw = new StringWriter(CultureInfo.InvariantCulture))
+            {
+                JsonTextWriter jw = new JsonTextWriter(sw);
+                jw.Formatting = formatting;
+
+                WriteTo(jw, converters);
+
+                return sw.ToString();
+            }
+        }
+
+        private static JValue? EnsureValue(JToken value)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+
+            if (value is JProperty property)
+            {
+                value = property.Value;
+            }
+
+            JValue? v = value as JValue;
+
+            return v;
+        }
+
+        private static string GetType(JToken token)
+        {
+            ValidationUtils.ArgumentNotNull(token, nameof(token));
+
+            if (token is JProperty p)
+            {
+                token = p.Value;
+            }
+
+            return token.Type.ToString();
+        }
+
+        private static bool ValidateToken(JToken o, JTokenType[] validTypes, bool nullable)
+        {
+            return (Array.IndexOf(validTypes, o.Type) != -1) || (nullable && (o.Type == JTokenType.Null || o.Type == JTokenType.Undefined));
+        }
+
+        #region Cast from operators
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="Newtonsoft.Json.Linq.JToken"/> to <see cref="System.Boolean"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator bool(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, BooleanTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Boolean.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return Convert.ToBoolean((int)integer);
+            }
+#endif
+
+            return Convert.ToBoolean(v.Value, CultureInfo.InvariantCulture);
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="Newtonsoft.Json.Linq.JToken"/> to <see cref="System.DateTimeOffset"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator DateTimeOffset(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, DateTimeTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to DateTimeOffset.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value is DateTimeOffset offset)
+            {
+                return offset;
+            }
+
+            if (v.Value is string s)
+            {
+                return DateTimeOffset.Parse(s, CultureInfo.InvariantCulture);
+            }
+
+            return new DateTimeOffset(Convert.ToDateTime(v.Value, CultureInfo.InvariantCulture));
+        }
+#endif
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Boolean"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator bool?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, BooleanTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Boolean.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return Convert.ToBoolean((int)integer);
+            }
+#endif
+
+            return (v.Value != null) ? (bool?)Convert.ToBoolean(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Int64"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator long(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Int64.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (long)integer;
+            }
+#endif
+
+            return Convert.ToInt64(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="DateTime"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator DateTime?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, DateTimeTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to DateTime.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_DATE_TIME_OFFSET
+            if (v.Value is DateTimeOffset offset)
+            {
+                return offset.DateTime;
+            }
+#endif
+
+            return (v.Value != null) ? (DateTime?)Convert.ToDateTime(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator DateTimeOffset?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, DateTimeTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to DateTimeOffset.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value == null)
+            {
+                return null;
+            }
+            if (v.Value is DateTimeOffset offset)
+            {
+                return offset;
+            }
+
+            if (v.Value is string s)
+            {
+                return DateTimeOffset.Parse(s, CultureInfo.InvariantCulture);
+            }
+
+            return new DateTimeOffset(Convert.ToDateTime(v.Value, CultureInfo.InvariantCulture));
+        }
+#endif
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Decimal"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator decimal?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Decimal.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (decimal?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (decimal?)Convert.ToDecimal(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Double"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator double?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Double.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (double?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (double?)Convert.ToDouble(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Char"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator char?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, CharTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Char.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (char?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (char?)Convert.ToChar(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Int32"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator int(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Int32.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (int)integer;
+            }
+#endif
+
+            return Convert.ToInt32(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Int16"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator short(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Int16.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (short)integer;
+            }
+#endif
+
+            return Convert.ToInt16(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="UInt16"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator ushort(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to UInt16.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (ushort)integer;
+            }
+#endif
+
+            return Convert.ToUInt16(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Char"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator char(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, CharTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Char.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (char)integer;
+            }
+#endif
+
+            return Convert.ToChar(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Byte"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator byte(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Byte.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (byte)integer;
+            }
+#endif
+
+            return Convert.ToByte(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="Newtonsoft.Json.Linq.JToken"/> to <see cref="System.SByte"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator sbyte(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to SByte.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (sbyte)integer;
+            }
+#endif
+
+            return Convert.ToSByte(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Int32"/> .
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator int?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Int32.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (int?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (int?)Convert.ToInt32(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Int16"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator short?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Int16.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (short?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (short?)Convert.ToInt16(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="UInt16"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator ushort?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to UInt16.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (ushort?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (ushort?)Convert.ToUInt16(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Byte"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator byte?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Byte.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (byte?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (byte?)Convert.ToByte(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="SByte"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator sbyte?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to SByte.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (sbyte?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (sbyte?)Convert.ToSByte(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="DateTime"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator DateTime(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, DateTimeTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to DateTime.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_DATE_TIME_OFFSET
+            if (v.Value is DateTimeOffset offset)
+            {
+                return offset.DateTime;
+            }
+#endif
+
+            return Convert.ToDateTime(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Int64"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator long?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Int64.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (long?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (long?)Convert.ToInt64(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Single"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator float?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Single.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (float?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (float?)Convert.ToSingle(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Decimal"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator decimal(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Decimal.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (decimal)integer;
+            }
+#endif
+
+            return Convert.ToDecimal(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="UInt32"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator uint?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to UInt32.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (uint?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (uint?)Convert.ToUInt32(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="UInt64"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator ulong?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to UInt64.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (ulong?)integer;
+            }
+#endif
+
+            return (v.Value != null) ? (ulong?)Convert.ToUInt64(v.Value, CultureInfo.InvariantCulture) : null;
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Double"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator double(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Double.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (double)integer;
+            }
+#endif
+
+            return Convert.ToDouble(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Single"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator float(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Single.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (float)integer;
+            }
+#endif
+
+            return Convert.ToSingle(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="String"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator string?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, StringTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to String.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value == null)
+            {
+                return null;
+            }
+
+            if (v.Value is byte[] bytes)
+            {
+                return Convert.ToBase64String(bytes);
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return integer.ToString(CultureInfo.InvariantCulture);
+            }
+#endif
+
+            return Convert.ToString(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="UInt32"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator uint(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to UInt32.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (uint)integer;
+            }
+#endif
+
+            return Convert.ToUInt32(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="Newtonsoft.Json.Linq.JToken"/> to <see cref="System.UInt64"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        [CLSCompliant(false)]
+        public static explicit operator ulong(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, NumberTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to UInt64.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return (ulong)integer;
+            }
+#endif
+
+            return Convert.ToUInt64(v.Value, CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Byte"/>[].
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator byte[]?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, BytesTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to byte array.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value is string)
+            {
+                return Convert.FromBase64String(Convert.ToString(v.Value, CultureInfo.InvariantCulture));
+            }
+#if HAVE_BIG_INTEGER
+            if (v.Value is BigInteger integer)
+            {
+                return integer.ToByteArray();
+            }
+#endif
+
+            if (v.Value is byte[] bytes)
+            {
+                return bytes;
+            }
+
+            throw new ArgumentException("Can not convert {0} to byte array.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Guid"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Guid(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, GuidTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to Guid.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value is byte[] bytes)
+            {
+                return new Guid(bytes);
+            }
+
+            return (v.Value is Guid guid) ? guid : new Guid(Convert.ToString(v.Value, CultureInfo.InvariantCulture));
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="Guid"/> .
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Guid?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, GuidTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Guid.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value == null)
+            {
+                return null;
+            }
+
+            if (v.Value is byte[] bytes)
+            {
+                return new Guid(bytes);
+            }
+
+            return (v.Value is Guid guid) ? guid : new Guid(Convert.ToString(v.Value, CultureInfo.InvariantCulture));
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="TimeSpan"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator TimeSpan(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, TimeSpanTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to TimeSpan.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            return (v.Value is TimeSpan span) ? span : ConvertUtils.ParseTimeSpan(Convert.ToString(v.Value, CultureInfo.InvariantCulture));
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Nullable{T}"/> of <see cref="TimeSpan"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator TimeSpan?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, TimeSpanTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to TimeSpan.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value == null)
+            {
+                return null;
+            }
+
+            return (v.Value is TimeSpan span) ? span : ConvertUtils.ParseTimeSpan(Convert.ToString(v.Value, CultureInfo.InvariantCulture));
+        }
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref="JToken"/> to <see cref="Uri"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Uri?(JToken? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, UriTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to Uri.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value == null)
+            {
+                return null;
+            }
+
+            return (v.Value is Uri uri) ? uri : new Uri(Convert.ToString(v.Value, CultureInfo.InvariantCulture));
+        }
+
+#if HAVE_BIG_INTEGER
+        private static BigInteger ToBigInteger(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, BigIntegerTypes, false))
+            {
+                throw new ArgumentException("Can not convert {0} to BigInteger.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            return ConvertUtils.ToBigInteger(v.Value!);
+        }
+
+        private static BigInteger? ToBigIntegerNullable(JToken value)
+        {
+            JValue? v = EnsureValue(value);
+            if (v == null || !ValidateToken(v, BigIntegerTypes, true))
+            {
+                throw new ArgumentException("Can not convert {0} to BigInteger.".FormatWith(CultureInfo.InvariantCulture, GetType(value)));
+            }
+
+            if (v.Value == null)
+            {
+                return null;
+            }
+
+            return ConvertUtils.ToBigInteger(v.Value);
+        }
+#endif
+        #endregion
+
+        #region Cast to operators
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Boolean"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(bool value)
+        {
+            return new JValue(value);
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="DateTimeOffset"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(DateTimeOffset value)
+        {
+            return new JValue(value);
+        }
+#endif
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Byte"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(byte value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Byte"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(byte? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="SByte"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(sbyte value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="SByte"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(sbyte? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Boolean"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(bool? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Int64"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(long value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="DateTime"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(DateTime? value)
+        {
+            return new JValue(value);
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="DateTimeOffset"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(DateTimeOffset? value)
+        {
+            return new JValue(value);
+        }
+#endif
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Decimal"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(decimal? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Double"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(double? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Int16"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(short value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="UInt16"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(ushort value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Int32"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(int value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Int32"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(int? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="DateTime"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(DateTime value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Int64"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(long? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Single"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(float? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Decimal"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(decimal value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Int16"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(short? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="UInt16"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(ushort? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="UInt32"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(uint? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="UInt64"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(ulong? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Double"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(double value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Single"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(float value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="String"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(string? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="UInt32"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(uint value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="UInt64"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        [CLSCompliant(false)]
+        public static implicit operator JToken(ulong value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Byte"/>[] to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(byte[] value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Uri"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(Uri? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="TimeSpan"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(TimeSpan value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="TimeSpan"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(TimeSpan? value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Guid"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(Guid value)
+        {
+            return new JValue(value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="Nullable{T}"/> of <see cref="Guid"/> to <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="value">The value to create a <see cref="JValue"/> from.</param>
+        /// <returns>The <see cref="JValue"/> initialized with the specified value.</returns>
+        public static implicit operator JToken(Guid? value)
+        {
+            return new JValue(value);
+        }
+        #endregion
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable<JToken>)this).GetEnumerator();
+        }
+
+        IEnumerator<JToken> IEnumerable<JToken>.GetEnumerator()
+        {
+            return Children().GetEnumerator();
+        }
+
+        internal abstract int GetDeepHashCode();
+
+        IJEnumerable<JToken> IJEnumerable<JToken>.this[object key] => this[key]!;
+
+        /// <summary>
+        /// Creates a <see cref="JsonReader"/> for this token.
+        /// </summary>
+        /// <returns>A <see cref="JsonReader"/> that can be used to read this token and its descendants.</returns>
+        public JsonReader CreateReader()
+        {
+            return new JTokenReader(this);
+        }
+
+        internal static JToken FromObjectInternal(object o, JsonSerializer jsonSerializer)
+        {
+            ValidationUtils.ArgumentNotNull(o, nameof(o));
+            ValidationUtils.ArgumentNotNull(jsonSerializer, nameof(jsonSerializer));
+
+            JToken token;
+            using (JTokenWriter jsonWriter = new JTokenWriter())
+            {
+                jsonSerializer.Serialize(jsonWriter, o);
+                token = jsonWriter.Token!;
+            }
+
+            return token;
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JToken"/> from an object.
+        /// </summary>
+        /// <param name="o">The object that will be used to create <see cref="JToken"/>.</param>
+        /// <returns>A <see cref="JToken"/> with the value of the specified object.</returns>
+        public static JToken FromObject(object o)
+        {
+            return FromObjectInternal(o, JsonSerializer.CreateDefault());
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JToken"/> from an object using the specified <see cref="JsonSerializer"/>.
+        /// </summary>
+        /// <param name="o">The object that will be used to create <see cref="JToken"/>.</param>
+        /// <param name="jsonSerializer">The <see cref="JsonSerializer"/> that will be used when reading the object.</param>
+        /// <returns>A <see cref="JToken"/> with the value of the specified object.</returns>
+        public static JToken FromObject(object o, JsonSerializer jsonSerializer)
+        {
+            return FromObjectInternal(o, jsonSerializer);
+        }
+
+        /// <summary>
+        /// Creates an instance of the specified .NET type from the <see cref="JToken"/>.
+        /// </summary>
+        /// <typeparam name="T">The object type that the token will be deserialized to.</typeparam>
+        /// <returns>The new object created from the JSON value.</returns>
+        public T? ToObject<T>()
+        {
+            return (T?)ToObject(typeof(T));
+        }
+
+        /// <summary>
+        /// Creates an instance of the specified .NET type from the <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="objectType">The object type that the token will be deserialized to.</param>
+        /// <returns>The new object created from the JSON value.</returns>
+        public object? ToObject(Type objectType)
+        {
+            if (JsonConvert.DefaultSettings == null)
+            {
+                PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(objectType, out bool isEnum);
+
+                if (isEnum)
+                {
+                    if (Type == JTokenType.String)
+                    {
+                        try
+                        {
+                            // use serializer so JsonConverter(typeof(StringEnumConverter)) + EnumMemberAttributes are respected
+                            return ToObject(objectType, JsonSerializer.CreateDefault());
+                        }
+                        catch (Exception ex)
+                        {
+                            Type enumType = objectType.IsEnum() ? objectType : Nullable.GetUnderlyingType(objectType);
+                            throw new ArgumentException("Could not convert '{0}' to {1}.".FormatWith(CultureInfo.InvariantCulture, (string?)this, enumType.Name), ex);
+                        }
+                    }
+
+                    if (Type == JTokenType.Integer)
+                    {
+                        Type enumType = objectType.IsEnum() ? objectType : Nullable.GetUnderlyingType(objectType);
+                        return Enum.ToObject(enumType, ((JValue)this).Value);
+                    }
+                }
+
+                switch (typeCode)
+                {
+                    case PrimitiveTypeCode.BooleanNullable:
+                        return (bool?)this;
+                    case PrimitiveTypeCode.Boolean:
+                        return (bool)this;
+                    case PrimitiveTypeCode.CharNullable:
+                        return (char?)this;
+                    case PrimitiveTypeCode.Char:
+                        return (char)this;
+                    case PrimitiveTypeCode.SByte:
+                        return (sbyte)this;
+                    case PrimitiveTypeCode.SByteNullable:
+                        return (sbyte?)this;
+                    case PrimitiveTypeCode.ByteNullable:
+                        return (byte?)this;
+                    case PrimitiveTypeCode.Byte:
+                        return (byte)this;
+                    case PrimitiveTypeCode.Int16Nullable:
+                        return (short?)this;
+                    case PrimitiveTypeCode.Int16:
+                        return (short)this;
+                    case PrimitiveTypeCode.UInt16Nullable:
+                        return (ushort?)this;
+                    case PrimitiveTypeCode.UInt16:
+                        return (ushort)this;
+                    case PrimitiveTypeCode.Int32Nullable:
+                        return (int?)this;
+                    case PrimitiveTypeCode.Int32:
+                        return (int)this;
+                    case PrimitiveTypeCode.UInt32Nullable:
+                        return (uint?)this;
+                    case PrimitiveTypeCode.UInt32:
+                        return (uint)this;
+                    case PrimitiveTypeCode.Int64Nullable:
+                        return (long?)this;
+                    case PrimitiveTypeCode.Int64:
+                        return (long)this;
+                    case PrimitiveTypeCode.UInt64Nullable:
+                        return (ulong?)this;
+                    case PrimitiveTypeCode.UInt64:
+                        return (ulong)this;
+                    case PrimitiveTypeCode.SingleNullable:
+                        return (float?)this;
+                    case PrimitiveTypeCode.Single:
+                        return (float)this;
+                    case PrimitiveTypeCode.DoubleNullable:
+                        return (double?)this;
+                    case PrimitiveTypeCode.Double:
+                        return (double)this;
+                    case PrimitiveTypeCode.DecimalNullable:
+                        return (decimal?)this;
+                    case PrimitiveTypeCode.Decimal:
+                        return (decimal)this;
+                    case PrimitiveTypeCode.DateTimeNullable:
+                        return (DateTime?)this;
+                    case PrimitiveTypeCode.DateTime:
+                        return (DateTime)this;
+#if HAVE_DATE_TIME_OFFSET
+                    case PrimitiveTypeCode.DateTimeOffsetNullable:
+                        return (DateTimeOffset?)this;
+                    case PrimitiveTypeCode.DateTimeOffset:
+                        return (DateTimeOffset)this;
+#endif
+                    case PrimitiveTypeCode.String:
+                        return (string?)this;
+                    case PrimitiveTypeCode.GuidNullable:
+                        return (Guid?)this;
+                    case PrimitiveTypeCode.Guid:
+                        return (Guid)this;
+                    case PrimitiveTypeCode.Uri:
+                        return (Uri?)this;
+                    case PrimitiveTypeCode.TimeSpanNullable:
+                        return (TimeSpan?)this;
+                    case PrimitiveTypeCode.TimeSpan:
+                        return (TimeSpan)this;
+#if HAVE_BIG_INTEGER
+                    case PrimitiveTypeCode.BigIntegerNullable:
+                        return ToBigIntegerNullable(this);
+                    case PrimitiveTypeCode.BigInteger:
+                        return ToBigInteger(this);
+#endif
+                }
+            }
+
+            return ToObject(objectType, JsonSerializer.CreateDefault());
+        }
+
+        /// <summary>
+        /// Creates an instance of the specified .NET type from the <see cref="JToken"/> using the specified <see cref="JsonSerializer"/>.
+        /// </summary>
+        /// <typeparam name="T">The object type that the token will be deserialized to.</typeparam>
+        /// <param name="jsonSerializer">The <see cref="JsonSerializer"/> that will be used when creating the object.</param>
+        /// <returns>The new object created from the JSON value.</returns>
+        public T? ToObject<T>(JsonSerializer jsonSerializer)
+        {
+            return (T?)ToObject(typeof(T), jsonSerializer);
+        }
+
+        /// <summary>
+        /// Creates an instance of the specified .NET type from the <see cref="JToken"/> using the specified <see cref="JsonSerializer"/>.
+        /// </summary>
+        /// <param name="objectType">The object type that the token will be deserialized to.</param>
+        /// <param name="jsonSerializer">The <see cref="JsonSerializer"/> that will be used when creating the object.</param>
+        /// <returns>The new object created from the JSON value.</returns>
+        public object? ToObject(Type objectType, JsonSerializer jsonSerializer)
+        {
+            ValidationUtils.ArgumentNotNull(jsonSerializer, nameof(jsonSerializer));
+
+            using (JTokenReader jsonReader = new JTokenReader(this))
+            {
+                return jsonSerializer.Deserialize(jsonReader, objectType);
+            }
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <returns>
+        /// A <see cref="JToken"/> that contains the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static JToken ReadFrom(JsonReader reader)
+        {
+            return ReadFrom(reader, null);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">An <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>
+        /// A <see cref="JToken"/> that contains the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static JToken ReadFrom(JsonReader reader, JsonLoadSettings? settings)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            bool hasContent;
+            if (reader.TokenType == JsonToken.None)
+            {
+                hasContent = (settings != null && settings.CommentHandling == CommentHandling.Ignore)
+                    ? reader.ReadAndMoveToContent()
+                    : reader.Read();
+            }
+            else if (reader.TokenType == JsonToken.Comment && settings?.CommentHandling == CommentHandling.Ignore)
+            {
+                hasContent = reader.ReadAndMoveToContent();
+            }
+            else
+            {
+                hasContent = true;
+            }
+
+            if (!hasContent)
+            {
+                throw JsonReaderException.Create(reader, "Error reading JToken from JsonReader.");
+            }
+
+            IJsonLineInfo? lineInfo = reader as IJsonLineInfo;
+
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return JObject.Load(reader, settings);
+                case JsonToken.StartArray:
+                    return JArray.Load(reader, settings);
+                case JsonToken.StartConstructor:
+                    return JConstructor.Load(reader, settings);
+                case JsonToken.PropertyName:
+                    return JProperty.Load(reader, settings);
+                case JsonToken.String:
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.Date:
+                case JsonToken.Boolean:
+                case JsonToken.Bytes:
+                    JValue v = new JValue(reader.Value);
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                case JsonToken.Comment:
+                    v = JValue.CreateComment(reader.Value!.ToString());
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                case JsonToken.Null:
+                    v = JValue.CreateNull();
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                case JsonToken.Undefined:
+                    v = JValue.CreateUndefined();
+                    v.SetLineInfo(lineInfo, settings);
+                    return v;
+                default:
+                    throw JsonReaderException.Create(reader, "Error reading JToken from JsonReader. Unexpected token: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+        }
+
+        /// <summary>
+        /// Load a <see cref="JToken"/> from a string that contains JSON.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON.</param>
+        /// <returns>A <see cref="JToken"/> populated from the string that contains JSON.</returns>
+        public static JToken Parse(string json)
+        {
+            return Parse(json, null);
+        }
+
+        /// <summary>
+        /// Load a <see cref="JToken"/> from a string that contains JSON.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>A <see cref="JToken"/> populated from the string that contains JSON.</returns>
+        public static JToken Parse(string json, JsonLoadSettings? settings)
+        {
+            using (JsonReader reader = new JsonTextReader(new StringReader(json)))
+            {
+                JToken t = Load(reader, settings);
+
+                while (reader.Read())
+                {
+                    // Any content encountered here other than a comment will throw in the reader.
+                }
+
+                return t;
+            }
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <param name="settings">The <see cref="JsonLoadSettings"/> used to load the JSON.
+        /// If this is <c>null</c>, default load settings will be used.</param>
+        /// <returns>
+        /// A <see cref="JToken"/> that contains the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static JToken Load(JsonReader reader, JsonLoadSettings? settings)
+        {
+            return ReadFrom(reader, settings);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JToken"/> from a <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">A <see cref="JsonReader"/> positioned at the token to read into this <see cref="JToken"/>.</param>
+        /// <returns>
+        /// A <see cref="JToken"/> that contains the token and its descendant tokens
+        /// that were read from the reader. The runtime type of the token is determined
+        /// by the token type of the first token encountered in the reader.
+        /// </returns>
+        public static JToken Load(JsonReader reader)
+        {
+            return Load(reader, null);
+        }
+
+        internal void SetLineInfo(IJsonLineInfo? lineInfo, JsonLoadSettings? settings)
+        {
+            if (settings != null && settings.LineInfoHandling != LineInfoHandling.Load)
+            {
+                return;
+            }
+
+            if (lineInfo == null || !lineInfo.HasLineInfo())
+            {
+                return;
+            }
+
+            SetLineInfo(lineInfo.LineNumber, lineInfo.LinePosition);
+        }
+
+        private class LineInfoAnnotation
+        {
+            internal readonly int LineNumber;
+            internal readonly int LinePosition;
+
+            public LineInfoAnnotation(int lineNumber, int linePosition)
+            {
+                LineNumber = lineNumber;
+                LinePosition = linePosition;
+            }
+        }
+
+        internal void SetLineInfo(int lineNumber, int linePosition)
+        {
+            AddAnnotation(new LineInfoAnnotation(lineNumber, linePosition));
+        }
+
+        bool IJsonLineInfo.HasLineInfo()
+        {
+            return (Annotation<LineInfoAnnotation>() != null);
+        }
+
+        int IJsonLineInfo.LineNumber
+        {
+            get
+            {
+                LineInfoAnnotation? annotation = Annotation<LineInfoAnnotation>();
+                if (annotation != null)
+                {
+                    return annotation.LineNumber;
+                }
+
+                return 0;
+            }
+        }
+
+        int IJsonLineInfo.LinePosition
+        {
+            get
+            {
+                LineInfoAnnotation? annotation = Annotation<LineInfoAnnotation>();
+                if (annotation != null)
+                {
+                    return annotation.LinePosition;
+                }
+
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// Selects a <see cref="JToken"/> using a JSONPath expression. Selects the token that matches the object path.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JSONPath expression.
+        /// </param>
+        /// <returns>A <see cref="JToken"/>, or <c>null</c>.</returns>
+        public JToken? SelectToken(string path)
+        {
+            return SelectToken(path, settings: null);
+        }
+
+        /// <summary>
+        /// Selects a <see cref="JToken"/> using a JSONPath expression. Selects the token that matches the object path.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JSONPath expression.
+        /// </param>
+        /// <param name="errorWhenNoMatch">A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression.</param>
+        /// <returns>A <see cref="JToken"/>.</returns>
+        public JToken? SelectToken(string path, bool errorWhenNoMatch)
+        {
+            JsonSelectSettings? settings = errorWhenNoMatch
+                ? new JsonSelectSettings { ErrorWhenNoMatch = true }
+                : null;
+
+            return SelectToken(path, settings);
+        }
+
+        /// <summary>
+        /// Selects a <see cref="JToken"/> using a JSONPath expression. Selects the token that matches the object path.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JSONPath expression.
+        /// </param>
+        /// <param name="settings">The <see cref="JsonSelectSettings"/> used to select tokens.</param>
+        /// <returns>A <see cref="JToken"/>.</returns>
+        public JToken? SelectToken(string path, JsonSelectSettings? settings)
+        {
+            JPath p = new JPath(path);
+
+            JToken? token = null;
+            foreach (JToken t in p.Evaluate(this, this, settings))
+            {
+                if (token != null)
+                {
+                    throw new JsonException("Path returned multiple tokens.");
+                }
+
+                token = t;
+            }
+
+            return token;
+        }
+
+        /// <summary>
+        /// Selects a collection of elements using a JSONPath expression.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JSONPath expression.
+        /// </param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the selected elements.</returns>
+        public IEnumerable<JToken> SelectTokens(string path)
+        {
+            return SelectTokens(path, settings: null);
+        }
+
+        /// <summary>
+        /// Selects a collection of elements using a JSONPath expression.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JSONPath expression.
+        /// </param>
+        /// <param name="errorWhenNoMatch">A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the selected elements.</returns>
+        public IEnumerable<JToken> SelectTokens(string path, bool errorWhenNoMatch)
+        {
+            JsonSelectSettings? settings = errorWhenNoMatch
+                ? new JsonSelectSettings { ErrorWhenNoMatch = true }
+                : null;
+
+            return SelectTokens(path, settings);
+        }
+
+        /// <summary>
+        /// Selects a collection of elements using a JSONPath expression.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JSONPath expression.
+        /// </param>
+        /// <param name="settings">The <see cref="JsonSelectSettings"/> used to select tokens.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="JToken"/> that contains the selected elements.</returns>
+        public IEnumerable<JToken> SelectTokens(string path, JsonSelectSettings? settings)
+        {
+            var p = new JPath(path);
+            return p.Evaluate(this, this, settings);
+        }
+
+#if HAVE_DYNAMIC
+        /// <summary>
+        /// Returns the <see cref="DynamicMetaObject"/> responsible for binding operations performed on this object.
+        /// </summary>
+        /// <param name="parameter">The expression tree representation of the runtime value.</param>
+        /// <returns>
+        /// The <see cref="DynamicMetaObject"/> to bind this object.
+        /// </returns>
+        protected virtual DynamicMetaObject GetMetaObject(Expression parameter)
+        {
+            return new DynamicProxyMetaObject<JToken>(parameter, this, new DynamicProxy<JToken>());
+        }
+
+        /// <summary>
+        /// Returns the <see cref="DynamicMetaObject"/> responsible for binding operations performed on this object.
+        /// </summary>
+        /// <param name="parameter">The expression tree representation of the runtime value.</param>
+        /// <returns>
+        /// The <see cref="DynamicMetaObject"/> to bind this object.
+        /// </returns>
+        DynamicMetaObject IDynamicMetaObjectProvider.GetMetaObject(Expression parameter)
+        {
+            return GetMetaObject(parameter);
+        }
+#endif
+
+#if HAVE_ICLONEABLE
+        object ICloneable.Clone()
+        {
+            return DeepClone();
+        }
+#endif
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="JToken"/>. All child tokens are recursively cloned.
+        /// </summary>
+        /// <returns>A new instance of the <see cref="JToken"/>.</returns>
+        public JToken DeepClone()
+        {
+            return CloneToken();
+        }
+
+        /// <summary>
+        /// Adds an object to the annotation list of this <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="annotation">The annotation to add.</param>
+        public void AddAnnotation(object annotation)
+        {
+            if (annotation == null)
+            {
+                throw new ArgumentNullException(nameof(annotation));
+            }
+
+            if (_annotations == null)
+            {
+                _annotations = (annotation is object[]) ? new[] { annotation } : annotation;
+            }
+            else
+            {
+                if (!(_annotations is object[] annotations))
+                {
+                    _annotations = new[] { _annotations, annotation };
+                }
+                else
+                {
+                    int index = 0;
+                    while (index < annotations.Length && annotations[index] != null)
+                    {
+                        index++;
+                    }
+                    if (index == annotations.Length)
+                    {
+                        Array.Resize(ref annotations, index * 2);
+                        _annotations = annotations;
+                    }
+                    annotations[index] = annotation;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the first annotation object of the specified type from this <see cref="JToken"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the annotation to retrieve.</typeparam>
+        /// <returns>The first annotation object that matches the specified type, or <c>null</c> if no annotation is of the specified type.</returns>
+        public T? Annotation<T>() where T : class
+        {
+            if (_annotations != null)
+            {
+                if (!(_annotations is object[] annotations))
+                {
+                    return (_annotations as T);
+                }
+                for (int i = 0; i < annotations.Length; i++)
+                {
+                    object annotation = annotations[i];
+                    if (annotation == null)
+                    {
+                        break;
+                    }
+
+                    if (annotation is T local)
+                    {
+                        return local;
+                    }
+                }
+            }
+
+            return default;
+        }
+
+        /// <summary>
+        /// Gets the first annotation object of the specified type from this <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="type">The <see cref="Type"/> of the annotation to retrieve.</param>
+        /// <returns>The first annotation object that matches the specified type, or <c>null</c> if no annotation is of the specified type.</returns>
+        public object? Annotation(Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            if (_annotations != null)
+            {
+                if (!(_annotations is object[] annotations))
+                {
+                    if (type.IsInstanceOfType(_annotations))
+                    {
+                        return _annotations;
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < annotations.Length; i++)
+                    {
+                        object o = annotations[i];
+                        if (o == null)
+                        {
+                            break;
+                        }
+
+                        if (type.IsInstanceOfType(o))
+                        {
+                            return o;
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets a collection of annotations of the specified type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the annotations to retrieve.</typeparam>
+        /// <returns>An <see cref="IEnumerable{T}"/> that contains the annotations for this <see cref="JToken"/>.</returns>
+        public IEnumerable<T> Annotations<T>() where T : class
+        {
+            if (_annotations == null)
+            {
+                yield break;
+            }
+
+            if (_annotations is object[] annotations)
+            {
+                for (int i = 0; i < annotations.Length; i++)
+                {
+                    object o = annotations[i];
+                    if (o == null)
+                    {
+                        break;
+                    }
+
+                    if (o is T casted)
+                    {
+                        yield return casted;
+                    }
+                }
+                yield break;
+            }
+
+            if (!(_annotations is T annotation))
+            {
+                yield break;
+            }
+
+            yield return annotation;
+        }
+
+        /// <summary>
+        /// Gets a collection of annotations of the specified type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="type">The <see cref="Type"/> of the annotations to retrieve.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="Object"/> that contains the annotations that match the specified type for this <see cref="JToken"/>.</returns>
+        public IEnumerable<object> Annotations(Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            if (_annotations == null)
+            {
+                yield break;
+            }
+
+            if (_annotations is object[] annotations)
+            {
+                for (int i = 0; i < annotations.Length; i++)
+                {
+                    object o = annotations[i];
+                    if (o == null)
+                    {
+                        break;
+                    }
+
+                    if (type.IsInstanceOfType(o))
+                    {
+                        yield return o;
+                    }
+                }
+                yield break;
+            }
+
+            if (!type.IsInstanceOfType(_annotations))
+            {
+                yield break;
+            }
+
+            yield return _annotations;
+        }
+
+        /// <summary>
+        /// Removes the annotations of the specified type from this <see cref="JToken"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of annotations to remove.</typeparam>
+        public void RemoveAnnotations<T>() where T : class
+        {
+            if (_annotations != null)
+            {
+                if (!(_annotations is object?[] annotations))
+                {
+                    if (_annotations is T)
+                    {
+                        _annotations = null;
+                    }
+                }
+                else
+                {
+                    int index = 0;
+                    int keepCount = 0;
+                    while (index < annotations.Length)
+                    {
+                        object? obj2 = annotations[index];
+                        if (obj2 == null)
+                        {
+                            break;
+                        }
+
+                        if (!(obj2 is T))
+                        {
+                            annotations[keepCount++] = obj2;
+                        }
+
+                        index++;
+                    }
+
+                    if (keepCount != 0)
+                    {
+                        while (keepCount < index)
+                        {
+                            annotations[keepCount++] = null;
+                        }
+                    }
+                    else
+                    {
+                        _annotations = null;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Removes the annotations of the specified type from this <see cref="JToken"/>.
+        /// </summary>
+        /// <param name="type">The <see cref="Type"/> of annotations to remove.</param>
+        public void RemoveAnnotations(Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            if (_annotations != null)
+            {
+                if (!(_annotations is object?[] annotations))
+                {
+                    if (type.IsInstanceOfType(_annotations))
+                    {
+                        _annotations = null;
+                    }
+                }
+                else
+                {
+                    int index = 0;
+                    int keepCount = 0;
+                    while (index < annotations.Length)
+                    {
+                        object? o = annotations[index];
+                        if (o == null)
+                        {
+                            break;
+                        }
+
+                        if (!type.IsInstanceOfType(o))
+                        {
+                            annotations[keepCount++] = o;
+                        }
+
+                        index++;
+                    }
+
+                    if (keepCount != 0)
+                    {
+                        while (keepCount < index)
+                        {
+                            annotations[keepCount++] = null;
+                        }
+                    }
+                    else
+                    {
+                        _annotations = null;
+                    }
+                }
+            }
+        }
+
+        internal void CopyAnnotations(JToken target, JToken source)
+        {
+            if (source._annotations is object[] annotations)
+            {
+                target._annotations = annotations.ToArray();
+            }
+            else
+            {
+                target._annotations = source._annotations;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JTokenEqualityComparer.cs b/Libs/Newtonsoft.Json/Linq/JTokenEqualityComparer.cs
new file mode 100644
index 0000000..b0e3367
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JTokenEqualityComparer.cs
@@ -0,0 +1,64 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Compares tokens to determine whether they are equal.
+    /// </summary>
+    public class JTokenEqualityComparer : IEqualityComparer<JToken>
+    {
+        /// <summary>
+        /// Determines whether the specified objects are equal.
+        /// </summary>
+        /// <param name="x">The first object of type <see cref="JToken"/> to compare.</param>
+        /// <param name="y">The second object of type <see cref="JToken"/> to compare.</param>
+        /// <returns>
+        /// <c>true</c> if the specified objects are equal; otherwise, <c>false</c>.
+        /// </returns>
+        public bool Equals(JToken x, JToken y)
+        {
+            return JToken.DeepEquals(x, y);
+        }
+
+        /// <summary>
+        /// Returns a hash code for the specified object.
+        /// </summary>
+        /// <param name="obj">The <see cref="System.Object"/> for which a hash code is to be returned.</param>
+        /// <returns>A hash code for the specified object.</returns>
+        /// <exception cref="System.ArgumentNullException">The type of <paramref name="obj"/> is a reference type and <paramref name="obj"/> is <c>null</c>.</exception>
+        public int GetHashCode(JToken obj)
+        {
+            if (obj == null)
+            {
+                return 0;
+            }
+
+            return obj.GetDeepHashCode();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JTokenReader.cs b/Libs/Newtonsoft.Json/Linq/JTokenReader.cs
new file mode 100644
index 0000000..b066191
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JTokenReader.cs
@@ -0,0 +1,345 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data.
+    /// </summary>
+    public class JTokenReader : JsonReader, IJsonLineInfo
+    {
+        private readonly JToken _root;
+        private string? _initialPath;
+        private JToken? _parent;
+        private JToken? _current;
+
+        /// <summary>
+        /// Gets the <see cref="JToken"/> at the reader's current position.
+        /// </summary>
+        public JToken? CurrentToken => _current;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JTokenReader"/> class.
+        /// </summary>
+        /// <param name="token">The token to read from.</param>
+        public JTokenReader(JToken token)
+        {
+            ValidationUtils.ArgumentNotNull(token, nameof(token));
+
+            _root = token;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JTokenReader"/> class.
+        /// </summary>
+        /// <param name="token">The token to read from.</param>
+        /// <param name="initialPath">The initial path of the token. It is prepended to the returned <see cref="Path"/>.</param>
+        public JTokenReader(JToken token, string initialPath)
+            : this(token)
+        {
+            _initialPath = initialPath;
+        }
+
+        /// <summary>
+        /// Reads the next JSON token from the underlying <see cref="JToken"/>.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the next token was read successfully; <c>false</c> if there are no more tokens to read.
+        /// </returns>
+        public override bool Read()
+        {
+            if (CurrentState != State.Start)
+            {
+                if (_current == null)
+                {
+                    return false;
+                }
+
+                if (_current is JContainer container && _parent != container)
+                {
+                    return ReadInto(container);
+                }
+                else
+                {
+                    return ReadOver(_current);
+                }
+            }
+
+            // The current value could already be the root value if it is a comment
+            if (_current == _root)
+            {
+                return false;
+            }
+
+            _current = _root;
+            SetToken(_current);
+            return true;
+        }
+
+        private bool ReadOver(JToken t)
+        {
+            if (t == _root)
+            {
+                return ReadToEnd();
+            }
+
+            JToken? next = t.Next;
+            if ((next == null || next == t) || t == t.Parent!.Last)
+            {
+                if (t.Parent == null)
+                {
+                    return ReadToEnd();
+                }
+
+                return SetEnd(t.Parent);
+            }
+            else
+            {
+                _current = next;
+                SetToken(_current);
+                return true;
+            }
+        }
+
+        private bool ReadToEnd()
+        {
+            _current = null;
+            SetToken(JsonToken.None);
+            return false;
+        }
+
+        private JsonToken? GetEndToken(JContainer c)
+        {
+            switch (c.Type)
+            {
+                case JTokenType.Object:
+                    return JsonToken.EndObject;
+                case JTokenType.Array:
+                    return JsonToken.EndArray;
+                case JTokenType.Constructor:
+                    return JsonToken.EndConstructor;
+                case JTokenType.Property:
+                    return null;
+                default:
+                    throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(c.Type), c.Type, "Unexpected JContainer type.");
+            }
+        }
+
+        private bool ReadInto(JContainer c)
+        {
+            JToken? firstChild = c.First;
+            if (firstChild == null)
+            {
+                return SetEnd(c);
+            }
+            else
+            {
+                SetToken(firstChild);
+                _current = firstChild;
+                _parent = c;
+                return true;
+            }
+        }
+
+        private bool SetEnd(JContainer c)
+        {
+            JsonToken? endToken = GetEndToken(c);
+            if (endToken != null)
+            {
+                SetToken(endToken.GetValueOrDefault());
+                _current = c;
+                _parent = c;
+                return true;
+            }
+            else
+            {
+                return ReadOver(c);
+            }
+        }
+
+        private void SetToken(JToken token)
+        {
+            switch (token.Type)
+            {
+                case JTokenType.Object:
+                    SetToken(JsonToken.StartObject);
+                    break;
+                case JTokenType.Array:
+                    SetToken(JsonToken.StartArray);
+                    break;
+                case JTokenType.Constructor:
+                    SetToken(JsonToken.StartConstructor, ((JConstructor)token).Name);
+                    break;
+                case JTokenType.Property:
+                    SetToken(JsonToken.PropertyName, ((JProperty)token).Name);
+                    break;
+                case JTokenType.Comment:
+                    SetToken(JsonToken.Comment, ((JValue)token).Value);
+                    break;
+                case JTokenType.Integer:
+                    SetToken(JsonToken.Integer, ((JValue)token).Value);
+                    break;
+                case JTokenType.Float:
+                    SetToken(JsonToken.Float, ((JValue)token).Value);
+                    break;
+                case JTokenType.String:
+                    SetToken(JsonToken.String, ((JValue)token).Value);
+                    break;
+                case JTokenType.Boolean:
+                    SetToken(JsonToken.Boolean, ((JValue)token).Value);
+                    break;
+                case JTokenType.Null:
+                    SetToken(JsonToken.Null, ((JValue)token).Value);
+                    break;
+                case JTokenType.Undefined:
+                    SetToken(JsonToken.Undefined, ((JValue)token).Value);
+                    break;
+                case JTokenType.Date:
+                    {
+                        object? v = ((JValue)token).Value;
+                        if (v is DateTime dt)
+                        {
+                            v = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
+                        }
+
+                        SetToken(JsonToken.Date, v);
+                        break;
+                    }
+                case JTokenType.Raw:
+                    SetToken(JsonToken.Raw, ((JValue)token).Value);
+                    break;
+                case JTokenType.Bytes:
+                    SetToken(JsonToken.Bytes, ((JValue)token).Value);
+                    break;
+                case JTokenType.Guid:
+                    SetToken(JsonToken.String, SafeToString(((JValue)token).Value));
+                    break;
+                case JTokenType.Uri:
+                    {
+                        object? v = ((JValue)token).Value;
+                        SetToken(JsonToken.String, v is Uri uri ? uri.OriginalString : SafeToString(v));
+                        break;
+                    }
+                case JTokenType.TimeSpan:
+                    SetToken(JsonToken.String, SafeToString(((JValue)token).Value));
+                    break;
+                default:
+                    throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(token.Type), token.Type, "Unexpected JTokenType.");
+            }
+        }
+
+        private string? SafeToString(object? value)
+        {
+            return value?.ToString();
+        }
+
+        bool IJsonLineInfo.HasLineInfo()
+        {
+            if (CurrentState == State.Start)
+            {
+                return false;
+            }
+
+            IJsonLineInfo? info = _current;
+            return (info != null && info.HasLineInfo());
+        }
+
+        int IJsonLineInfo.LineNumber
+        {
+            get
+            {
+                if (CurrentState == State.Start)
+                {
+                    return 0;
+                }
+
+                IJsonLineInfo? info = _current;
+                if (info != null)
+                {
+                    return info.LineNumber;
+                }
+
+                return 0;
+            }
+        }
+
+        int IJsonLineInfo.LinePosition
+        {
+            get
+            {
+                if (CurrentState == State.Start)
+                {
+                    return 0;
+                }
+
+                IJsonLineInfo? info = _current;
+                if (info != null)
+                {
+                    return info.LinePosition;
+                }
+
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets the path of the current JSON token. 
+        /// </summary>
+        public override string Path
+        {
+            get
+            {
+                string path = base.Path;
+
+                if (_initialPath == null)
+                {
+                    _initialPath = _root.Path;
+                }
+
+                if (!StringUtils.IsNullOrEmpty(_initialPath))
+                {
+                    if (StringUtils.IsNullOrEmpty(path))
+                    {
+                        return _initialPath;
+                    }
+
+                    if (path.StartsWith('['))
+                    {
+                        path = _initialPath + path;
+                    }
+                    else
+                    {
+                        path = _initialPath + "." + path;
+                    }
+                }
+
+                return path;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JTokenType.cs b/Libs/Newtonsoft.Json/Linq/JTokenType.cs
new file mode 100644
index 0000000..c3aa22c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JTokenType.cs
@@ -0,0 +1,123 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies the type of token.
+    /// </summary>
+    public enum JTokenType
+    {
+        /// <summary>
+        /// No token type has been set.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// A JSON object.
+        /// </summary>
+        Object = 1,
+
+        /// <summary>
+        /// A JSON array.
+        /// </summary>
+        Array = 2,
+
+        /// <summary>
+        /// A JSON constructor.
+        /// </summary>
+        Constructor = 3,
+
+        /// <summary>
+        /// A JSON object property.
+        /// </summary>
+        Property = 4,
+
+        /// <summary>
+        /// A comment.
+        /// </summary>
+        Comment = 5,
+
+        /// <summary>
+        /// An integer value.
+        /// </summary>
+        Integer = 6,
+
+        /// <summary>
+        /// A float value.
+        /// </summary>
+        Float = 7,
+
+        /// <summary>
+        /// A string value.
+        /// </summary>
+        String = 8,
+
+        /// <summary>
+        /// A boolean value.
+        /// </summary>
+        Boolean = 9,
+
+        /// <summary>
+        /// A null value.
+        /// </summary>
+        Null = 10,
+
+        /// <summary>
+        /// An undefined value.
+        /// </summary>
+        Undefined = 11,
+
+        /// <summary>
+        /// A date value.
+        /// </summary>
+        Date = 12,
+
+        /// <summary>
+        /// A raw JSON value.
+        /// </summary>
+        Raw = 13,
+
+        /// <summary>
+        /// A collection of bytes value.
+        /// </summary>
+        Bytes = 14,
+
+        /// <summary>
+        /// A Guid value.
+        /// </summary>
+        Guid = 15,
+
+        /// <summary>
+        /// A Uri value.
+        /// </summary>
+        Uri = 16,
+
+        /// <summary>
+        /// A TimeSpan value.
+        /// </summary>
+        TimeSpan = 17
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JTokenWriter.Async.cs b/Libs/Newtonsoft.Json/Linq/JTokenWriter.Async.cs
new file mode 100644
index 0000000..a55125d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JTokenWriter.Async.cs
@@ -0,0 +1,53 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public partial class JTokenWriter
+    {
+        // This is the only method that can benefit from Task-based asynchronicity, and that only when
+        // the reader provides it.
+        internal override Task WriteTokenAsync(JsonReader reader, bool writeChildren, bool writeDateConstructorAsDate, bool writeComments, CancellationToken cancellationToken)
+        {
+            // Since JTokenReader is a common target (and with an optimised path) and since it can't
+            // read truly async, catch that case.
+            if (reader is JTokenReader)
+            {
+                WriteToken(reader, writeChildren, writeDateConstructorAsDate, writeComments);
+                return AsyncUtils.CompletedTask;
+            }
+
+            return WriteTokenSyncReadingAsync(reader, cancellationToken);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JTokenWriter.cs b/Libs/Newtonsoft.Json/Linq/JTokenWriter.cs
new file mode 100644
index 0000000..ce3efde
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JTokenWriter.cs
@@ -0,0 +1,538 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Diagnostics;
+using System.Globalization;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data.
+    /// </summary>
+    public partial class JTokenWriter : JsonWriter
+    {
+        private JContainer? _token;
+        private JContainer? _parent;
+        // used when writer is writing single value and the value has no containing parent
+        private JValue? _value;
+        private JToken? _current;
+
+        /// <summary>
+        /// Gets the <see cref="JToken"/> at the writer's current position.
+        /// </summary>
+        public JToken? CurrentToken => _current;
+
+        /// <summary>
+        /// Gets the token being written.
+        /// </summary>
+        /// <value>The token being written.</value>
+        public JToken? Token
+        {
+            get
+            {
+                if (_token != null)
+                {
+                    return _token;
+                }
+
+                return _value;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JTokenWriter"/> class writing to the given <see cref="JContainer"/>.
+        /// </summary>
+        /// <param name="container">The container being written to.</param>
+        public JTokenWriter(JContainer container)
+        {
+            ValidationUtils.ArgumentNotNull(container, nameof(container));
+
+            _token = container;
+            _parent = container;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JTokenWriter"/> class.
+        /// </summary>
+        public JTokenWriter()
+        {
+        }
+
+        /// <summary>
+        /// Flushes whatever is in the buffer to the underlying <see cref="JContainer"/>.
+        /// </summary>
+        public override void Flush()
+        {
+        }
+
+        /// <summary>
+        /// Closes this writer.
+        /// If <see cref="JsonWriter.AutoCompleteOnClose"/> is set to <c>true</c>, the JSON is auto-completed.
+        /// </summary>
+        /// <remarks>
+        /// Setting <see cref="JsonWriter.CloseOutput"/> to <c>true</c> has no additional effect, since the underlying <see cref="JContainer"/> is a type that cannot be closed.
+        /// </remarks>
+        public override void Close()
+        {
+            base.Close();
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON object.
+        /// </summary>
+        public override void WriteStartObject()
+        {
+            base.WriteStartObject();
+
+            AddParent(new JObject());
+        }
+
+        private void AddParent(JContainer container)
+        {
+            if (_parent == null)
+            {
+                _token = container;
+            }
+            else
+            {
+                _parent.AddAndSkipParentCheck(container);
+            }
+
+            _parent = container;
+            _current = container;
+        }
+
+        private void RemoveParent()
+        {
+            _current = _parent;
+            _parent = _parent!.Parent;
+
+            if (_parent != null && _parent.Type == JTokenType.Property)
+            {
+                _parent = _parent.Parent;
+            }
+        }
+
+        /// <summary>
+        /// Writes the beginning of a JSON array.
+        /// </summary>
+        public override void WriteStartArray()
+        {
+            base.WriteStartArray();
+
+            AddParent(new JArray());
+        }
+
+        /// <summary>
+        /// Writes the start of a constructor with the given name.
+        /// </summary>
+        /// <param name="name">The name of the constructor.</param>
+        public override void WriteStartConstructor(string name)
+        {
+            base.WriteStartConstructor(name);
+
+            AddParent(new JConstructor(name));
+        }
+
+        /// <summary>
+        /// Writes the end.
+        /// </summary>
+        /// <param name="token">The token.</param>
+        protected override void WriteEnd(JsonToken token)
+        {
+            RemoveParent();
+        }
+
+        /// <summary>
+        /// Writes the property name of a name/value pair on a JSON object.
+        /// </summary>
+        /// <param name="name">The name of the property.</param>
+        public override void WritePropertyName(string name)
+        {
+            // avoid duplicate property name exception
+            // last property name wins
+            (_parent as JObject)?.Remove(name);
+
+            AddParent(new JProperty(name));
+
+            // don't set state until after in case of an error
+            // incorrect state will cause issues if writer is disposed when closing open properties
+            base.WritePropertyName(name);
+        }
+
+        private void AddValue(object? value, JsonToken token)
+        {
+            AddValue(new JValue(value), token);
+        }
+
+        internal void AddValue(JValue? value, JsonToken token)
+        {
+            if (_parent != null)
+            {
+                // TryAdd will return false if an invalid JToken type is added.
+                // For example, a JComment can't be added to a JObject.
+                // If there is an invalid JToken type then skip it.
+                if (_parent.TryAdd(value))
+                {
+                    _current = _parent.Last;
+
+                    if (_parent.Type == JTokenType.Property)
+                    {
+                        _parent = _parent.Parent;
+                    }
+                }
+            }
+            else
+            {
+                _value = value ?? JValue.CreateNull();
+                _current = _value;
+            }
+        }
+
+        #region WriteValue methods
+        /// <summary>
+        /// Writes a <see cref="Object"/> value.
+        /// An error will be raised if the value cannot be written as a single JSON token.
+        /// </summary>
+        /// <param name="value">The <see cref="Object"/> value to write.</param>
+        public override void WriteValue(object? value)
+        {
+#if HAVE_BIG_INTEGER
+            if (value is BigInteger)
+            {
+                InternalWriteValue(JsonToken.Integer);
+                AddValue(value, JsonToken.Integer);
+            }
+            else
+#endif
+            {
+                base.WriteValue(value);
+            }
+        }
+
+        /// <summary>
+        /// Writes a null value.
+        /// </summary>
+        public override void WriteNull()
+        {
+            base.WriteNull();
+            AddValue(null, JsonToken.Null);
+        }
+
+        /// <summary>
+        /// Writes an undefined value.
+        /// </summary>
+        public override void WriteUndefined()
+        {
+            base.WriteUndefined();
+            AddValue(null, JsonToken.Undefined);
+        }
+
+        /// <summary>
+        /// Writes raw JSON.
+        /// </summary>
+        /// <param name="json">The raw JSON to write.</param>
+        public override void WriteRaw(string? json)
+        {
+            base.WriteRaw(json);
+            AddValue(new JRaw(json), JsonToken.Raw);
+        }
+
+        /// <summary>
+        /// Writes a comment <c>/*...*/</c> containing the specified text.
+        /// </summary>
+        /// <param name="text">Text to place inside the comment.</param>
+        public override void WriteComment(string? text)
+        {
+            base.WriteComment(text);
+            AddValue(JValue.CreateComment(text), JsonToken.Comment);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="String"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="String"/> value to write.</param>
+        public override void WriteValue(string? value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int32"/> value to write.</param>
+        public override void WriteValue(int value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt32"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt32"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(uint value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int64"/> value to write.</param>
+        public override void WriteValue(long value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt64"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt64"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(ulong value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Single"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Single"/> value to write.</param>
+        public override void WriteValue(float value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Double"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Double"/> value to write.</param>
+        public override void WriteValue(double value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Boolean"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Boolean"/> value to write.</param>
+        public override void WriteValue(bool value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Boolean);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Int16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Int16"/> value to write.</param>
+        public override void WriteValue(short value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="UInt16"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="UInt16"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(ushort value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Char"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Char"/> value to write.</param>
+        public override void WriteValue(char value)
+        {
+            base.WriteValue(value);
+            string s;
+#if HAVE_CHAR_TO_STRING_WITH_CULTURE
+            s = value.ToString(CultureInfo.InvariantCulture);
+#else
+            s = value.ToString();
+#endif
+            AddValue(s, JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/> value to write.</param>
+        public override void WriteValue(byte value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="SByte"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="SByte"/> value to write.</param>
+        [CLSCompliant(false)]
+        public override void WriteValue(sbyte value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Integer);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Decimal"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Decimal"/> value to write.</param>
+        public override void WriteValue(decimal value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Float);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="DateTime"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
+        public override void WriteValue(DateTime value)
+        {
+            base.WriteValue(value);
+            value = DateTimeUtils.EnsureDateTime(value, DateTimeZoneHandling);
+            AddValue(value, JsonToken.Date);
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Writes a <see cref="DateTimeOffset"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="DateTimeOffset"/> value to write.</param>
+        public override void WriteValue(DateTimeOffset value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Date);
+        }
+#endif
+
+        /// <summary>
+        /// Writes a <see cref="Byte"/>[] value.
+        /// </summary>
+        /// <param name="value">The <see cref="Byte"/>[] value to write.</param>
+        public override void WriteValue(byte[]? value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.Bytes);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="TimeSpan"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="TimeSpan"/> value to write.</param>
+        public override void WriteValue(TimeSpan value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Guid"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Guid"/> value to write.</param>
+        public override void WriteValue(Guid value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.String);
+        }
+
+        /// <summary>
+        /// Writes a <see cref="Uri"/> value.
+        /// </summary>
+        /// <param name="value">The <see cref="Uri"/> value to write.</param>
+        public override void WriteValue(Uri? value)
+        {
+            base.WriteValue(value);
+            AddValue(value, JsonToken.String);
+        }
+        #endregion
+
+        internal override void WriteToken(JsonReader reader, bool writeChildren, bool writeDateConstructorAsDate, bool writeComments)
+        {
+            // cloning the token rather than reading then writing it doesn't lose some type information, e.g. Guid, byte[], etc
+            if (reader is JTokenReader tokenReader && writeChildren && writeDateConstructorAsDate && writeComments)
+            {
+                if (tokenReader.TokenType == JsonToken.None)
+                {
+                    if (!tokenReader.Read())
+                    {
+                        return;
+                    }
+                }
+
+                JToken value = tokenReader.CurrentToken!.CloneToken();
+
+                if (_parent != null)
+                {
+                    _parent.Add(value);
+                    _current = _parent.Last;
+
+                    // if the writer was in a property then move out of it and up to its parent object
+                    if (_parent.Type == JTokenType.Property)
+                    {
+                        _parent = _parent.Parent;
+                        InternalWriteValue(JsonToken.Null);
+                    }
+                }
+                else
+                {
+                    _current = value;
+
+                    if (_token == null && _value == null)
+                    {
+                        _token = value as JContainer;
+                        _value = value as JValue;
+                    }
+                }
+
+                tokenReader.Skip();
+            }
+            else
+            {
+                base.WriteToken(reader, writeChildren, writeDateConstructorAsDate, writeComments);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JValue.Async.cs b/Libs/Newtonsoft.Json/Linq/JValue.Async.cs
new file mode 100644
index 0000000..2408541
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JValue.Async.cs
@@ -0,0 +1,138 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System;
+using System.Globalization;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    public partial class JValue
+    {
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/> asynchronously.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        public override Task WriteToAsync(JsonWriter writer, CancellationToken cancellationToken, params JsonConverter[] converters)
+        {
+            if (converters != null && converters.Length > 0 && _value != null)
+            {
+                JsonConverter? matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType());
+                if (matchingConverter != null && matchingConverter.CanWrite)
+                {
+                    // TODO: Call WriteJsonAsync when it exists.
+                    matchingConverter.WriteJson(writer, _value, JsonSerializer.CreateDefault());
+                    return AsyncUtils.CompletedTask;
+                }
+            }
+
+            switch (_valueType)
+            {
+                case JTokenType.Comment:
+                    return writer.WriteCommentAsync(_value?.ToString(), cancellationToken);
+                case JTokenType.Raw:
+                    return writer.WriteRawValueAsync(_value?.ToString(), cancellationToken);
+                case JTokenType.Null:
+                    return writer.WriteNullAsync(cancellationToken);
+                case JTokenType.Undefined:
+                    return writer.WriteUndefinedAsync(cancellationToken);
+                case JTokenType.Integer:
+                    if (_value is int i)
+                    {
+                        return writer.WriteValueAsync(i, cancellationToken);
+                    }
+
+                    if (_value is long l)
+                    {
+                        return writer.WriteValueAsync(l, cancellationToken);
+                    }
+
+                    if (_value is ulong ul)
+                    {
+                        return writer.WriteValueAsync(ul, cancellationToken);
+                    }
+
+#if HAVE_BIG_INTEGER
+                    if (_value is BigInteger integer)
+                    {
+                        return writer.WriteValueAsync(integer, cancellationToken);
+                    }
+#endif
+
+                    return writer.WriteValueAsync(Convert.ToInt64(_value, CultureInfo.InvariantCulture), cancellationToken);
+                case JTokenType.Float:
+                    if (_value is decimal dec)
+                    {
+                        return writer.WriteValueAsync(dec, cancellationToken);
+                    }
+
+                    if (_value is double d)
+                    {
+                        return writer.WriteValueAsync(d, cancellationToken);
+                    }
+
+                    if (_value is float f)
+                    {
+                        return writer.WriteValueAsync(f, cancellationToken);
+                    }
+
+                    return writer.WriteValueAsync(Convert.ToDouble(_value, CultureInfo.InvariantCulture), cancellationToken);
+                case JTokenType.String:
+                    return writer.WriteValueAsync(_value?.ToString(), cancellationToken);
+                case JTokenType.Boolean:
+                    return writer.WriteValueAsync(Convert.ToBoolean(_value, CultureInfo.InvariantCulture), cancellationToken);
+                case JTokenType.Date:
+                    if (_value is DateTimeOffset offset)
+                    {
+                        return writer.WriteValueAsync(offset, cancellationToken);
+                    }
+
+                    return writer.WriteValueAsync(Convert.ToDateTime(_value, CultureInfo.InvariantCulture), cancellationToken);
+                case JTokenType.Bytes:
+                    return writer.WriteValueAsync((byte[]?)_value, cancellationToken);
+                case JTokenType.Guid:
+                    return writer.WriteValueAsync(_value != null ? (Guid?)_value : null, cancellationToken);
+                case JTokenType.TimeSpan:
+                    return writer.WriteValueAsync(_value != null ? (TimeSpan?)_value : null, cancellationToken);
+                case JTokenType.Uri:
+                    return writer.WriteValueAsync((Uri?)_value, cancellationToken);
+            }
+
+            throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(Type), _valueType, "Unexpected token type.");
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/Linq/JValue.cs b/Libs/Newtonsoft.Json/Linq/JValue.cs
new file mode 100644
index 0000000..12a59c0
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JValue.cs
@@ -0,0 +1,1187 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if HAVE_DYNAMIC
+using System.Dynamic;
+using System.Linq.Expressions;
+#endif
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Represents a value in JSON (string, integer, date, etc).
+    /// </summary>
+    public partial class JValue : JToken, IEquatable<JValue>, IFormattable, IComparable, IComparable<JValue>
+#if HAVE_ICONVERTIBLE
+        , IConvertible
+#endif
+    {
+        private JTokenType _valueType;
+        private object? _value;
+
+        internal JValue(object? value, JTokenType type)
+        {
+            _value = value;
+            _valueType = type;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class from another <see cref="JValue"/> object.
+        /// </summary>
+        /// <param name="other">A <see cref="JValue"/> object to copy from.</param>
+        public JValue(JValue other)
+            : this(other.Value, other.Type)
+        {
+            CopyAnnotations(this, other);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(long value)
+            : this(value, JTokenType.Integer)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(decimal value)
+            : this(value, JTokenType.Float)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(char value)
+            : this(value, JTokenType.String)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        [CLSCompliant(false)]
+        public JValue(ulong value)
+            : this(value, JTokenType.Integer)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(double value)
+            : this(value, JTokenType.Float)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(float value)
+            : this(value, JTokenType.Float)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(DateTime value)
+            : this(value, JTokenType.Date)
+        {
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(DateTimeOffset value)
+            : this(value, JTokenType.Date)
+        {
+        }
+#endif
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(bool value)
+            : this(value, JTokenType.Boolean)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(string? value)
+            : this(value, JTokenType.String)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(Guid value)
+            : this(value, JTokenType.Guid)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(Uri? value)
+            : this(value, (value != null) ? JTokenType.Uri : JTokenType.Null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(TimeSpan value)
+            : this(value, JTokenType.TimeSpan)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JValue"/> class with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public JValue(object? value)
+            : this(value, GetValueType(null, value))
+        {
+        }
+
+        internal override bool DeepEquals(JToken node)
+        {
+            if (!(node is JValue other))
+            {
+                return false;
+            }
+            if (other == this)
+            {
+                return true;
+            }
+
+            return ValuesEquals(this, other);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this token has child tokens.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this token has child values; otherwise, <c>false</c>.
+        /// </value>
+        public override bool HasValues => false;
+
+#if HAVE_BIG_INTEGER
+        private static int CompareBigInteger(BigInteger i1, object i2)
+        {
+            int result = i1.CompareTo(ConvertUtils.ToBigInteger(i2));
+
+            if (result != 0)
+            {
+                return result;
+            }
+
+            // converting a fractional number to a BigInteger will lose the fraction
+            // check for fraction if result is two numbers are equal
+            if (i2 is decimal d1)
+            {
+                return (0m).CompareTo(Math.Abs(d1 - Math.Truncate(d1)));
+            }
+            else if (i2 is double || i2 is float)
+            {
+                double d = Convert.ToDouble(i2, CultureInfo.InvariantCulture);
+                return (0d).CompareTo(Math.Abs(d - Math.Truncate(d)));
+            }
+
+            return result;
+        }
+#endif
+
+        internal static int Compare(JTokenType valueType, object? objA, object? objB)
+        {
+            if (objA == objB)
+            {
+                return 0;
+            }
+            if (objB == null)
+            {
+                return 1;
+            }
+            if (objA == null)
+            {
+                return -1;
+            }
+
+            switch (valueType)
+            {
+                case JTokenType.Integer:
+                {
+#if HAVE_BIG_INTEGER
+                    if (objA is BigInteger integerA)
+                    {
+                        return CompareBigInteger(integerA, objB);
+                    }
+                    if (objB is BigInteger integerB)
+                    {
+                            return -CompareBigInteger(integerB, objA);
+                        }
+#endif
+                    if (objA is ulong || objB is ulong || objA is decimal || objB is decimal)
+                    {
+                        return Convert.ToDecimal(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(objB, CultureInfo.InvariantCulture));
+                    }
+                    else if (objA is float || objB is float || objA is double || objB is double)
+                    {
+                        return CompareFloat(objA, objB);
+                    }
+                    else
+                    {
+                        return Convert.ToInt64(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToInt64(objB, CultureInfo.InvariantCulture));
+                    }
+                }
+                case JTokenType.Float:
+                {
+#if HAVE_BIG_INTEGER
+                    if (objA is BigInteger integerA)
+                    {
+                        return CompareBigInteger(integerA, objB);
+                    }
+                    if (objB is BigInteger integerB)
+                    {
+                        return -CompareBigInteger(integerB, objA);
+                    }
+#endif
+                    if (objA is ulong || objB is ulong || objA is decimal || objB is decimal)
+                    {
+                        return Convert.ToDecimal(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(objB, CultureInfo.InvariantCulture));
+                    }
+                    return CompareFloat(objA, objB);
+                    }
+                case JTokenType.Comment:
+                case JTokenType.String:
+                case JTokenType.Raw:
+                    string s1 = Convert.ToString(objA, CultureInfo.InvariantCulture);
+                    string s2 = Convert.ToString(objB, CultureInfo.InvariantCulture);
+
+                    return string.CompareOrdinal(s1, s2);
+                case JTokenType.Boolean:
+                    bool b1 = Convert.ToBoolean(objA, CultureInfo.InvariantCulture);
+                    bool b2 = Convert.ToBoolean(objB, CultureInfo.InvariantCulture);
+
+                    return b1.CompareTo(b2);
+                case JTokenType.Date:
+#if HAVE_DATE_TIME_OFFSET
+                    if (objA is DateTime dateA)
+                    {
+#else
+                        DateTime dateA = (DateTime)objA;
+#endif
+                        DateTime dateB;
+
+#if HAVE_DATE_TIME_OFFSET
+                        if (objB is DateTimeOffset offsetB)
+                        {
+                            dateB = offsetB.DateTime;
+                        }
+                        else
+#endif
+                        {
+                            dateB = Convert.ToDateTime(objB, CultureInfo.InvariantCulture);
+                        }
+
+                        return dateA.CompareTo(dateB);
+#if HAVE_DATE_TIME_OFFSET
+                    }
+                    else
+                    {
+                        DateTimeOffset offsetA = (DateTimeOffset)objA;
+                        if (!(objB is DateTimeOffset offsetB))
+                        {
+                            offsetB = new DateTimeOffset(Convert.ToDateTime(objB, CultureInfo.InvariantCulture));
+                        }
+
+                        return offsetA.CompareTo(offsetB);
+                    }
+#endif
+                case JTokenType.Bytes:
+                    if (!(objB is byte[] bytesB))
+                    {
+                        throw new ArgumentException("Object must be of type byte[].");
+                    }
+
+                    byte[]? bytesA = objA as byte[];
+                    MiscellaneousUtils.Assert(bytesA != null);
+
+                    return MiscellaneousUtils.ByteArrayCompare(bytesA!, bytesB);
+                case JTokenType.Guid:
+                    if (!(objB is Guid))
+                    {
+                        throw new ArgumentException("Object must be of type Guid.");
+                    }
+
+                    Guid guid1 = (Guid)objA;
+                    Guid guid2 = (Guid)objB;
+
+                    return guid1.CompareTo(guid2);
+                case JTokenType.Uri:
+                    Uri? uri2 = objB as Uri;
+                    if (uri2 == null)
+                    {
+                        throw new ArgumentException("Object must be of type Uri.");
+                    }
+
+                    Uri uri1 = (Uri)objA;
+
+                    return Comparer<string>.Default.Compare(uri1.ToString(), uri2.ToString());
+                case JTokenType.TimeSpan:
+                    if (!(objB is TimeSpan))
+                    {
+                        throw new ArgumentException("Object must be of type TimeSpan.");
+                    }
+
+                    TimeSpan ts1 = (TimeSpan)objA;
+                    TimeSpan ts2 = (TimeSpan)objB;
+
+                    return ts1.CompareTo(ts2);
+                default:
+                    throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(valueType), valueType, "Unexpected value type: {0}".FormatWith(CultureInfo.InvariantCulture, valueType));
+            }
+        }
+
+        private static int CompareFloat(object objA, object objB)
+        {
+            double d1 = Convert.ToDouble(objA, CultureInfo.InvariantCulture);
+            double d2 = Convert.ToDouble(objB, CultureInfo.InvariantCulture);
+
+            // take into account possible floating point errors
+            if (MathUtils.ApproxEquals(d1, d2))
+            {
+                return 0;
+            }
+
+            return d1.CompareTo(d2);
+        }
+
+#if HAVE_EXPRESSIONS
+        private static bool Operation(ExpressionType operation, object? objA, object? objB, out object? result)
+        {
+            if (objA is string || objB is string)
+            {
+                if (operation == ExpressionType.Add || operation == ExpressionType.AddAssign)
+                {
+                    result = objA?.ToString() + objB?.ToString();
+                    return true;
+                }
+            }
+
+#if HAVE_BIG_INTEGER
+            if (objA is BigInteger || objB is BigInteger)
+            {
+                if (objA == null || objB == null)
+                {
+                    result = null;
+                    return true;
+                }
+
+                // not that this will lose the fraction
+                // BigInteger doesn't have operators with non-integer types
+                BigInteger i1 = ConvertUtils.ToBigInteger(objA);
+                BigInteger i2 = ConvertUtils.ToBigInteger(objB);
+
+                switch (operation)
+                {
+                    case ExpressionType.Add:
+                    case ExpressionType.AddAssign:
+                        result = i1 + i2;
+                        return true;
+                    case ExpressionType.Subtract:
+                    case ExpressionType.SubtractAssign:
+                        result = i1 - i2;
+                        return true;
+                    case ExpressionType.Multiply:
+                    case ExpressionType.MultiplyAssign:
+                        result = i1 * i2;
+                        return true;
+                    case ExpressionType.Divide:
+                    case ExpressionType.DivideAssign:
+                        result = i1 / i2;
+                        return true;
+                }
+            }
+            else
+#endif
+                if (objA is ulong || objB is ulong || objA is decimal || objB is decimal)
+                {
+                    if (objA == null || objB == null)
+                    {
+                        result = null;
+                        return true;
+                    }
+
+                    decimal d1 = Convert.ToDecimal(objA, CultureInfo.InvariantCulture);
+                    decimal d2 = Convert.ToDecimal(objB, CultureInfo.InvariantCulture);
+
+                    switch (operation)
+                    {
+                        case ExpressionType.Add:
+                        case ExpressionType.AddAssign:
+                            result = d1 + d2;
+                            return true;
+                        case ExpressionType.Subtract:
+                        case ExpressionType.SubtractAssign:
+                            result = d1 - d2;
+                            return true;
+                        case ExpressionType.Multiply:
+                        case ExpressionType.MultiplyAssign:
+                            result = d1 * d2;
+                            return true;
+                        case ExpressionType.Divide:
+                        case ExpressionType.DivideAssign:
+                            result = d1 / d2;
+                            return true;
+                    }
+                }
+                else if (objA is float || objB is float || objA is double || objB is double)
+                {
+                    if (objA == null || objB == null)
+                    {
+                        result = null;
+                        return true;
+                    }
+
+                    double d1 = Convert.ToDouble(objA, CultureInfo.InvariantCulture);
+                    double d2 = Convert.ToDouble(objB, CultureInfo.InvariantCulture);
+
+                    switch (operation)
+                    {
+                        case ExpressionType.Add:
+                        case ExpressionType.AddAssign:
+                            result = d1 + d2;
+                            return true;
+                        case ExpressionType.Subtract:
+                        case ExpressionType.SubtractAssign:
+                            result = d1 - d2;
+                            return true;
+                        case ExpressionType.Multiply:
+                        case ExpressionType.MultiplyAssign:
+                            result = d1 * d2;
+                            return true;
+                        case ExpressionType.Divide:
+                        case ExpressionType.DivideAssign:
+                            result = d1 / d2;
+                            return true;
+                    }
+                }
+                else if (objA is int || objA is uint || objA is long || objA is short || objA is ushort || objA is sbyte || objA is byte ||
+                         objB is int || objB is uint || objB is long || objB is short || objB is ushort || objB is sbyte || objB is byte)
+                {
+                    if (objA == null || objB == null)
+                    {
+                        result = null;
+                        return true;
+                    }
+
+                    long l1 = Convert.ToInt64(objA, CultureInfo.InvariantCulture);
+                    long l2 = Convert.ToInt64(objB, CultureInfo.InvariantCulture);
+
+                    switch (operation)
+                    {
+                        case ExpressionType.Add:
+                        case ExpressionType.AddAssign:
+                            result = l1 + l2;
+                            return true;
+                        case ExpressionType.Subtract:
+                        case ExpressionType.SubtractAssign:
+                            result = l1 - l2;
+                            return true;
+                        case ExpressionType.Multiply:
+                        case ExpressionType.MultiplyAssign:
+                            result = l1 * l2;
+                            return true;
+                        case ExpressionType.Divide:
+                        case ExpressionType.DivideAssign:
+                            result = l1 / l2;
+                            return true;
+                    }
+                }
+
+            result = null;
+            return false;
+        }
+#endif
+
+        internal override JToken CloneToken()
+        {
+            return new JValue(this);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JValue"/> comment with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>A <see cref="JValue"/> comment with the given value.</returns>
+        public static JValue CreateComment(string? value)
+        {
+            return new JValue(value, JTokenType.Comment);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JValue"/> string with the given value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>A <see cref="JValue"/> string with the given value.</returns>
+        public static JValue CreateString(string? value)
+        {
+            return new JValue(value, JTokenType.String);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JValue"/> null value.
+        /// </summary>
+        /// <returns>A <see cref="JValue"/> null value.</returns>
+        public static JValue CreateNull()
+        {
+            return new JValue(null, JTokenType.Null);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JValue"/> undefined value.
+        /// </summary>
+        /// <returns>A <see cref="JValue"/> undefined value.</returns>
+        public static JValue CreateUndefined()
+        {
+            return new JValue(null, JTokenType.Undefined);
+        }
+
+        private static JTokenType GetValueType(JTokenType? current, object? value)
+        {
+            if (value == null)
+            {
+                return JTokenType.Null;
+            }
+#if HAVE_ADO_NET
+            else if (value == DBNull.Value)
+            {
+                return JTokenType.Null;
+            }
+#endif
+            else if (value is string)
+            {
+                return GetStringValueType(current);
+            }
+            else if (value is long || value is int || value is short || value is sbyte
+                     || value is ulong || value is uint || value is ushort || value is byte)
+            {
+                return JTokenType.Integer;
+            }
+            else if (value is Enum)
+            {
+                return JTokenType.Integer;
+            }
+#if HAVE_BIG_INTEGER
+            else if (value is BigInteger)
+            {
+                return JTokenType.Integer;
+            }
+#endif
+            else if (value is double || value is float || value is decimal)
+            {
+                return JTokenType.Float;
+            }
+            else if (value is DateTime)
+            {
+                return JTokenType.Date;
+            }
+#if HAVE_DATE_TIME_OFFSET
+            else if (value is DateTimeOffset)
+            {
+                return JTokenType.Date;
+            }
+#endif
+            else if (value is byte[])
+            {
+                return JTokenType.Bytes;
+            }
+            else if (value is bool)
+            {
+                return JTokenType.Boolean;
+            }
+            else if (value is Guid)
+            {
+                return JTokenType.Guid;
+            }
+            else if (value is Uri)
+            {
+                return JTokenType.Uri;
+            }
+            else if (value is TimeSpan)
+            {
+                return JTokenType.TimeSpan;
+            }
+
+            throw new ArgumentException("Could not determine JSON object type for type {0}.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
+        }
+
+        private static JTokenType GetStringValueType(JTokenType? current)
+        {
+            if (current == null)
+            {
+                return JTokenType.String;
+            }
+
+            switch (current.GetValueOrDefault())
+            {
+                case JTokenType.Comment:
+                case JTokenType.String:
+                case JTokenType.Raw:
+                    return current.GetValueOrDefault();
+                default:
+                    return JTokenType.String;
+            }
+        }
+
+        /// <summary>
+        /// Gets the node type for this <see cref="JToken"/>.
+        /// </summary>
+        /// <value>The type.</value>
+        public override JTokenType Type => _valueType;
+
+        /// <summary>
+        /// Gets or sets the underlying token value.
+        /// </summary>
+        /// <value>The underlying token value.</value>
+        public object? Value
+        {
+            get => _value;
+            set
+            {
+                Type? currentType = _value?.GetType();
+                Type? newType = value?.GetType();
+
+                if (currentType != newType)
+                {
+                    _valueType = GetValueType(_valueType, value);
+                }
+
+                _value = value;
+            }
+        }
+
+        /// <summary>
+        /// Writes this token to a <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="converters">A collection of <see cref="JsonConverter"/>s which will be used when writing the token.</param>
+        public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
+        {
+            if (converters != null && converters.Length > 0 && _value != null)
+            {
+                JsonConverter? matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType());
+                if (matchingConverter != null && matchingConverter.CanWrite)
+                {
+                    matchingConverter.WriteJson(writer, _value, JsonSerializer.CreateDefault());
+                    return;
+                }
+            }
+
+            switch (_valueType)
+            {
+                case JTokenType.Comment:
+                    writer.WriteComment(_value?.ToString());
+                    return;
+                case JTokenType.Raw:
+                    writer.WriteRawValue(_value?.ToString());
+                    return;
+                case JTokenType.Null:
+                    writer.WriteNull();
+                    return;
+                case JTokenType.Undefined:
+                    writer.WriteUndefined();
+                    return;
+                case JTokenType.Integer:
+                    if (_value is int i)
+                    {
+                        writer.WriteValue(i);
+                    }
+                    else if (_value is long l)
+                    {
+                        writer.WriteValue(l);
+                    }
+                    else if (_value is ulong ul)
+                    {
+                        writer.WriteValue(ul);
+                    }
+#if HAVE_BIG_INTEGER
+                    else if (_value is BigInteger integer)
+                    {
+                        writer.WriteValue(integer);
+                    }
+#endif
+                    else
+                    {
+                        writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture));
+                    }
+                    return;
+                case JTokenType.Float:
+                    if (_value is decimal dec)
+                    {
+                        writer.WriteValue(dec);
+                    }
+                    else if (_value is double d)
+                    {
+                        writer.WriteValue(d);
+                    }
+                    else if (_value is float f)
+                    {
+                        writer.WriteValue(f);
+                    }
+                    else
+                    {
+                        writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture));
+                    }
+                    return;
+                case JTokenType.String:
+                    writer.WriteValue(_value?.ToString());
+                    return;
+                case JTokenType.Boolean:
+                    writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture));
+                    return;
+                case JTokenType.Date:
+#if HAVE_DATE_TIME_OFFSET
+                    if (_value is DateTimeOffset offset)
+                    {
+                        writer.WriteValue(offset);
+                    }
+                    else
+#endif
+                    {
+                        writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture));
+                    }
+                    return;
+                case JTokenType.Bytes:
+                    writer.WriteValue((byte[]?)_value);
+                    return;
+                case JTokenType.Guid:
+                    writer.WriteValue((_value != null) ? (Guid?)_value : null);
+                    return;
+                case JTokenType.TimeSpan:
+                    writer.WriteValue((_value != null) ? (TimeSpan?)_value : null);
+                    return;
+                case JTokenType.Uri:
+                    writer.WriteValue((Uri?)_value);
+                    return;
+            }
+
+            throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(Type), _valueType, "Unexpected token type.");
+        }
+
+        internal override int GetDeepHashCode()
+        {
+            int valueHashCode = (_value != null) ? _value.GetHashCode() : 0;
+
+            // GetHashCode on an enum boxes so cast to int
+            return ((int)_valueType).GetHashCode() ^ valueHashCode;
+        }
+
+        private static bool ValuesEquals(JValue v1, JValue v2)
+        {
+            return (v1 == v2 || (v1._valueType == v2._valueType && Compare(v1._valueType, v1._value, v2._value) == 0));
+        }
+
+        /// <summary>
+        /// Indicates whether the current object is equal to another object of the same type.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> if the current object is equal to the <paramref name="other"/> parameter; otherwise, <c>false</c>.
+        /// </returns>
+        /// <param name="other">An object to compare with this object.</param>
+        public bool Equals(JValue? other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return ValuesEquals(this, other);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="Object"/> is equal to the current <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare with the current <see cref="Object"/>.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref="Object"/> is equal to the current <see cref="Object"/>; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is JValue v)
+            {
+                return Equals(v);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a particular type.
+        /// </summary>
+        /// <returns>
+        /// A hash code for the current <see cref="Object"/>.
+        /// </returns>
+        public override int GetHashCode()
+        {
+            if (_value == null)
+            {
+                return 0;
+            }
+
+            return _value.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> that represents this instance.
+        /// </summary>
+        /// <remarks>
+        /// <c>ToString()</c> returns a non-JSON string value for tokens with a type of <see cref="JTokenType.String"/>.
+        /// If you want the JSON for all token types then you should use <see cref="WriteTo(JsonWriter, JsonConverter[])"/>.
+        /// </remarks>
+        /// <returns>
+        /// A <see cref="String"/> that represents this instance.
+        /// </returns>
+        public override string ToString()
+        {
+            if (_value == null)
+            {
+                return string.Empty;
+            }
+
+            return _value.ToString();
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> that represents this instance.
+        /// </summary>
+        /// <param name="format">The format.</param>
+        /// <returns>
+        /// A <see cref="String"/> that represents this instance.
+        /// </returns>
+        public string ToString(string format)
+        {
+            return ToString(format, CultureInfo.CurrentCulture);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> that represents this instance.
+        /// </summary>
+        /// <param name="formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref="String"/> that represents this instance.
+        /// </returns>
+        public string ToString(IFormatProvider formatProvider)
+        {
+            return ToString(null, formatProvider);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> that represents this instance.
+        /// </summary>
+        /// <param name="format">The format.</param>
+        /// <param name="formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref="String"/> that represents this instance.
+        /// </returns>
+        public string ToString(string? format, IFormatProvider formatProvider)
+        {
+            if (_value == null)
+            {
+                return string.Empty;
+            }
+
+            if (_value is IFormattable formattable)
+            {
+                return formattable.ToString(format, formatProvider);
+            }
+            else
+            {
+                return _value.ToString();
+            }
+        }
+
+#if HAVE_DYNAMIC
+        /// <summary>
+        /// Returns the <see cref="DynamicMetaObject"/> responsible for binding operations performed on this object.
+        /// </summary>
+        /// <param name="parameter">The expression tree representation of the runtime value.</param>
+        /// <returns>
+        /// The <see cref="DynamicMetaObject"/> to bind this object.
+        /// </returns>
+        protected override DynamicMetaObject GetMetaObject(Expression parameter)
+        {
+            return new DynamicProxyMetaObject<JValue>(parameter, this, new JValueDynamicProxy());
+        }
+
+        private class JValueDynamicProxy : DynamicProxy<JValue>
+        {
+            public override bool TryConvert(JValue instance, ConvertBinder binder, [NotNullWhen(true)]out object? result)
+            {
+                if (binder.Type == typeof(JValue) || binder.Type == typeof(JToken))
+                {
+                    result = instance;
+                    return true;
+                }
+
+                object? value = instance.Value;
+
+                if (value == null)
+                {
+                    result = null;
+                    return ReflectionUtils.IsNullable(binder.Type);
+                }
+
+                result = ConvertUtils.Convert(value, CultureInfo.InvariantCulture, binder.Type);
+                return true;
+            }
+
+            public override bool TryBinaryOperation(JValue instance, BinaryOperationBinder binder, object arg, [NotNullWhen(true)]out object? result)
+            {
+                object? compareValue = arg is JValue value ? value.Value : arg;
+
+                switch (binder.Operation)
+                {
+                    case ExpressionType.Equal:
+                        result = (Compare(instance.Type, instance.Value, compareValue) == 0);
+                        return true;
+                    case ExpressionType.NotEqual:
+                        result = (Compare(instance.Type, instance.Value, compareValue) != 0);
+                        return true;
+                    case ExpressionType.GreaterThan:
+                        result = (Compare(instance.Type, instance.Value, compareValue) > 0);
+                        return true;
+                    case ExpressionType.GreaterThanOrEqual:
+                        result = (Compare(instance.Type, instance.Value, compareValue) >= 0);
+                        return true;
+                    case ExpressionType.LessThan:
+                        result = (Compare(instance.Type, instance.Value, compareValue) < 0);
+                        return true;
+                    case ExpressionType.LessThanOrEqual:
+                        result = (Compare(instance.Type, instance.Value, compareValue) <= 0);
+                        return true;
+                    case ExpressionType.Add:
+                    case ExpressionType.AddAssign:
+                    case ExpressionType.Subtract:
+                    case ExpressionType.SubtractAssign:
+                    case ExpressionType.Multiply:
+                    case ExpressionType.MultiplyAssign:
+                    case ExpressionType.Divide:
+                    case ExpressionType.DivideAssign:
+                        if (Operation(binder.Operation, instance.Value, compareValue, out result))
+                        {
+                            result = new JValue(result);
+                            return true;
+                        }
+                        break;
+                }
+
+                result = null;
+                return false;
+            }
+        }
+#endif
+
+        int IComparable.CompareTo(object obj)
+        {
+            if (obj == null)
+            {
+                return 1;
+            }
+
+            JTokenType comparisonType;
+            object? otherValue;
+            if (obj is JValue value)
+            {
+                otherValue = value.Value;
+                comparisonType = (_valueType == JTokenType.String && _valueType != value._valueType)
+                    ? value._valueType
+                    : _valueType;
+            }
+            else
+            {
+                otherValue = obj;
+                comparisonType = _valueType;
+            }
+
+            return Compare(comparisonType, _value, otherValue);
+        }
+
+        /// <summary>
+        /// Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.
+        /// </summary>
+        /// <param name="obj">An object to compare with this instance.</param>
+        /// <returns>
+        /// A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has these meanings:
+        /// Value
+        /// Meaning
+        /// Less than zero
+        /// This instance is less than <paramref name="obj"/>.
+        /// Zero
+        /// This instance is equal to <paramref name="obj"/>.
+        /// Greater than zero
+        /// This instance is greater than <paramref name="obj"/>.
+        /// </returns>
+        /// <exception cref="ArgumentException">
+        /// 	<paramref name="obj"/> is not of the same type as this instance.
+        /// </exception>
+        public int CompareTo(JValue obj)
+        {
+            if (obj == null)
+            {
+                return 1;
+            }
+
+            JTokenType comparisonType = (_valueType == JTokenType.String && _valueType != obj._valueType)
+                ? obj._valueType
+                : _valueType;
+
+            return Compare(comparisonType, _value, obj._value);
+        }
+
+#if HAVE_ICONVERTIBLE
+        TypeCode IConvertible.GetTypeCode()
+        {
+            if (_value == null)
+            {
+                return TypeCode.Empty;
+            }
+
+            if (_value is IConvertible convertable)
+            {
+                return convertable.GetTypeCode();
+            }
+
+            return TypeCode.Object;
+        }
+
+        bool IConvertible.ToBoolean(IFormatProvider provider)
+        {
+            return (bool)this;
+        }
+
+        char IConvertible.ToChar(IFormatProvider provider)
+        {
+            return (char)this;
+        }
+
+        sbyte IConvertible.ToSByte(IFormatProvider provider)
+        {
+            return (sbyte)this;
+        }
+
+        byte IConvertible.ToByte(IFormatProvider provider)
+        {
+            return (byte)this;
+        }
+
+        short IConvertible.ToInt16(IFormatProvider provider)
+        {
+            return (short)this;
+        }
+
+        ushort IConvertible.ToUInt16(IFormatProvider provider)
+        {
+            return (ushort)this;
+        }
+
+        int IConvertible.ToInt32(IFormatProvider provider)
+        {
+            return (int)this;
+        }
+
+        uint IConvertible.ToUInt32(IFormatProvider provider)
+        {
+            return (uint)this;
+        }
+
+        long IConvertible.ToInt64(IFormatProvider provider)
+        {
+            return (long)this;
+        }
+
+        ulong IConvertible.ToUInt64(IFormatProvider provider)
+        {
+            return (ulong)this;
+        }
+
+        float IConvertible.ToSingle(IFormatProvider provider)
+        {
+            return (float)this;
+        }
+
+        double IConvertible.ToDouble(IFormatProvider provider)
+        {
+            return (double)this;
+        }
+
+        decimal IConvertible.ToDecimal(IFormatProvider provider)
+        {
+            return (decimal)this;
+        }
+
+        DateTime IConvertible.ToDateTime(IFormatProvider provider)
+        {
+            return (DateTime)this;
+        }
+
+        object? IConvertible.ToType(Type conversionType, IFormatProvider provider)
+        {
+            return ToObject(conversionType);
+        }
+#endif
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Linq/JsonLoadSettings.cs b/Libs/Newtonsoft.Json/Linq/JsonLoadSettings.cs
new file mode 100644
index 0000000..b6ef0ae
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonLoadSettings.cs
@@ -0,0 +1,81 @@
+using System;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies the settings used when loading JSON.
+    /// </summary>
+    public class JsonLoadSettings
+    {
+        private CommentHandling _commentHandling;
+        private LineInfoHandling _lineInfoHandling;
+        private DuplicatePropertyNameHandling _duplicatePropertyNameHandling;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonLoadSettings"/> class.
+        /// </summary>
+        public JsonLoadSettings()
+        {
+            _lineInfoHandling = LineInfoHandling.Load;
+            _commentHandling = CommentHandling.Ignore;
+            _duplicatePropertyNameHandling = DuplicatePropertyNameHandling.Replace;
+        }
+
+        /// <summary>
+        /// Gets or sets how JSON comments are handled when loading JSON.
+        /// The default value is <see cref="CommentHandling.Ignore" />.
+        /// </summary>
+        /// <value>The JSON comment handling.</value>
+        public CommentHandling CommentHandling
+        {
+            get => _commentHandling;
+            set
+            {
+                if (value < CommentHandling.Ignore || value > CommentHandling.Load)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _commentHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how JSON line info is handled when loading JSON.
+        /// The default value is <see cref="LineInfoHandling.Load" />.
+        /// </summary>
+        /// <value>The JSON line info handling.</value>
+        public LineInfoHandling LineInfoHandling
+        {
+            get => _lineInfoHandling;
+            set
+            {
+                if (value < LineInfoHandling.Ignore || value > LineInfoHandling.Load)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _lineInfoHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how duplicate property names in JSON objects are handled when loading JSON.
+        /// The default value is <see cref="DuplicatePropertyNameHandling.Replace" />.
+        /// </summary>
+        /// <value>The JSON duplicate property name handling.</value>
+        public DuplicatePropertyNameHandling DuplicatePropertyNameHandling
+        {
+            get => _duplicatePropertyNameHandling;
+            set
+            {
+                if (value < DuplicatePropertyNameHandling.Replace || value > DuplicatePropertyNameHandling.Error)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _duplicatePropertyNameHandling = value;
+            }
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Linq/JsonMergeSettings.cs b/Libs/Newtonsoft.Json/Linq/JsonMergeSettings.cs
new file mode 100644
index 0000000..f40ae05
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonMergeSettings.cs
@@ -0,0 +1,103 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies the settings used when merging JSON.
+    /// </summary>
+    public class JsonMergeSettings
+    {
+        private MergeArrayHandling _mergeArrayHandling;
+        private MergeNullValueHandling _mergeNullValueHandling;
+        private StringComparison _propertyNameComparison;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonMergeSettings"/> class.
+        /// </summary>
+        public JsonMergeSettings()
+        {
+            _propertyNameComparison = StringComparison.Ordinal;
+        }
+
+        /// <summary>
+        /// Gets or sets the method used when merging JSON arrays.
+        /// </summary>
+        /// <value>The method used when merging JSON arrays.</value>
+        public MergeArrayHandling MergeArrayHandling
+        {
+            get => _mergeArrayHandling;
+            set
+            {
+                if (value < MergeArrayHandling.Concat || value > MergeArrayHandling.Merge)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _mergeArrayHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how null value properties are merged.
+        /// </summary>
+        /// <value>How null value properties are merged.</value>
+        public MergeNullValueHandling MergeNullValueHandling
+        {
+            get => _mergeNullValueHandling;
+            set
+            {
+                if (value < MergeNullValueHandling.Ignore || value > MergeNullValueHandling.Merge)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _mergeNullValueHandling = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the comparison used to match property names while merging.
+        /// The exact property name will be searched for first and if no matching property is found then
+        /// the <see cref="StringComparison"/> will be used to match a property.
+        /// </summary>
+        /// <value>The comparison used to match property names while merging.</value>
+        public StringComparison PropertyNameComparison
+        {
+            get => _propertyNameComparison;
+            set
+            {
+                if (value < StringComparison.CurrentCulture || value > StringComparison.OrdinalIgnoreCase)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value));
+                }
+
+                _propertyNameComparison = value;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/ArrayIndexFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/ArrayIndexFilter.cs
new file mode 100644
index 0000000..dd0654c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/ArrayIndexFilter.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ArrayIndexFilter : PathFilter
+    {
+        public int? Index { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken t in current)
+            {
+                if (Index != null)
+                {
+                    JToken? v = GetTokenIndex(t, settings, Index.GetValueOrDefault());
+
+                    if (v != null)
+                    {
+                        yield return v;
+                    }
+                }
+                else
+                {
+                    if (t is JArray || t is JConstructor)
+                    {
+                        foreach (JToken v in t)
+                        {
+                            yield return v;
+                        }
+                    }
+                    else
+                    {
+                        if (settings?.ErrorWhenNoMatch ?? false)
+                        {
+                            throw new JsonException("Index * not valid on {0}.".FormatWith(CultureInfo.InvariantCulture, t.GetType().Name));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/ArrayMultipleIndexFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/ArrayMultipleIndexFilter.cs
new file mode 100644
index 0000000..fb7c2e4
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/ArrayMultipleIndexFilter.cs
@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ArrayMultipleIndexFilter : PathFilter
+    {
+        internal List<int> Indexes;
+
+        public ArrayMultipleIndexFilter(List<int> indexes)
+        {
+            Indexes = indexes;
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken t in current)
+            {
+                foreach (int i in Indexes)
+                {
+                    JToken? v = GetTokenIndex(t, settings, i);
+
+                    if (v != null)
+                    {
+                        yield return v;
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/ArraySliceFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/ArraySliceFilter.cs
new file mode 100644
index 0000000..2370da8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/ArraySliceFilter.cs
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ArraySliceFilter : PathFilter
+    {
+        public int? Start { get; set; }
+        public int? End { get; set; }
+        public int? Step { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            if (Step == 0)
+            {
+                throw new JsonException("Step cannot be zero.");
+            }
+
+            foreach (JToken t in current)
+            {
+                if (t is JArray a)
+                {
+                    // set defaults for null arguments
+                    int stepCount = Step ?? 1;
+                    int startIndex = Start ?? ((stepCount > 0) ? 0 : a.Count - 1);
+                    int stopIndex = End ?? ((stepCount > 0) ? a.Count : -1);
+
+                    // start from the end of the list if start is negative
+                    if (Start < 0)
+                    {
+                        startIndex = a.Count + startIndex;
+                    }
+
+                    // end from the start of the list if stop is negative
+                    if (End < 0)
+                    {
+                        stopIndex = a.Count + stopIndex;
+                    }
+
+                    // ensure indexes keep within collection bounds
+                    startIndex = Math.Max(startIndex, (stepCount > 0) ? 0 : int.MinValue);
+                    startIndex = Math.Min(startIndex, (stepCount > 0) ? a.Count : a.Count - 1);
+                    stopIndex = Math.Max(stopIndex, -1);
+                    stopIndex = Math.Min(stopIndex, a.Count);
+
+                    bool positiveStep = (stepCount > 0);
+
+                    if (IsValid(startIndex, stopIndex, positiveStep))
+                    {
+                        for (int i = startIndex; IsValid(i, stopIndex, positiveStep); i += stepCount)
+                        {
+                            yield return a[i];
+                        }
+                    }
+                    else
+                    {
+                        if (settings?.ErrorWhenNoMatch ?? false)
+                        {
+                            throw new JsonException("Array slice of {0} to {1} returned no results.".FormatWith(CultureInfo.InvariantCulture,
+                                Start != null ? Start.GetValueOrDefault().ToString(CultureInfo.InvariantCulture) : "*",
+                                End != null ? End.GetValueOrDefault().ToString(CultureInfo.InvariantCulture) : "*"));
+                        }
+                    }
+                }
+                else
+                {
+                    if (settings?.ErrorWhenNoMatch ?? false)
+                    {
+                        throw new JsonException("Array slice is not valid on {0}.".FormatWith(CultureInfo.InvariantCulture, t.GetType().Name));
+                    }
+                }
+            }
+        }
+
+        private bool IsValid(int index, int stopIndex, bool positiveStep)
+        {
+            if (positiveStep)
+            {
+                return (index < stopIndex);
+            }
+
+            return (index > stopIndex);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/FieldFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/FieldFilter.cs
new file mode 100644
index 0000000..d1ded0c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/FieldFilter.cs
@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class FieldFilter : PathFilter
+    {
+        internal string? Name;
+
+        public FieldFilter(string? name)
+        {
+            Name = name;
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken t in current)
+            {
+                if (t is JObject o)
+                {
+                    if (Name != null)
+                    {
+                        JToken? v = o[Name];
+
+                        if (v != null)
+                        {
+                            yield return v;
+                        }
+                        else if (settings?.ErrorWhenNoMatch ?? false)
+                        {
+                            throw new JsonException("Property '{0}' does not exist on JObject.".FormatWith(CultureInfo.InvariantCulture, Name));
+                        }
+                    }
+                    else
+                    {
+                        foreach (KeyValuePair<string, JToken?> p in o)
+                        {
+                            yield return p.Value!;
+                        }
+                    }
+                }
+                else
+                {
+                    if (settings?.ErrorWhenNoMatch ?? false)
+                    {
+                        throw new JsonException("Property '{0}' not valid on {1}.".FormatWith(CultureInfo.InvariantCulture, Name ?? "*", t.GetType().Name));
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/FieldMultipleFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/FieldMultipleFilter.cs
new file mode 100644
index 0000000..196290a
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/FieldMultipleFilter.cs
@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using System.Globalization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class FieldMultipleFilter : PathFilter
+    {
+        internal List<string> Names;
+
+        public FieldMultipleFilter(List<string> names)
+        {
+            Names = names;
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken t in current)
+            {
+                if (t is JObject o)
+                {
+                    foreach (string name in Names)
+                    {
+                        JToken? v = o[name];
+
+                        if (v != null)
+                        {
+                            yield return v;
+                        }
+
+                        if (settings?.ErrorWhenNoMatch ?? false)
+                        {
+                            throw new JsonException("Property '{0}' does not exist on JObject.".FormatWith(CultureInfo.InvariantCulture, name));
+                        }
+                    }
+                }
+                else
+                {
+                    if (settings?.ErrorWhenNoMatch ?? false)
+                    {
+                        throw new JsonException("Properties {0} not valid on {1}.".FormatWith(CultureInfo.InvariantCulture, string.Join(", ", Names.Select(n => "'" + n + "'")
+#if !HAVE_STRING_JOIN_WITH_ENUMERABLE
+                            .ToArray()
+#endif
+                            ), t.GetType().Name));
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/JPath.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/JPath.cs
new file mode 100644
index 0000000..d4d0ad7
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/JPath.cs
@@ -0,0 +1,893 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class JPath
+    {
+        private static readonly char[] FloatCharacters = new[] {'.', 'E', 'e'};
+
+        private readonly string _expression;
+        public List<PathFilter> Filters { get; }
+
+        private int _currentIndex;
+
+        public JPath(string expression)
+        {
+            ValidationUtils.ArgumentNotNull(expression, nameof(expression));
+            _expression = expression;
+            Filters = new List<PathFilter>();
+
+            ParseMain();
+        }
+
+        private void ParseMain()
+        {
+            int currentPartStartIndex = _currentIndex;
+
+            EatWhitespace();
+
+            if (_expression.Length == _currentIndex)
+            {
+                return;
+            }
+
+            if (_expression[_currentIndex] == '$')
+            {
+                if (_expression.Length == 1)
+                {
+                    return;
+                }
+
+                // only increment position for "$." or "$["
+                // otherwise assume property that starts with $
+                char c = _expression[_currentIndex + 1];
+                if (c == '.' || c == '[')
+                {
+                    _currentIndex++;
+                    currentPartStartIndex = _currentIndex;
+                }
+            }
+
+            if (!ParsePath(Filters, currentPartStartIndex, false))
+            {
+                int lastCharacterIndex = _currentIndex;
+
+                EatWhitespace();
+
+                if (_currentIndex < _expression.Length)
+                {
+                    throw new JsonException("Unexpected character while parsing path: " + _expression[lastCharacterIndex]);
+                }
+            }
+        }
+
+        private bool ParsePath(List<PathFilter> filters, int currentPartStartIndex, bool query)
+        {
+            bool scan = false;
+            bool followingIndexer = false;
+            bool followingDot = false;
+
+            bool ended = false;
+            while (_currentIndex < _expression.Length && !ended)
+            {
+                char currentChar = _expression[_currentIndex];
+
+                switch (currentChar)
+                {
+                    case '[':
+                    case '(':
+                        if (_currentIndex > currentPartStartIndex)
+                        {
+                            string? member = _expression.Substring(currentPartStartIndex, _currentIndex - currentPartStartIndex);
+                            if (member == "*")
+                            {
+                                member = null;
+                            }
+
+                            filters.Add(CreatePathFilter(member, scan));
+                            scan = false;
+                        }
+
+                        filters.Add(ParseIndexer(currentChar, scan));
+                        scan = false;
+
+                        _currentIndex++;
+                        currentPartStartIndex = _currentIndex;
+                        followingIndexer = true;
+                        followingDot = false;
+                        break;
+                    case ']':
+                    case ')':
+                        ended = true;
+                        break;
+                    case ' ':
+                        if (_currentIndex < _expression.Length)
+                        {
+                            ended = true;
+                        }
+                        break;
+                    case '.':
+                        if (_currentIndex > currentPartStartIndex)
+                        {
+                            string? member = _expression.Substring(currentPartStartIndex, _currentIndex - currentPartStartIndex);
+                            if (member == "*")
+                            {
+                                member = null;
+                            }
+
+                            filters.Add(CreatePathFilter(member, scan));
+                            scan = false;
+                        }
+                        if (_currentIndex + 1 < _expression.Length && _expression[_currentIndex + 1] == '.')
+                        {
+                            scan = true;
+                            _currentIndex++;
+                        }
+                        _currentIndex++;
+                        currentPartStartIndex = _currentIndex;
+                        followingIndexer = false;
+                        followingDot = true;
+                        break;
+                    default:
+                        if (query && (currentChar == '=' || currentChar == '<' || currentChar == '!' || currentChar == '>' || currentChar == '|' || currentChar == '&'))
+                        {
+                            ended = true;
+                        }
+                        else
+                        {
+                            if (followingIndexer)
+                            {
+                                throw new JsonException("Unexpected character following indexer: " + currentChar);
+                            }
+
+                            _currentIndex++;
+                        }
+                        break;
+                }
+            }
+
+            bool atPathEnd = (_currentIndex == _expression.Length);
+
+            if (_currentIndex > currentPartStartIndex)
+            {
+                string? member = _expression.Substring(currentPartStartIndex, _currentIndex - currentPartStartIndex).TrimEnd();
+                if (member == "*")
+                {
+                    member = null;
+                }
+                filters.Add(CreatePathFilter(member, scan));
+            }
+            else
+            {
+                // no field name following dot in path and at end of base path/query
+                if (followingDot && (atPathEnd || query))
+                {
+                    throw new JsonException("Unexpected end while parsing path.");
+                }
+            }
+
+            return atPathEnd;
+        }
+
+        private static PathFilter CreatePathFilter(string? member, bool scan)
+        {
+            PathFilter filter = (scan) ? (PathFilter)new ScanFilter(member) : new FieldFilter(member);
+            return filter;
+        }
+
+        private PathFilter ParseIndexer(char indexerOpenChar, bool scan)
+        {
+            _currentIndex++;
+
+            char indexerCloseChar = (indexerOpenChar == '[') ? ']' : ')';
+
+            EnsureLength("Path ended with open indexer.");
+
+            EatWhitespace();
+
+            if (_expression[_currentIndex] == '\'')
+            {
+                return ParseQuotedField(indexerCloseChar, scan);
+            }
+            else if (_expression[_currentIndex] == '?')
+            {
+                return ParseQuery(indexerCloseChar, scan);
+            }
+            else
+            {
+                return ParseArrayIndexer(indexerCloseChar);
+            }
+        }
+
+        private PathFilter ParseArrayIndexer(char indexerCloseChar)
+        {
+            int start = _currentIndex;
+            int? end = null;
+            List<int>? indexes = null;
+            int colonCount = 0;
+            int? startIndex = null;
+            int? endIndex = null;
+            int? step = null;
+
+            while (_currentIndex < _expression.Length)
+            {
+                char currentCharacter = _expression[_currentIndex];
+
+                if (currentCharacter == ' ')
+                {
+                    end = _currentIndex;
+                    EatWhitespace();
+                    continue;
+                }
+
+                if (currentCharacter == indexerCloseChar)
+                {
+                    int length = (end ?? _currentIndex) - start;
+
+                    if (indexes != null)
+                    {
+                        if (length == 0)
+                        {
+                            throw new JsonException("Array index expected.");
+                        }
+
+                        string indexer = _expression.Substring(start, length);
+                        int index = Convert.ToInt32(indexer, CultureInfo.InvariantCulture);
+
+                        indexes.Add(index);
+                        return new ArrayMultipleIndexFilter(indexes);
+                    }
+                    else if (colonCount > 0)
+                    {
+                        if (length > 0)
+                        {
+                            string indexer = _expression.Substring(start, length);
+                            int index = Convert.ToInt32(indexer, CultureInfo.InvariantCulture);
+
+                            if (colonCount == 1)
+                            {
+                                endIndex = index;
+                            }
+                            else
+                            {
+                                step = index;
+                            }
+                        }
+
+                        return new ArraySliceFilter { Start = startIndex, End = endIndex, Step = step };
+                    }
+                    else
+                    {
+                        if (length == 0)
+                        {
+                            throw new JsonException("Array index expected.");
+                        }
+
+                        string indexer = _expression.Substring(start, length);
+                        int index = Convert.ToInt32(indexer, CultureInfo.InvariantCulture);
+
+                        return new ArrayIndexFilter { Index = index };
+                    }
+                }
+                else if (currentCharacter == ',')
+                {
+                    int length = (end ?? _currentIndex) - start;
+
+                    if (length == 0)
+                    {
+                        throw new JsonException("Array index expected.");
+                    }
+
+                    if (indexes == null)
+                    {
+                        indexes = new List<int>();
+                    }
+
+                    string indexer = _expression.Substring(start, length);
+                    indexes.Add(Convert.ToInt32(indexer, CultureInfo.InvariantCulture));
+
+                    _currentIndex++;
+
+                    EatWhitespace();
+
+                    start = _currentIndex;
+                    end = null;
+                }
+                else if (currentCharacter == '*')
+                {
+                    _currentIndex++;
+                    EnsureLength("Path ended with open indexer.");
+                    EatWhitespace();
+
+                    if (_expression[_currentIndex] != indexerCloseChar)
+                    {
+                        throw new JsonException("Unexpected character while parsing path indexer: " + currentCharacter);
+                    }
+
+                    return new ArrayIndexFilter();
+                }
+                else if (currentCharacter == ':')
+                {
+                    int length = (end ?? _currentIndex) - start;
+
+                    if (length > 0)
+                    {
+                        string indexer = _expression.Substring(start, length);
+                        int index = Convert.ToInt32(indexer, CultureInfo.InvariantCulture);
+
+                        if (colonCount == 0)
+                        {
+                            startIndex = index;
+                        }
+                        else if (colonCount == 1)
+                        {
+                            endIndex = index;
+                        }
+                        else
+                        {
+                            step = index;
+                        }
+                    }
+
+                    colonCount++;
+
+                    _currentIndex++;
+
+                    EatWhitespace();
+
+                    start = _currentIndex;
+                    end = null;
+                }
+                else if (!char.IsDigit(currentCharacter) && currentCharacter != '-')
+                {
+                    throw new JsonException("Unexpected character while parsing path indexer: " + currentCharacter);
+                }
+                else
+                {
+                    if (end != null)
+                    {
+                        throw new JsonException("Unexpected character while parsing path indexer: " + currentCharacter);
+                    }
+
+                    _currentIndex++;
+                }
+            }
+
+            throw new JsonException("Path ended with open indexer.");
+        }
+
+        private void EatWhitespace()
+        {
+            while (_currentIndex < _expression.Length)
+            {
+                if (_expression[_currentIndex] != ' ')
+                {
+                    break;
+                }
+
+                _currentIndex++;
+            }
+        }
+
+        private PathFilter ParseQuery(char indexerCloseChar, bool scan)
+        {
+            _currentIndex++;
+            EnsureLength("Path ended with open indexer.");
+
+            if (_expression[_currentIndex] != '(')
+            {
+                throw new JsonException("Unexpected character while parsing path indexer: " + _expression[_currentIndex]);
+            }
+
+            _currentIndex++;
+
+            QueryExpression expression = ParseExpression();
+
+            _currentIndex++;
+            EnsureLength("Path ended with open indexer.");
+            EatWhitespace();
+
+            if (_expression[_currentIndex] != indexerCloseChar)
+            {
+                throw new JsonException("Unexpected character while parsing path indexer: " + _expression[_currentIndex]);
+            }
+
+            if (!scan)
+            {
+                return new QueryFilter(expression);
+            }
+            else
+            {
+                return new QueryScanFilter(expression);
+            }
+        }
+
+        private bool TryParseExpression(out List<PathFilter>? expressionPath)
+        {
+            if (_expression[_currentIndex] == '$')
+            {
+                expressionPath = new List<PathFilter> { RootFilter.Instance };
+            }
+            else if (_expression[_currentIndex] == '@')
+            {
+                expressionPath = new List<PathFilter>();
+            }
+            else
+            {
+                expressionPath = null;
+                return false;
+            }
+
+            _currentIndex++;
+
+            if (ParsePath(expressionPath!, _currentIndex, true))
+            {
+                throw new JsonException("Path ended with open query.");
+            }
+
+            return true;
+        }
+
+        private JsonException CreateUnexpectedCharacterException()
+        {
+            return new JsonException("Unexpected character while parsing path query: " + _expression[_currentIndex]);
+        }
+
+        private object ParseSide()
+        {
+            EatWhitespace();
+
+            if (TryParseExpression(out List<PathFilter>? expressionPath))
+            {
+                EatWhitespace();
+                EnsureLength("Path ended with open query.");
+
+                return expressionPath!;
+            }
+
+            if (TryParseValue(out var value))
+            {
+                EatWhitespace();
+                EnsureLength("Path ended with open query.");
+
+                return new JValue(value);
+            }
+
+            throw CreateUnexpectedCharacterException();
+        }
+
+        private QueryExpression ParseExpression()
+        {
+            QueryExpression? rootExpression = null;
+            CompositeExpression? parentExpression = null;
+
+            while (_currentIndex < _expression.Length)
+            {
+                object left = ParseSide();
+                object? right = null;
+
+                QueryOperator op;
+                if (_expression[_currentIndex] == ')'
+                    || _expression[_currentIndex] == '|'
+                    || _expression[_currentIndex] == '&')
+                {
+                    op = QueryOperator.Exists;
+                }
+                else
+                {
+                    op = ParseOperator();
+
+                    right = ParseSide();
+                }
+
+                BooleanQueryExpression booleanExpression = new BooleanQueryExpression(op, left, right);
+
+                if (_expression[_currentIndex] == ')')
+                {
+                    if (parentExpression != null)
+                    {
+                        parentExpression.Expressions.Add(booleanExpression);
+                        return rootExpression!;
+                    }
+
+                    return booleanExpression;
+                }
+                if (_expression[_currentIndex] == '&')
+                {
+                    if (!Match("&&"))
+                    {
+                        throw CreateUnexpectedCharacterException();
+                    }
+
+                    if (parentExpression == null || parentExpression.Operator != QueryOperator.And)
+                    {
+                        CompositeExpression andExpression = new CompositeExpression(QueryOperator.And);
+
+                        parentExpression?.Expressions.Add(andExpression);
+
+                        parentExpression = andExpression;
+
+                        if (rootExpression == null)
+                        {
+                            rootExpression = parentExpression;
+                        }
+                    }
+
+                    parentExpression.Expressions.Add(booleanExpression);
+                }
+                if (_expression[_currentIndex] == '|')
+                {
+                    if (!Match("||"))
+                    {
+                        throw CreateUnexpectedCharacterException();
+                    }
+
+                    if (parentExpression == null || parentExpression.Operator != QueryOperator.Or)
+                    {
+                        CompositeExpression orExpression = new CompositeExpression(QueryOperator.Or);
+
+                        parentExpression?.Expressions.Add(orExpression);
+
+                        parentExpression = orExpression;
+
+                        if (rootExpression == null)
+                        {
+                            rootExpression = parentExpression;
+                        }
+                    }
+
+                    parentExpression.Expressions.Add(booleanExpression);
+                }
+            }
+
+            throw new JsonException("Path ended with open query.");
+        }
+
+        private bool TryParseValue(out object? value)
+        {
+            char currentChar = _expression[_currentIndex];
+            if (currentChar == '\'')
+            {
+                value = ReadQuotedString();
+                return true;
+            }
+            else if (char.IsDigit(currentChar) || currentChar == '-')
+            {
+                StringBuilder sb = new StringBuilder();
+                sb.Append(currentChar);
+
+                _currentIndex++;
+                while (_currentIndex < _expression.Length)
+                {
+                    currentChar = _expression[_currentIndex];
+                    if (currentChar == ' ' || currentChar == ')')
+                    {
+                        string numberText = sb.ToString();
+
+                        if (numberText.IndexOfAny(FloatCharacters) != -1)
+                        {
+                            bool result = double.TryParse(numberText, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out var d);
+                            value = d;
+                            return result;
+                        }
+                        else
+                        {
+                            bool result = long.TryParse(numberText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var l);
+                            value = l;
+                            return result;
+                        }
+                    }
+                    else
+                    {
+                        sb.Append(currentChar);
+                        _currentIndex++;
+                    }
+                }
+            }
+            else if (currentChar == 't')
+            {
+                if (Match("true"))
+                {
+                    value = true;
+                    return true;
+                }
+            }
+            else if (currentChar == 'f')
+            {
+                if (Match("false"))
+                {
+                    value = false;
+                    return true;
+                }
+            }
+            else if (currentChar == 'n')
+            {
+                if (Match("null"))
+                {
+                    value = null;
+                    return true;
+                }
+            }
+            else if (currentChar == '/')
+            {
+                value = ReadRegexString();
+                return true;
+            }
+
+            value = null;
+            return false;
+        }
+
+        private string ReadQuotedString()
+        {
+            StringBuilder sb = new StringBuilder();
+
+            _currentIndex++;
+            while (_currentIndex < _expression.Length)
+            {
+                char currentChar = _expression[_currentIndex];
+                if (currentChar == '\\' && _currentIndex + 1 < _expression.Length)
+                {
+                    _currentIndex++;
+                    currentChar = _expression[_currentIndex];
+
+                    char resolvedChar;
+                    switch (currentChar)
+                    {
+                        case 'b':
+                            resolvedChar = '\b';
+                            break;
+                        case 't':
+                            resolvedChar = '\t';
+                            break;
+                        case 'n':
+                            resolvedChar = '\n';
+                            break;
+                        case 'f':
+                            resolvedChar = '\f';
+                            break;
+                        case 'r':
+                            resolvedChar = '\r';
+                            break;
+                        case '\\':
+                        case '"':
+                        case '\'':
+                        case '/':
+                            resolvedChar = currentChar;
+                            break;
+                        default:
+                            throw new JsonException(@"Unknown escape character: \" + currentChar);
+                    }
+
+                    sb.Append(resolvedChar);
+
+                    _currentIndex++;
+                }
+                else if (currentChar == '\'')
+                {
+                    _currentIndex++;
+                    return sb.ToString();
+                }
+                else
+                {
+                    _currentIndex++;
+                    sb.Append(currentChar);
+                }
+            }
+
+            throw new JsonException("Path ended with an open string.");
+        }
+
+        private string ReadRegexString()
+        {
+            int startIndex = _currentIndex;
+
+            _currentIndex++;
+            while (_currentIndex < _expression.Length)
+            {
+                char currentChar = _expression[_currentIndex];
+
+                // handle escaped / character
+                if (currentChar == '\\' && _currentIndex + 1 < _expression.Length)
+                {
+                    _currentIndex += 2;
+                }
+                else if (currentChar == '/')
+                {
+                    _currentIndex++;
+
+                    while (_currentIndex < _expression.Length)
+                    {
+                        currentChar = _expression[_currentIndex];
+
+                        if (char.IsLetter(currentChar))
+                        {
+                            _currentIndex++;
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+
+                    return _expression.Substring(startIndex, _currentIndex - startIndex);
+                }
+                else
+                {
+                    _currentIndex++;
+                }
+            }
+
+            throw new JsonException("Path ended with an open regex.");
+        }
+
+        private bool Match(string s)
+        {
+            int currentPosition = _currentIndex;
+            for (int i = 0; i < s.Length; i++)
+            {
+                if (currentPosition < _expression.Length && _expression[currentPosition] == s[i])
+                {
+                    currentPosition++;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            _currentIndex = currentPosition;
+            return true;
+        }
+
+        private QueryOperator ParseOperator()
+        {
+            if (_currentIndex + 1 >= _expression.Length)
+            {
+                throw new JsonException("Path ended with open query.");
+            }
+
+            if (Match("==="))
+            {
+                return QueryOperator.StrictEquals;
+            }
+
+            if (Match("=="))
+            {
+                return QueryOperator.Equals;
+            }
+
+            if (Match("=~"))
+            {
+                return QueryOperator.RegexEquals;
+            }
+
+            if (Match("!=="))
+            {
+                return QueryOperator.StrictNotEquals;
+            }
+
+            if (Match("!=") || Match("<>"))
+            {
+                return QueryOperator.NotEquals;
+            }
+            if (Match("<="))
+            {
+                return QueryOperator.LessThanOrEquals;
+            }
+            if (Match("<"))
+            {
+                return QueryOperator.LessThan;
+            }
+            if (Match(">="))
+            {
+                return QueryOperator.GreaterThanOrEquals;
+            }
+            if (Match(">"))
+            {
+                return QueryOperator.GreaterThan;
+            }
+
+            throw new JsonException("Could not read query operator.");
+        }
+
+        private PathFilter ParseQuotedField(char indexerCloseChar, bool scan)
+        {
+            List<string>? fields = null;
+
+            while (_currentIndex < _expression.Length)
+            {
+                string field = ReadQuotedString();
+
+                EatWhitespace();
+                EnsureLength("Path ended with open indexer.");
+
+                if (_expression[_currentIndex] == indexerCloseChar)
+                {
+                    if (fields != null)
+                    {
+                        fields.Add(field);
+                        return (scan)
+                            ? (PathFilter)new ScanMultipleFilter(fields)
+                            : (PathFilter)new FieldMultipleFilter(fields);
+                    }
+                    else
+                    {
+                        return CreatePathFilter(field, scan);
+                    }
+                }
+                else if (_expression[_currentIndex] == ',')
+                {
+                    _currentIndex++;
+                    EatWhitespace();
+
+                    if (fields == null)
+                    {
+                        fields = new List<string>();
+                    }
+
+                    fields.Add(field);
+                }
+                else
+                {
+                    throw new JsonException("Unexpected character while parsing path indexer: " + _expression[_currentIndex]);
+                }
+            }
+
+            throw new JsonException("Path ended with open indexer.");
+        }
+
+        private void EnsureLength(string message)
+        {
+            if (_currentIndex >= _expression.Length)
+            {
+                throw new JsonException(message);
+            }
+        }
+
+        internal IEnumerable<JToken> Evaluate(JToken root, JToken t, JsonSelectSettings? settings)
+        {
+            return Evaluate(Filters, root, t, settings);
+        }
+
+        internal static IEnumerable<JToken> Evaluate(List<PathFilter> filters, JToken root, JToken t, JsonSelectSettings? settings)
+        {
+            IEnumerable<JToken> current = new[] { t };
+            foreach (PathFilter filter in filters)
+            {
+                current = filter.ExecuteFilter(root, current, settings);
+            }
+
+            return current;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/PathFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/PathFilter.cs
new file mode 100644
index 0000000..d859b96
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/PathFilter.cs
@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal abstract class PathFilter
+    {
+        public abstract IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings);
+
+        protected static JToken? GetTokenIndex(JToken t, JsonSelectSettings? settings, int index)
+        {
+            if (t is JArray a)
+            {
+                if (a.Count <= index)
+                {
+                    if (settings?.ErrorWhenNoMatch ?? false)
+                    {
+                        throw new JsonException("Index {0} outside the bounds of JArray.".FormatWith(CultureInfo.InvariantCulture, index));
+                    }
+
+                    return null;
+                }
+
+                return a[index];
+            }
+            else if (t is JConstructor c)
+            {
+                if (c.Count <= index)
+                {
+                    if (settings?.ErrorWhenNoMatch ?? false)
+                    {
+                        throw new JsonException("Index {0} outside the bounds of JConstructor.".FormatWith(CultureInfo.InvariantCulture, index));
+                    }
+
+                    return null;
+                }
+
+                return c[index];
+            }
+            else
+            {
+                if (settings?.ErrorWhenNoMatch ?? false)
+                {
+                    throw new JsonException("Index {0} not valid on {1}.".FormatWith(CultureInfo.InvariantCulture, index, t.GetType().Name));
+                }
+
+                return null;
+            }
+        }
+
+        protected static JToken? GetNextScanValue(JToken originalParent, JToken? container, JToken? value)
+        {
+            // step into container's values
+            if (container != null && container.HasValues)
+            {
+                value = container.First;
+            }
+            else
+            {
+                // finished container, move to parent
+                while (value != null && value != originalParent && value == value.Parent!.Last)
+                {
+                    value = value.Parent;
+                }
+
+                // finished
+                if (value == null || value == originalParent)
+                {
+                    return null;
+                }
+
+                // move to next value in container
+                value = value.Next;
+            }
+
+            return value;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/QueryExpression.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/QueryExpression.cs
new file mode 100644
index 0000000..26756d4
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/QueryExpression.cs
@@ -0,0 +1,328 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Diagnostics;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal enum QueryOperator
+    {
+        None = 0,
+        Equals = 1,
+        NotEquals = 2,
+        Exists = 3,
+        LessThan = 4,
+        LessThanOrEquals = 5,
+        GreaterThan = 6,
+        GreaterThanOrEquals = 7,
+        And = 8,
+        Or = 9,
+        RegexEquals = 10,
+        StrictEquals = 11,
+        StrictNotEquals = 12
+    }
+
+    internal abstract class QueryExpression
+    {
+        internal QueryOperator Operator;
+
+        public QueryExpression(QueryOperator @operator)
+        {
+            Operator = @operator;
+        }
+
+        // For unit tests
+        public bool IsMatch(JToken root, JToken t)
+        {
+            return IsMatch(root, t, null);
+        }
+
+        public abstract bool IsMatch(JToken root, JToken t, JsonSelectSettings? settings);
+    }
+
+    internal class CompositeExpression : QueryExpression
+    {
+        public List<QueryExpression> Expressions { get; set; }
+
+        public CompositeExpression(QueryOperator @operator) : base(@operator)
+        {
+            Expressions = new List<QueryExpression>();
+        }
+
+        public override bool IsMatch(JToken root, JToken t, JsonSelectSettings? settings)
+        {
+            switch (Operator)
+            {
+                case QueryOperator.And:
+                    foreach (QueryExpression e in Expressions)
+                    {
+                        if (!e.IsMatch(root, t, settings))
+                        {
+                            return false;
+                        }
+                    }
+                    return true;
+                case QueryOperator.Or:
+                    foreach (QueryExpression e in Expressions)
+                    {
+                        if (e.IsMatch(root, t, settings))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+
+    internal class BooleanQueryExpression : QueryExpression
+    {
+        public readonly object Left;
+        public readonly object? Right;
+
+        public BooleanQueryExpression(QueryOperator @operator, object left, object? right) : base(@operator)
+        {
+            Left = left;
+            Right = right;
+        }
+
+        private IEnumerable<JToken> GetResult(JToken root, JToken t, object? o)
+        {
+            if (o is JToken resultToken)
+            {
+                return new[] { resultToken };
+            }
+
+            if (o is List<PathFilter> pathFilters)
+            {
+                return JPath.Evaluate(pathFilters, root, t, null);
+            }
+
+            return CollectionUtils.ArrayEmpty<JToken>();
+        }
+
+        public override bool IsMatch(JToken root, JToken t, JsonSelectSettings? settings)
+        {
+            if (Operator == QueryOperator.Exists)
+            {
+                return GetResult(root, t, Left).Any();
+            }
+
+            using (IEnumerator<JToken> leftResults = GetResult(root, t, Left).GetEnumerator())
+            {
+                if (leftResults.MoveNext())
+                {
+                    IEnumerable<JToken> rightResultsEn = GetResult(root, t, Right);
+                    ICollection<JToken> rightResults = rightResultsEn as ICollection<JToken> ?? rightResultsEn.ToList();
+
+                    do
+                    {
+                        JToken leftResult = leftResults.Current;
+                        foreach (JToken rightResult in rightResults)
+                        {
+                            if (MatchTokens(leftResult, rightResult, settings))
+                            {
+                                return true;
+                            }
+                        }
+                    } while (leftResults.MoveNext());
+                }
+            }
+
+            return false;
+        }
+
+        private bool MatchTokens(JToken leftResult, JToken rightResult, JsonSelectSettings? settings)
+        {
+            if (leftResult is JValue leftValue && rightResult is JValue rightValue)
+            {
+                switch (Operator)
+                {
+                    case QueryOperator.RegexEquals:
+                        if (RegexEquals(leftValue, rightValue, settings))
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.Equals:
+                        if (EqualsWithStringCoercion(leftValue, rightValue))
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.StrictEquals:
+                        if (EqualsWithStrictMatch(leftValue, rightValue))
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.NotEquals:
+                        if (!EqualsWithStringCoercion(leftValue, rightValue))
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.StrictNotEquals:
+                        if (!EqualsWithStrictMatch(leftValue, rightValue))
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.GreaterThan:
+                        if (leftValue.CompareTo(rightValue) > 0)
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.GreaterThanOrEquals:
+                        if (leftValue.CompareTo(rightValue) >= 0)
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.LessThan:
+                        if (leftValue.CompareTo(rightValue) < 0)
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.LessThanOrEquals:
+                        if (leftValue.CompareTo(rightValue) <= 0)
+                        {
+                            return true;
+                        }
+                        break;
+                    case QueryOperator.Exists:
+                        return true;
+                }
+            }
+            else
+            {
+                switch (Operator)
+                {
+                    case QueryOperator.Exists:
+                    // you can only specify primitive types in a comparison
+                    // notequals will always be true
+                    case QueryOperator.NotEquals:
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool RegexEquals(JValue input, JValue pattern, JsonSelectSettings? settings)
+        {
+            if (input.Type != JTokenType.String || pattern.Type != JTokenType.String)
+            {
+                return false;
+            }
+
+            string regexText = (string)pattern.Value!;
+            int patternOptionDelimiterIndex = regexText.LastIndexOf('/');
+
+            string patternText = regexText.Substring(1, patternOptionDelimiterIndex - 1);
+            string optionsText = regexText.Substring(patternOptionDelimiterIndex + 1);
+
+#if HAVE_REGEX_TIMEOUTS
+            TimeSpan timeout = settings?.RegexMatchTimeout ?? Regex.InfiniteMatchTimeout;
+            return Regex.IsMatch((string)input.Value!, patternText, MiscellaneousUtils.GetRegexOptions(optionsText), timeout);
+#else
+            return Regex.IsMatch((string)input.Value!, patternText, MiscellaneousUtils.GetRegexOptions(optionsText));
+#endif
+        }
+
+        internal static bool EqualsWithStringCoercion(JValue value, JValue queryValue)
+        {
+            if (value.Equals(queryValue))
+            {
+                return true;
+            }
+
+            // Handle comparing an integer with a float
+            // e.g. Comparing 1 and 1.0
+            if ((value.Type == JTokenType.Integer && queryValue.Type == JTokenType.Float)
+                || (value.Type == JTokenType.Float && queryValue.Type == JTokenType.Integer))
+            {
+                return JValue.Compare(value.Type, value.Value, queryValue.Value) == 0;
+            }
+
+            if (queryValue.Type != JTokenType.String)
+            {
+                return false;
+            }
+
+            string queryValueString = (string)queryValue.Value!;
+
+            string currentValueString;
+
+            // potential performance issue with converting every value to string?
+            switch (value.Type)
+            {
+                case JTokenType.Date:
+                    using (StringWriter writer = StringUtils.CreateStringWriter(64))
+                    {
+#if HAVE_DATE_TIME_OFFSET
+                        if (value.Value is DateTimeOffset offset)
+                        {
+                            DateTimeUtils.WriteDateTimeOffsetString(writer, offset, DateFormatHandling.IsoDateFormat, null, CultureInfo.InvariantCulture);
+                        }
+                        else
+#endif
+                        {
+                            DateTimeUtils.WriteDateTimeString(writer, (DateTime)value.Value!, DateFormatHandling.IsoDateFormat, null, CultureInfo.InvariantCulture);
+                        }
+
+                        currentValueString = writer.ToString();
+                    }
+                    break;
+                case JTokenType.Bytes:
+                    currentValueString = Convert.ToBase64String((byte[])value.Value!);
+                    break;
+                case JTokenType.Guid:
+                case JTokenType.TimeSpan:
+                    currentValueString = value.Value!.ToString();
+                    break;
+                case JTokenType.Uri:
+                    currentValueString = ((Uri)value.Value!).OriginalString;
+                    break;
+                default:
+                    return false;
+            }
+
+            return string.Equals(currentValueString, queryValueString, StringComparison.Ordinal);
+        }
+
+        internal static bool EqualsWithStrictMatch(JValue value, JValue queryValue)
+        {
+            MiscellaneousUtils.Assert(value != null);
+            MiscellaneousUtils.Assert(queryValue != null);
+
+            // Handle comparing an integer with a float
+            // e.g. Comparing 1 and 1.0
+            if ((value.Type == JTokenType.Integer && queryValue.Type == JTokenType.Float)
+                || (value.Type == JTokenType.Float && queryValue.Type == JTokenType.Integer))
+            {
+                return JValue.Compare(value.Type, value.Value, queryValue.Value) == 0;
+            }
+
+            // we handle floats and integers the exact same way, so they are pseudo equivalent
+            if (value.Type != queryValue.Type)
+            {
+                return false;
+            }
+
+            return value.Equals(queryValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/QueryFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/QueryFilter.cs
new file mode 100644
index 0000000..54f540f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/QueryFilter.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class QueryFilter : PathFilter
+    {
+        internal QueryExpression Expression;
+
+        public QueryFilter(QueryExpression expression)
+        {
+            Expression = expression;
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken t in current)
+            {
+                foreach (JToken v in t)
+                {
+                    if (Expression.IsMatch(root, v, settings))
+                    {
+                        yield return v;
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/QueryScanFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/QueryScanFilter.cs
new file mode 100644
index 0000000..ef71ab5
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/QueryScanFilter.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class QueryScanFilter : PathFilter
+    {
+        internal QueryExpression Expression;
+
+        public QueryScanFilter(QueryExpression expression)
+        {
+            Expression = expression;
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken t in current)
+            {
+                if (t is JContainer c)
+                {
+                    foreach (JToken d in c.DescendantsAndSelf())
+                    {
+                        if (Expression.IsMatch(root, d, settings))
+                        {
+                            yield return d;
+                        }
+                    }
+                }
+                else
+                {
+                    if (Expression.IsMatch(root, t, settings))
+                    {
+                        yield return t;
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/RootFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/RootFilter.cs
new file mode 100644
index 0000000..0c980c5
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/RootFilter.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class RootFilter : PathFilter
+    {
+        public static readonly RootFilter Instance = new RootFilter();
+
+        private RootFilter()
+        {
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            return new[] { root };
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/ScanFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/ScanFilter.cs
new file mode 100644
index 0000000..12c2306
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/ScanFilter.cs
@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ScanFilter : PathFilter
+    {
+        internal string? Name;
+
+        public ScanFilter(string? name)
+        {
+            Name = name;
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken c in current)
+            {
+                if (Name == null)
+                {
+                    yield return c;
+                }
+
+                JToken? value = c;
+
+                while (true)
+                {
+                    JContainer? container = value as JContainer;
+
+                    value = GetNextScanValue(c, container, value);
+                    if (value == null)
+                    {
+                        break;
+                    }
+
+                    if (value is JProperty property)
+                    {
+                        if (property.Name == Name)
+                        {
+                            yield return property.Value;
+                        }
+                    }
+                    else
+                    {
+                        if (Name == null)
+                        {
+                            yield return value;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonPath/ScanMultipleFilter.cs b/Libs/Newtonsoft.Json/Linq/JsonPath/ScanMultipleFilter.cs
new file mode 100644
index 0000000..c805a4b
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonPath/ScanMultipleFilter.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ScanMultipleFilter : PathFilter
+    {
+        private List<string> _names;
+
+        public ScanMultipleFilter(List<string> names)
+        {
+            _names = names;
+        }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, JsonSelectSettings? settings)
+        {
+            foreach (JToken c in current)
+            {
+                JToken? value = c;
+
+                while (true)
+                {
+                    JContainer? container = value as JContainer;
+
+                    value = GetNextScanValue(c, container, value);
+                    if (value == null)
+                    {
+                        break;
+                    }
+
+                    if (value is JProperty property)
+                    {
+                        foreach (string name in _names)
+                        {
+                            if (property.Name == name)
+                            {
+                                yield return property.Value;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/JsonSelectSettings.cs b/Libs/Newtonsoft.Json/Linq/JsonSelectSettings.cs
new file mode 100644
index 0000000..a5fa4f2
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/JsonSelectSettings.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies the settings used when selecting JSON.
+    /// </summary>
+    public class JsonSelectSettings
+    {
+#if HAVE_REGEX_TIMEOUTS
+        /// <summary>
+        /// Gets or sets a timeout that will be used when executing regular expressions.
+        /// </summary>
+        /// <value>The timeout that will be used when executing regular expressions.</value>
+        public TimeSpan? RegexMatchTimeout { get; set; }
+#endif
+
+        /// <summary>
+        /// Gets or sets a flag that indicates whether an error should be thrown if
+        /// no tokens are found when evaluating part of the expression.
+        /// </summary>
+        /// <value>
+        /// A flag that indicates whether an error should be thrown if
+        /// no tokens are found when evaluating part of the expression.
+        /// </value>
+        public bool ErrorWhenNoMatch { get; set; }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Linq/LineInfoHandling.cs b/Libs/Newtonsoft.Json/Linq/LineInfoHandling.cs
new file mode 100644
index 0000000..439f03c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/LineInfoHandling.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies how line information is handled when loading JSON.
+    /// </summary>
+    public enum LineInfoHandling
+    {
+        /// <summary>
+        /// Ignore line information.
+        /// </summary>
+        Ignore = 0,
+
+        /// <summary>
+        /// Load line information.
+        /// </summary>
+        Load = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/MergeArrayHandling.cs b/Libs/Newtonsoft.Json/Linq/MergeArrayHandling.cs
new file mode 100644
index 0000000..b113ade
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/MergeArrayHandling.cs
@@ -0,0 +1,20 @@
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies how JSON arrays are merged together.
+    /// </summary>
+    public enum MergeArrayHandling
+    {
+        /// <summary>Concatenate arrays.</summary>
+        Concat = 0,
+
+        /// <summary>Union arrays, skipping items that already exist.</summary>
+        Union = 1,
+
+        /// <summary>Replace all array items.</summary>
+        Replace = 2,
+
+        /// <summary>Merge array items together, matched by index.</summary>
+        Merge = 3
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Linq/MergeNullValueHandling.cs b/Libs/Newtonsoft.Json/Linq/MergeNullValueHandling.cs
new file mode 100644
index 0000000..b07b701
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Linq/MergeNullValueHandling.cs
@@ -0,0 +1,21 @@
+using System;
+
+namespace LC.Newtonsoft.Json.Linq
+{
+    /// <summary>
+    /// Specifies how null value properties are merged.
+    /// </summary>
+    [Flags]
+    public enum MergeNullValueHandling
+    {
+        /// <summary>
+        /// The content's null value properties will be ignored during merging.
+        /// </summary>
+        Ignore = 0,
+
+        /// <summary>
+        /// The content's null value properties will be merged.
+        /// </summary>
+        Merge = 1
+    }
+}
diff --git a/Libs/Newtonsoft.Json/MemberSerialization.cs b/Libs/Newtonsoft.Json/MemberSerialization.cs
new file mode 100644
index 0000000..f02871a
--- /dev/null
+++ b/Libs/Newtonsoft.Json/MemberSerialization.cs
@@ -0,0 +1,58 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Runtime.Serialization;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies the member serialization options for the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public enum MemberSerialization
+    {
+#pragma warning disable 1584,1711,1572,1581,1580,1574
+        /// <summary>
+        /// All public members are serialized by default. Members can be excluded using <see cref="JsonIgnoreAttribute"/> or <see cref="NonSerializedAttribute"/>.
+        /// This is the default member serialization mode.
+        /// </summary>
+        OptOut = 0,
+
+        /// <summary>
+        /// Only members marked with <see cref="JsonPropertyAttribute"/> or <see cref="DataMemberAttribute"/> are serialized.
+        /// This member serialization mode can also be set by marking the class with <see cref="DataContractAttribute"/>.
+        /// </summary>
+        OptIn = 1,
+
+        /// <summary>
+        /// All public and private fields are serialized. Members can be excluded using <see cref="JsonIgnoreAttribute"/> or <see cref="NonSerializedAttribute"/>.
+        /// This member serialization mode can also be set by marking the class with <see cref="SerializableAttribute"/>
+        /// and setting IgnoreSerializableAttribute on <see cref="DefaultContractResolver"/> to <c>false</c>.
+        /// </summary>
+        Fields = 2
+#pragma warning restore 1584,1711,1572,1581,1580,1574
+    }
+}
diff --git a/Libs/Newtonsoft.Json/MetadataPropertyHandling.cs b/Libs/Newtonsoft.Json/MetadataPropertyHandling.cs
new file mode 100644
index 0000000..6562574
--- /dev/null
+++ b/Libs/Newtonsoft.Json/MetadataPropertyHandling.cs
@@ -0,0 +1,52 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies metadata property handling options for the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public enum MetadataPropertyHandling
+    {
+        /// <summary>
+        /// Read metadata properties located at the start of a JSON object.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// Read metadata properties located anywhere in a JSON object. Note that this setting will impact performance.
+        /// </summary>
+        ReadAhead = 1,
+
+        /// <summary>
+        /// Do not try to read metadata properties.
+        /// </summary>
+        Ignore = 2
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/MissingMemberHandling.cs b/Libs/Newtonsoft.Json/MissingMemberHandling.cs
new file mode 100644
index 0000000..0c5ff66
--- /dev/null
+++ b/Libs/Newtonsoft.Json/MissingMemberHandling.cs
@@ -0,0 +1,47 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies missing member handling options for the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public enum MissingMemberHandling
+    {
+        /// <summary>
+        /// Ignore a missing member and do not attempt to deserialize it.
+        /// </summary>
+        Ignore = 0,
+
+        /// <summary>
+        /// Throw a <see cref="JsonSerializationException"/> when a missing member is encountered during deserialization.
+        /// </summary>
+        Error = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Newtonsoft.Json.ruleset b/Libs/Newtonsoft.Json/Newtonsoft.Json.ruleset
new file mode 100644
index 0000000..a49f1e2
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Newtonsoft.Json.ruleset
@@ -0,0 +1,199 @@
+<?xml version="1.0"?>
+<RuleSet Name="All Rules Disabled" Description="All Rules are disabled." ToolsVersion="15.0">
+   <Rules AnalyzerId="Microsoft.CodeAnalysis.VersionCheckAnalyzer" RuleNamespace="Microsoft.CodeAnalysis.VersionCheckAnalyzer">
+      <Rule Id="CA9999" Action="None" />             <!-- Analyzer version mismatch -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.CodeQuality.Analyzers" RuleNamespace="Microsoft.CodeQuality.Analyzers">
+      <Rule Id="CA1000" Action="None" />             <!-- Do not declare static members on generic types -->
+      <Rule Id="CA1008" Action="None" />             <!-- Enums should have zero value -->
+      <Rule Id="CA1010" Action="None" />             <!-- Collections should implement generic interface -->
+      <Rule Id="CA1012" Action="None" />             <!-- Abstract types should not have constructors -->
+      <Rule Id="CA1014" Action="None" />             <!-- Mark assemblies with CLSCompliant -->
+      <Rule Id="CA1016" Action="None" />             <!-- Mark assemblies with assembly version -->
+      <Rule Id="CA1017" Action="None" />             <!-- Mark assemblies with ComVisible -->
+      <Rule Id="CA1018" Action="None" />             <!-- Mark attributes with AttributeUsageAttribute -->
+      <Rule Id="CA1024" Action="None" />             <!-- Use properties where appropriate -->
+      <Rule Id="CA1027" Action="None" />             <!-- Mark enums with FlagsAttribute -->
+      <Rule Id="CA1028" Action="None" />             <!-- Enum Storage should be Int32 -->
+      <Rule Id="CA1030" Action="None" />             <!-- Use events where appropriate -->
+      <Rule Id="CA1031" Action="None" />             <!-- Do not catch general exception types -->
+      <Rule Id="CA1033" Action="None" />             <!-- Interface methods should be callable by child types -->
+      <Rule Id="CA1034" Action="None" />             <!-- Nested types should not be visible -->
+      <Rule Id="CA1036" Action="None" />             <!-- Override methods on comparable types -->
+      <Rule Id="CA1040" Action="None" />             <!-- Avoid empty interfaces -->
+      <Rule Id="CA1041" Action="None" />             <!-- Provide ObsoleteAttribute message -->
+      <Rule Id="CA1043" Action="None" />             <!-- Use Integral Or String Argument For Indexers -->
+      <Rule Id="CA1044" Action="None" />             <!-- Properties should not be write only -->
+      <Rule Id="CA1050" Action="None" />             <!-- Declare types in namespaces -->
+      <Rule Id="CA1051" Action="None" />             <!-- Do not declare visible instance fields -->
+      <Rule Id="CA1052" Action="None" />             <!-- Static holder types should be Static or NotInheritable -->
+      <Rule Id="CA1054" Action="None" />             <!-- Uri parameters should not be strings -->
+      <Rule Id="CA1055" Action="None" />             <!-- Uri return values should not be strings -->
+      <Rule Id="CA1056" Action="None" />             <!-- Uri properties should not be strings -->
+      <Rule Id="CA1060" Action="None" />             <!-- Move pinvokes to native methods class -->
+      <Rule Id="CA1061" Action="None" />             <!-- Do not hide base class methods -->
+      <Rule Id="CA1062" Action="None" />             <!-- Validate arguments of public methods -->
+      <Rule Id="CA1063" Action="None" />             <!-- Implement IDisposable Correctly -->
+      <Rule Id="CA1064" Action="None" />             <!-- Exceptions should be public -->
+      <Rule Id="CA1066" Action="None" />             <!-- Type {0} should implement IEquatable<T> because it overrides Equals -->
+      <Rule Id="CA1067" Action="None" />             <!-- Override Object.Equals(object) when implementing IEquatable<T> -->
+      <Rule Id="CA1068" Action="None" />             <!-- CancellationToken parameters must come last -->
+      <Rule Id="CA1501" Action="None" />             <!-- Avoid excessive inheritance -->
+      <Rule Id="CA1502" Action="None" />             <!-- Avoid excessive complexity -->
+      <Rule Id="CA1505" Action="None" />             <!-- Avoid unmaintainable code -->
+      <Rule Id="CA1506" Action="None" />             <!-- Avoid excessive class coupling -->
+      <Rule Id="CA1508" Action="None" />             <!-- Avoid dead conditional code -->
+      <Rule Id="CA1509" Action="None" />             <!-- Invalid entry in code metrics rule specification file -->
+      <Rule Id="CA1707" Action="None" />             <!-- Identifiers should not contain underscores -->
+      <Rule Id="CA1708" Action="None" />             <!-- Identifiers should differ by more than case -->
+      <Rule Id="CA1710" Action="None" />             <!-- Identifiers should have correct suffix -->
+      <Rule Id="CA1711" Action="None" />             <!-- Identifiers should not have incorrect suffix -->
+      <Rule Id="CA1712" Action="None" />             <!-- Do not prefix enum values with type name -->
+      <Rule Id="CA1714" Action="None" />             <!-- Flags enums should have plural names -->
+      <Rule Id="CA1715" Action="None" />             <!-- Identifiers should have correct prefix -->
+      <Rule Id="CA1716" Action="None" />             <!-- Identifiers should not match keywords -->
+      <Rule Id="CA1717" Action="None" />             <!-- Only FlagsAttribute enums should have plural names -->
+      <Rule Id="CA1720" Action="None" />             <!-- Identifier contains type name -->
+      <Rule Id="CA1721" Action="None" />             <!-- Property names should not match get methods -->
+      <Rule Id="CA1724" Action="None" />             <!-- Type names should not match namespaces -->
+      <Rule Id="CA1725" Action="None" />             <!-- Parameter names should match base declaration -->
+      <Rule Id="CA1801" Action="None" />             <!-- Review unused parameters -->
+      <Rule Id="CA1802" Action="None" />             <!-- Use literals where appropriate -->
+      <Rule Id="CA1806" Action="None" />             <!-- Do not ignore method results -->
+      <Rule Id="CA1812" Action="Warning" />          <!-- Avoid uninstantiated internal classes -->
+      <Rule Id="CA1814" Action="None" />             <!-- Prefer jagged arrays over multidimensional -->
+      <Rule Id="CA1815" Action="None" />             <!-- Override equals and operator equals on value types -->
+      <Rule Id="CA1819" Action="None" />             <!-- Properties should not return arrays -->
+      <Rule Id="CA1822" Action="None" />             <!-- Mark members as static -->
+      <Rule Id="CA1823" Action="Warning" />          <!-- Avoid unused private fields -->
+      <Rule Id="CA2007" Action="Error" />            <!-- Do not directly await a Task -->
+      <Rule Id="CA2119" Action="None" />             <!-- Seal methods that satisfy private interfaces -->
+      <Rule Id="CA2211" Action="None" />             <!-- Non-constant fields should not be visible -->
+      <Rule Id="CA2214" Action="None" />             <!-- Do not call overridable methods in constructors -->
+      <Rule Id="CA2217" Action="None" />             <!-- Do not mark enums with FlagsAttribute -->
+      <Rule Id="CA2219" Action="None" />             <!-- Do not raise exceptions in finally clauses -->
+      <Rule Id="CA2225" Action="None" />             <!-- Operator overloads have named alternates -->
+      <Rule Id="CA2226" Action="None" />             <!-- Operators should have symmetrical overloads -->
+      <Rule Id="CA2227" Action="None" />             <!-- Collection properties should be read only -->
+      <Rule Id="CA2231" Action="None" />             <!-- Overload operator equals on overriding value type Equals -->
+      <Rule Id="CA2244" Action="None" />             <!-- Do not duplicate indexed element initializations -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.CodeQuality.CSharp.Analyzers" RuleNamespace="Microsoft.CodeQuality.CSharp.Analyzers">
+      <Rule Id="CA1001" Action="None" />             <!-- Types that own disposable fields should be disposable -->
+      <Rule Id="CA1003" Action="None" />             <!-- Use generic event handler instances -->
+      <Rule Id="CA1019" Action="None" />             <!-- Define accessors for attribute arguments -->
+      <Rule Id="CA1032" Action="None" />             <!-- Implement standard exception constructors -->
+      <Rule Id="CA1065" Action="None" />             <!-- Do not raise exceptions in unexpected locations -->
+      <Rule Id="CA1200" Action="None" />             <!-- Avoid using cref tags with a prefix -->
+      <Rule Id="CA1507" Action="None" />             <!-- Use nameof to express symbol names -->
+      <Rule Id="CA1821" Action="None" />             <!-- Remove empty Finalizers -->
+      <Rule Id="CA2200" Action="None" />             <!-- Rethrow to preserve stack details. -->
+      <Rule Id="CA2234" Action="None" />             <!-- Pass system uri objects instead of strings -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.CodeQuality.VisualBasic.Analyzers" RuleNamespace="Microsoft.CodeQuality.VisualBasic.Analyzers">
+      <Rule Id="CA1001" Action="None" />             <!-- Types that own disposable fields should be disposable -->
+      <Rule Id="CA1003" Action="None" />             <!-- Use generic event handler instances -->
+      <Rule Id="CA1019" Action="None" />             <!-- Define accessors for attribute arguments -->
+      <Rule Id="CA1032" Action="None" />             <!-- Implement standard exception constructors -->
+      <Rule Id="CA1065" Action="None" />             <!-- Do not raise exceptions in unexpected locations -->
+      <Rule Id="CA1200" Action="None" />             <!-- Avoid using cref tags with a prefix -->
+      <Rule Id="CA1507" Action="None" />             <!-- Use nameof to express symbol names -->
+      <Rule Id="CA1821" Action="None" />             <!-- Remove empty Finalizers -->
+      <Rule Id="CA2200" Action="None" />             <!-- Rethrow to preserve stack details. -->
+      <Rule Id="CA2218" Action="None" />             <!-- Override GetHashCode on overriding Equals -->
+      <Rule Id="CA2224" Action="None" />             <!-- Override Equals on overloading operator equals -->
+      <Rule Id="CA2234" Action="None" />             <!-- Pass system uri objects instead of strings -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.NetCore.Analyzers" RuleNamespace="Microsoft.NetCore.Analyzers">
+      <Rule Id="CA1303" Action="None" />             <!-- Do not pass literals as localized parameters -->
+      <Rule Id="CA1304" Action="Error" />            <!-- Specify CultureInfo -->
+      <Rule Id="CA1305" Action="Error" />            <!-- Specify IFormatProvider -->
+      <Rule Id="CA1307" Action="Error" />            <!-- Specify StringComparison -->
+      <Rule Id="CA1308" Action="None" />             <!-- Normalize strings to uppercase -->
+      <Rule Id="CA1401" Action="None" />             <!-- P/Invokes should not be visible -->
+      <Rule Id="CA1813" Action="None" />             <!-- Avoid unsealed attributes -->
+      <Rule Id="CA1816" Action="None" />             <!-- Dispose methods should call SuppressFinalize -->
+      <Rule Id="CA1820" Action="None" />             <!-- Test for empty strings using string length -->
+      <Rule Id="CA1826" Action="None" />             <!-- Do not use Enumerable methods on indexable collections. Instead use the collection directly -->
+      <Rule Id="CA2000" Action="None" />             <!-- Dispose objects before losing scope -->
+      <Rule Id="CA2002" Action="None" />             <!-- Do not lock on objects with weak identity -->
+      <Rule Id="CA2008" Action="None" />             <!-- Do not create tasks without passing a TaskScheduler -->
+      <Rule Id="CA2009" Action="None" />             <!-- Do not call ToImmutableCollection on an ImmutableCollection value -->
+      <Rule Id="CA2100" Action="None" />             <!-- Review SQL queries for security vulnerabilities -->
+      <Rule Id="CA2101" Action="None" />             <!-- Specify marshaling for P/Invoke string arguments -->
+      <Rule Id="CA2208" Action="None" />             <!-- Instantiate argument exceptions correctly -->
+      <Rule Id="CA2213" Action="None" />             <!-- Disposable fields should be disposed -->
+      <Rule Id="CA2216" Action="None" />             <!-- Disposable types should declare finalizer -->
+      <Rule Id="CA2229" Action="None" />             <!-- Implement serialization constructors -->
+      <Rule Id="CA2235" Action="None" />             <!-- Mark all non-serializable fields -->
+      <Rule Id="CA2237" Action="None" />             <!-- Mark ISerializable types with serializable -->
+      <Rule Id="CA2241" Action="None" />             <!-- Provide correct arguments to formatting methods -->
+      <Rule Id="CA2242" Action="None" />             <!-- Test for NaN correctly -->
+      <Rule Id="CA2243" Action="None" />             <!-- Attribute string literals should parse correctly -->
+      <Rule Id="CA2300" Action="None" />             <!-- Do not use insecure deserializer BinaryFormatter -->
+      <Rule Id="CA2301" Action="None" />             <!-- Do not call BinaryFormatter.Deserialize without first setting BinaryFormatter.Binder -->
+      <Rule Id="CA2302" Action="None" />             <!-- Ensure BinaryFormatter.Binder is set before calling BinaryFormatter.Deserialize -->
+      <Rule Id="CA2305" Action="None" />             <!-- Do not use insecure deserializer LosFormatter -->
+      <Rule Id="CA2310" Action="None" />             <!-- Do not use insecure deserializer NetDataContractSerializer -->
+      <Rule Id="CA2311" Action="None" />             <!-- Do not deserialize without first setting NetDataContractSerializer.Binder -->
+      <Rule Id="CA2312" Action="None" />             <!-- Ensure NetDataContractSerializer.Binder is set before deserializing -->
+      <Rule Id="CA2315" Action="None" />             <!-- Do not use insecure deserializer ObjectStateFormatter -->
+      <Rule Id="CA3001" Action="None" />             <!-- Review code for SQL injection vulnerabilities -->
+      <Rule Id="CA3002" Action="None" />             <!-- Review code for XSS vulnerabilities -->
+      <Rule Id="CA3003" Action="None" />             <!-- Review code for file path injection vulnerabilities -->
+      <Rule Id="CA3004" Action="None" />             <!-- Review code for information disclosure vulnerabilities -->
+      <Rule Id="CA3005" Action="None" />             <!-- Review code for LDAP injection vulnerabilities -->
+      <Rule Id="CA3006" Action="None" />             <!-- Review code for process command injection vulnerabilities -->
+      <Rule Id="CA3007" Action="None" />             <!-- Review code for open redirect vulnerabilities -->
+      <Rule Id="CA3008" Action="None" />             <!-- Review code for XPath injection vulnerabilities -->
+      <Rule Id="CA3009" Action="None" />             <!-- Review code for XML injection vulnerabilities -->
+      <Rule Id="CA3010" Action="None" />             <!-- Review code for XAML injection vulnerabilities -->
+      <Rule Id="CA3011" Action="None" />             <!-- Review code for DLL injection vulnerabilities -->
+      <Rule Id="CA3012" Action="None" />             <!-- Review code for regex injection vulnerabilities -->
+      <Rule Id="CA3061" Action="None" />             <!-- Do Not Add Schema By URL -->
+      <Rule Id="CA5350" Action="None" />             <!-- Do Not Use Weak Cryptographic Algorithms -->
+      <Rule Id="CA5351" Action="None" />             <!-- Do Not Use Broken Cryptographic Algorithms -->
+      <Rule Id="CA5358" Action="None" />             <!-- Do Not Use Unsafe Cipher Modes -->
+      <Rule Id="CA5359" Action="None" />             <!-- Do Not Disable Certificate Validation -->
+      <Rule Id="CA5360" Action="None" />             <!-- Do Not Call Dangerous Methods In Deserialization -->
+      <Rule Id="CA5361" Action="None" />             <!-- Do Not Disable SChannel Use of Strong Crypto -->
+      <Rule Id="CA5362" Action="None" />             <!-- Do Not Refer Self In Serializable Class -->
+      <Rule Id="CA5363" Action="None" />             <!-- Do Not Disable Request Validation -->
+      <Rule Id="CA5364" Action="None" />             <!-- Do Not Use Deprecated Security Protocols -->
+      <Rule Id="CA5365" Action="None" />             <!-- Do Not Disable HTTP Header Checking -->
+      <Rule Id="CA5367" Action="None" />             <!-- Do Not Serialize Types With Pointer Fields -->
+      <Rule Id="CA5368" Action="None" />             <!-- Set ViewStateUserKey For Classes Derived From Page -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.NetCore.CSharp.Analyzers" RuleNamespace="Microsoft.NetCore.CSharp.Analyzers">
+      <Rule Id="CA1309" Action="Error" />            <!-- Use ordinal stringcomparison -->
+      <Rule Id="CA1810" Action="None" />             <!-- Initialize reference type static fields inline -->
+      <Rule Id="CA1824" Action="None" />             <!-- Mark assemblies with NeutralResourcesLanguageAttribute -->
+      <Rule Id="CA1825" Action="Warning" />          <!-- Avoid zero-length array allocations. -->
+      <Rule Id="CA2010" Action="None" />             <!-- Always consume the value returned by methods marked with PreserveSigAttribute -->
+      <Rule Id="CA2201" Action="None" />             <!-- Do not raise reserved exception types -->
+      <Rule Id="CA2207" Action="None" />             <!-- Initialize value type static fields inline -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.NetCore.VisualBasic.Analyzers" RuleNamespace="Microsoft.NetCore.VisualBasic.Analyzers">
+      <Rule Id="CA1309" Action="Error" />            <!-- Use ordinal stringcomparison -->
+      <Rule Id="CA1810" Action="None" />             <!-- Initialize reference type static fields inline -->
+      <Rule Id="CA1824" Action="None" />             <!-- Mark assemblies with NeutralResourcesLanguageAttribute -->
+      <Rule Id="CA1825" Action="Warning" />          <!-- Avoid zero-length array allocations. -->
+      <Rule Id="CA2010" Action="None" />             <!-- Always consume the value returned by methods marked with PreserveSigAttribute -->
+      <Rule Id="CA2201" Action="None" />             <!-- Do not raise reserved exception types -->
+      <Rule Id="CA2207" Action="None" />             <!-- Initialize value type static fields inline -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.NetFramework.Analyzers" RuleNamespace="Microsoft.NetFramework.Analyzers">
+      <Rule Id="CA1058" Action="None" />             <!-- Types should not extend certain base types -->
+      <Rule Id="CA2153" Action="None" />             <!-- Do Not Catch Corrupted State Exceptions -->
+      <Rule Id="CA3075" Action="None" />             <!-- Insecure DTD processing in XML -->
+      <Rule Id="CA3147" Action="None" />             <!-- Mark Verb Handlers With Validate Antiforgery Token -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.NetFramework.CSharp.Analyzers" RuleNamespace="Microsoft.NetFramework.CSharp.Analyzers">
+      <Rule Id="CA3076" Action="None" />             <!-- Insecure XSLT script processing. -->
+      <Rule Id="CA3077" Action="None" />             <!-- Insecure Processing in API Design, XmlDocument and XmlTextReader -->
+   </Rules>
+   <Rules AnalyzerId="Microsoft.NetFramework.VisualBasic.Analyzers" RuleNamespace="Microsoft.NetFramework.VisualBasic.Analyzers">
+      <Rule Id="CA3076" Action="None" />             <!-- Insecure XSLT script processing. -->
+      <Rule Id="CA3077" Action="None" />             <!-- Insecure Processing in API Design, XmlDocument and XmlTextReader -->
+   </Rules>
+</RuleSet>
diff --git a/Libs/Newtonsoft.Json/NullValueHandling.cs b/Libs/Newtonsoft.Json/NullValueHandling.cs
new file mode 100644
index 0000000..f342aac
--- /dev/null
+++ b/Libs/Newtonsoft.Json/NullValueHandling.cs
@@ -0,0 +1,47 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies null value handling options for the <see cref="JsonSerializer"/>.
+    /// </summary>
+    /// <example>
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="ReducingSerializedJsonSizeNullValueHandlingObject" title="NullValueHandling Class" />
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="ReducingSerializedJsonSizeNullValueHandlingExample" title="NullValueHandling Ignore Example" />
+    /// </example>
+    public enum NullValueHandling
+    {
+        /// <summary>
+        /// Include null values when serializing and deserializing objects.
+        /// </summary>
+        Include = 0,
+
+        /// <summary>
+        /// Ignore null values when serializing and deserializing objects.
+        /// </summary>
+        Ignore = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/ObjectCreationHandling.cs b/Libs/Newtonsoft.Json/ObjectCreationHandling.cs
new file mode 100644
index 0000000..9ae9543
--- /dev/null
+++ b/Libs/Newtonsoft.Json/ObjectCreationHandling.cs
@@ -0,0 +1,48 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies how object creation is handled by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public enum ObjectCreationHandling
+    {
+        /// <summary>
+        /// Reuse existing objects, create new objects when needed.
+        /// </summary>
+        Auto = 0,
+
+        /// <summary>
+        /// Only reuse existing objects.
+        /// </summary>
+        Reuse = 1,
+
+        /// <summary>
+        /// Always create new objects.
+        /// </summary>
+        Replace = 2
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/PreserveReferencesHandling.cs b/Libs/Newtonsoft.Json/PreserveReferencesHandling.cs
new file mode 100644
index 0000000..0fa4a27
--- /dev/null
+++ b/Libs/Newtonsoft.Json/PreserveReferencesHandling.cs
@@ -0,0 +1,62 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies reference handling options for the <see cref="JsonSerializer"/>.
+    /// Note that references cannot be preserved when a value is set via a non-default constructor such as types that implement <see cref="T:System.Runtime.Serialization.ISerializable"/>.
+    /// </summary>
+    /// <example>
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="PreservingObjectReferencesOn" title="Preserve Object References" />       
+    /// </example>
+    [Flags]
+    public enum PreserveReferencesHandling
+    {
+        /// <summary>
+        /// Do not preserve references when serializing types.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Preserve references when serializing into a JSON object structure.
+        /// </summary>
+        Objects = 1,
+
+        /// <summary>
+        /// Preserve references when serializing into a JSON array structure.
+        /// </summary>
+        Arrays = 2,
+
+        /// <summary>
+        /// Preserve references when serializing.
+        /// </summary>
+        All = Objects | Arrays
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Properties/AssemblyInfo.cs b/Libs/Newtonsoft.Json/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..2a67ec4
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Properties/AssemblyInfo.cs
@@ -0,0 +1,70 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+#if NET20
+[assembly: AllowPartiallyTrustedCallers]
+#elif NET35
+[assembly: AllowPartiallyTrustedCallers]
+#elif NET40
+[assembly: AllowPartiallyTrustedCallers]
+#else
+[assembly: AllowPartiallyTrustedCallers]
+#endif
+
+#if !SIGNED
+
+[assembly: InternalsVisibleTo("Newtonsoft.Json.Schema")]
+[assembly: InternalsVisibleTo("Newtonsoft.Json.Tests")]
+#else
+[assembly: InternalsVisibleTo("Newtonsoft.Json.Schema, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
+[assembly: InternalsVisibleTo("Newtonsoft.Json.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
+#endif
+
+[assembly: InternalsVisibleTo("Newtonsoft.Json.Dynamic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100cbd8d53b9d7de30f1f1278f636ec462cf9c254991291e66ebb157a885638a517887633b898ccbcf0d5c5ff7be85a6abe9e765d0ac7cd33c68dac67e7e64530e8222101109f154ab14a941c490ac155cd1d4fcba0fabb49016b4ef28593b015cab5937da31172f03f67d09edda404b88a60023f062ae71d0b2e4438b74cc11dc9")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+#if HAVE_COM_ATTRIBUTES
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly: Guid("9ca358aa-317b-4925-8ada-4a29e943a363")]
+#endif
+
+[assembly: CLSCompliant(true)]
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/ReferenceLoopHandling.cs b/Libs/Newtonsoft.Json/ReferenceLoopHandling.cs
new file mode 100644
index 0000000..c8ad993
--- /dev/null
+++ b/Libs/Newtonsoft.Json/ReferenceLoopHandling.cs
@@ -0,0 +1,52 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies reference loop handling options for the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public enum ReferenceLoopHandling
+    {
+        /// <summary>
+        /// Throw a <see cref="JsonSerializationException"/> when a loop is encountered.
+        /// </summary>
+        Error = 0,
+
+        /// <summary>
+        /// Ignore loop references and do not serialize.
+        /// </summary>
+        Ignore = 1,
+
+        /// <summary>
+        /// Serialize loop references.
+        /// </summary>
+        Serialize = 2
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Required.cs b/Libs/Newtonsoft.Json/Required.cs
new file mode 100644
index 0000000..0110e39
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Required.cs
@@ -0,0 +1,53 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Indicating whether a property is required.
+    /// </summary>
+    public enum Required
+    {
+        /// <summary>
+        /// The property is not required. The default state.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// The property must be defined in JSON but can be a null value.
+        /// </summary>
+        AllowNull = 1,
+
+        /// <summary>
+        /// The property must be defined in JSON and cannot be a null value.
+        /// </summary>
+        Always = 2,
+
+        /// <summary>
+        /// The property is not required but it cannot be a null value.
+        /// </summary>
+        DisallowNull = 3
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/Extensions.cs b/Libs/Newtonsoft.Json/Schema/Extensions.cs
new file mode 100644
index 0000000..68ac120
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/Extensions.cs
@@ -0,0 +1,139 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// Contains the JSON schema extension methods.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public static class Extensions
+    {
+        /// <summary>
+        /// <para>
+        /// Determines whether the <see cref="JToken"/> is valid.
+        /// </para>
+        /// <note type="caution">
+        /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+        /// </note>
+        /// </summary>
+        /// <param name="source">The source <see cref="JToken"/> to test.</param>
+        /// <param name="schema">The schema to test with.</param>
+        /// <returns>
+        /// 	<c>true</c> if the specified <see cref="JToken"/> is valid; otherwise, <c>false</c>.
+        /// </returns>
+        [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+        public static bool IsValid(this JToken source, JsonSchema schema)
+        {
+            bool valid = true;
+            source.Validate(schema, (sender, args) => { valid = false; });
+            return valid;
+        }
+
+        /// <summary>
+        /// <para>
+        /// Determines whether the <see cref="JToken"/> is valid.
+        /// </para>
+        /// <note type="caution">
+        /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+        /// </note>
+        /// </summary>
+        /// <param name="source">The source <see cref="JToken"/> to test.</param>
+        /// <param name="schema">The schema to test with.</param>
+        /// <param name="errorMessages">When this method returns, contains any error messages generated while validating. </param>
+        /// <returns>
+        /// 	<c>true</c> if the specified <see cref="JToken"/> is valid; otherwise, <c>false</c>.
+        /// </returns>
+        [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+        public static bool IsValid(this JToken source, JsonSchema schema, out IList<string> errorMessages)
+        {
+            IList<string> errors = new List<string>();
+
+            source.Validate(schema, (sender, args) => errors.Add(args.Message));
+
+            errorMessages = errors;
+            return (errorMessages.Count == 0);
+        }
+
+        /// <summary>
+        /// <para>
+        /// Validates the specified <see cref="JToken"/>.
+        /// </para>
+        /// <note type="caution">
+        /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+        /// </note>
+        /// </summary>
+        /// <param name="source">The source <see cref="JToken"/> to test.</param>
+        /// <param name="schema">The schema to test with.</param>
+        [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+        public static void Validate(this JToken source, JsonSchema schema)
+        {
+            source.Validate(schema, null);
+        }
+
+        /// <summary>
+        /// <para>
+        /// Validates the specified <see cref="JToken"/>.
+        /// </para>
+        /// <note type="caution">
+        /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+        /// </note>
+        /// </summary>
+        /// <param name="source">The source <see cref="JToken"/> to test.</param>
+        /// <param name="schema">The schema to test with.</param>
+        /// <param name="validationEventHandler">The validation event handler.</param>
+        [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+        public static void Validate(this JToken source, JsonSchema schema, ValidationEventHandler validationEventHandler)
+        {
+            ValidationUtils.ArgumentNotNull(source, nameof(source));
+            ValidationUtils.ArgumentNotNull(schema, nameof(schema));
+
+            using (JsonValidatingReader reader = new JsonValidatingReader(source.CreateReader()))
+            {
+                reader.Schema = schema;
+                if (validationEventHandler != null)
+                {
+                    reader.ValidationEventHandler += validationEventHandler;
+                }
+
+                while (reader.Read())
+                {
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchema.cs b/Libs/Newtonsoft.Json/Schema/JsonSchema.cs
new file mode 100644
index 0000000..56c7aca
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchema.cs
@@ -0,0 +1,357 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// An in-memory representation of a JSON Schema.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public class JsonSchema
+    {
+        /// <summary>
+        /// Gets or sets the id.
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Gets or sets the title.
+        /// </summary>
+        public string Title { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the object is required.
+        /// </summary>
+        public bool? Required { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the object is read-only.
+        /// </summary>
+        public bool? ReadOnly { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the object is visible to users.
+        /// </summary>
+        public bool? Hidden { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the object is transient.
+        /// </summary>
+        public bool? Transient { get; set; }
+
+        /// <summary>
+        /// Gets or sets the description of the object.
+        /// </summary>
+        public string Description { get; set; }
+
+        /// <summary>
+        /// Gets or sets the types of values allowed by the object.
+        /// </summary>
+        /// <value>The type.</value>
+        public JsonSchemaType? Type { get; set; }
+
+        /// <summary>
+        /// Gets or sets the pattern.
+        /// </summary>
+        /// <value>The pattern.</value>
+        public string Pattern { get; set; }
+
+        /// <summary>
+        /// Gets or sets the minimum length.
+        /// </summary>
+        /// <value>The minimum length.</value>
+        public int? MinimumLength { get; set; }
+
+        /// <summary>
+        /// Gets or sets the maximum length.
+        /// </summary>
+        /// <value>The maximum length.</value>
+        public int? MaximumLength { get; set; }
+
+        /// <summary>
+        /// Gets or sets a number that the value should be divisible by.
+        /// </summary>
+        /// <value>A number that the value should be divisible by.</value>
+        public double? DivisibleBy { get; set; }
+
+        /// <summary>
+        /// Gets or sets the minimum.
+        /// </summary>
+        /// <value>The minimum.</value>
+        public double? Minimum { get; set; }
+
+        /// <summary>
+        /// Gets or sets the maximum.
+        /// </summary>
+        /// <value>The maximum.</value>
+        public double? Maximum { get; set; }
+
+        /// <summary>
+        /// Gets or sets a flag indicating whether the value can not equal the number defined by the <c>minimum</c> attribute (<see cref="JsonSchema.Minimum"/>).
+        /// </summary>
+        /// <value>A flag indicating whether the value can not equal the number defined by the <c>minimum</c> attribute (<see cref="JsonSchema.Minimum"/>).</value>
+        public bool? ExclusiveMinimum { get; set; }
+
+        /// <summary>
+        /// Gets or sets a flag indicating whether the value can not equal the number defined by the <c>maximum</c> attribute (<see cref="JsonSchema.Maximum"/>).
+        /// </summary>
+        /// <value>A flag indicating whether the value can not equal the number defined by the <c>maximum</c> attribute (<see cref="JsonSchema.Maximum"/>).</value>
+        public bool? ExclusiveMaximum { get; set; }
+
+        /// <summary>
+        /// Gets or sets the minimum number of items.
+        /// </summary>
+        /// <value>The minimum number of items.</value>
+        public int? MinimumItems { get; set; }
+
+        /// <summary>
+        /// Gets or sets the maximum number of items.
+        /// </summary>
+        /// <value>The maximum number of items.</value>
+        public int? MaximumItems { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="JsonSchema"/> of items.
+        /// </summary>
+        /// <value>The <see cref="JsonSchema"/> of items.</value>
+        public IList<JsonSchema> Items { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether items in an array are validated using the <see cref="JsonSchema"/> instance at their array position from <see cref="JsonSchema.Items"/>.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if items are validated using their array position; otherwise, <c>false</c>.
+        /// </value>
+        public bool PositionalItemsValidation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="JsonSchema"/> of additional items.
+        /// </summary>
+        /// <value>The <see cref="JsonSchema"/> of additional items.</value>
+        public JsonSchema AdditionalItems { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether additional items are allowed.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if additional items are allowed; otherwise, <c>false</c>.
+        /// </value>
+        public bool AllowAdditionalItems { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the array items must be unique.
+        /// </summary>
+        public bool UniqueItems { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="JsonSchema"/> of properties.
+        /// </summary>
+        /// <value>The <see cref="JsonSchema"/> of properties.</value>
+        public IDictionary<string, JsonSchema> Properties { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="JsonSchema"/> of additional properties.
+        /// </summary>
+        /// <value>The <see cref="JsonSchema"/> of additional properties.</value>
+        public JsonSchema AdditionalProperties { get; set; }
+
+        /// <summary>
+        /// Gets or sets the pattern properties.
+        /// </summary>
+        /// <value>The pattern properties.</value>
+        public IDictionary<string, JsonSchema> PatternProperties { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether additional properties are allowed.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if additional properties are allowed; otherwise, <c>false</c>.
+        /// </value>
+        public bool AllowAdditionalProperties { get; set; }
+
+        /// <summary>
+        /// Gets or sets the required property if this property is present.
+        /// </summary>
+        /// <value>The required property if this property is present.</value>
+        public string Requires { get; set; }
+
+        /// <summary>
+        /// Gets or sets the a collection of valid enum values allowed.
+        /// </summary>
+        /// <value>A collection of valid enum values allowed.</value>
+        public IList<JToken> Enum { get; set; }
+
+        /// <summary>
+        /// Gets or sets disallowed types.
+        /// </summary>
+        /// <value>The disallowed types.</value>
+        public JsonSchemaType? Disallow { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default value.
+        /// </summary>
+        /// <value>The default value.</value>
+        public JToken Default { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection of <see cref="JsonSchema"/> that this schema extends.
+        /// </summary>
+        /// <value>The collection of <see cref="JsonSchema"/> that this schema extends.</value>
+        public IList<JsonSchema> Extends { get; set; }
+
+        /// <summary>
+        /// Gets or sets the format.
+        /// </summary>
+        /// <value>The format.</value>
+        public string Format { get; set; }
+
+        internal string Location { get; set; }
+
+#pragma warning disable CA1305 // Specify IFormatProvider
+        private readonly string _internalId = Guid.NewGuid().ToString("N");
+#pragma warning restore CA1305 // Specify IFormatProvider
+
+        internal string InternalId => _internalId;
+
+        // if this is set then this schema instance is just a deferred reference
+        // and will be replaced when the schema reference is resolved
+        internal string DeferredReference { get; set; }
+        internal bool ReferencesResolved { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSchema"/> class.
+        /// </summary>
+        public JsonSchema()
+        {
+            AllowAdditionalProperties = true;
+            AllowAdditionalItems = true;
+        }
+
+        /// <summary>
+        /// Reads a <see cref="JsonSchema"/> from the specified <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> containing the JSON Schema to read.</param>
+        /// <returns>The <see cref="JsonSchema"/> object representing the JSON Schema.</returns>
+        public static JsonSchema Read(JsonReader reader)
+        {
+            return Read(reader, new JsonSchemaResolver());
+        }
+
+        /// <summary>
+        /// Reads a <see cref="JsonSchema"/> from the specified <see cref="JsonReader"/>.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> containing the JSON Schema to read.</param>
+        /// <param name="resolver">The <see cref="JsonSchemaResolver"/> to use when resolving schema references.</param>
+        /// <returns>The <see cref="JsonSchema"/> object representing the JSON Schema.</returns>
+        public static JsonSchema Read(JsonReader reader, JsonSchemaResolver resolver)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+            ValidationUtils.ArgumentNotNull(resolver, nameof(resolver));
+
+            JsonSchemaBuilder builder = new JsonSchemaBuilder(resolver);
+            return builder.Read(reader);
+        }
+
+        /// <summary>
+        /// Load a <see cref="JsonSchema"/> from a string that contains JSON Schema.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON Schema.</param>
+        /// <returns>A <see cref="JsonSchema"/> populated from the string that contains JSON Schema.</returns>
+        public static JsonSchema Parse(string json)
+        {
+            return Parse(json, new JsonSchemaResolver());
+        }
+
+        /// <summary>
+        /// Load a <see cref="JsonSchema"/> from a string that contains JSON Schema using the specified <see cref="JsonSchemaResolver"/>.
+        /// </summary>
+        /// <param name="json">A <see cref="String"/> that contains JSON Schema.</param>
+        /// <param name="resolver">The resolver.</param>
+        /// <returns>A <see cref="JsonSchema"/> populated from the string that contains JSON Schema.</returns>
+        public static JsonSchema Parse(string json, JsonSchemaResolver resolver)
+        {
+            ValidationUtils.ArgumentNotNull(json, nameof(json));
+
+            using (JsonReader reader = new JsonTextReader(new StringReader(json)))
+            {
+                return Read(reader, resolver);
+            }
+        }
+
+        /// <summary>
+        /// Writes this schema to a <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        public void WriteTo(JsonWriter writer)
+        {
+            WriteTo(writer, new JsonSchemaResolver());
+        }
+
+        /// <summary>
+        /// Writes this schema to a <see cref="JsonWriter"/> using the specified <see cref="JsonSchemaResolver"/>.
+        /// </summary>
+        /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
+        /// <param name="resolver">The resolver used.</param>
+        public void WriteTo(JsonWriter writer, JsonSchemaResolver resolver)
+        {
+            ValidationUtils.ArgumentNotNull(writer, nameof(writer));
+            ValidationUtils.ArgumentNotNull(resolver, nameof(resolver));
+
+            JsonSchemaWriter schemaWriter = new JsonSchemaWriter(writer, resolver);
+            schemaWriter.WriteSchema(this);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> that represents the current <see cref="Object"/>.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="String"/> that represents the current <see cref="Object"/>.
+        /// </returns>
+        public override string ToString()
+        {
+            StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);
+            JsonTextWriter jsonWriter = new JsonTextWriter(writer);
+            jsonWriter.Formatting = Formatting.Indented;
+
+            WriteTo(jsonWriter);
+
+            return writer.ToString();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaBuilder.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaBuilder.cs
new file mode 100644
index 0000000..52ca727
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaBuilder.cs
@@ -0,0 +1,489 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Serialization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+using LC.Newtonsoft.Json.Linq;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    internal class JsonSchemaBuilder
+    {
+        private readonly IList<JsonSchema> _stack;
+        private readonly JsonSchemaResolver _resolver;
+        private readonly IDictionary<string, JsonSchema> _documentSchemas;
+        private JsonSchema _currentSchema;
+        private JObject _rootSchema;
+
+        public JsonSchemaBuilder(JsonSchemaResolver resolver)
+        {
+            _stack = new List<JsonSchema>();
+            _documentSchemas = new Dictionary<string, JsonSchema>();
+            _resolver = resolver;
+        }
+
+        private void Push(JsonSchema value)
+        {
+            _currentSchema = value;
+            _stack.Add(value);
+            _resolver.LoadedSchemas.Add(value);
+            _documentSchemas.Add(value.Location, value);
+        }
+
+        private JsonSchema Pop()
+        {
+            JsonSchema poppedSchema = _currentSchema;
+            _stack.RemoveAt(_stack.Count - 1);
+            _currentSchema = _stack.LastOrDefault();
+
+            return poppedSchema;
+        }
+
+        private JsonSchema CurrentSchema => _currentSchema;
+
+        internal JsonSchema Read(JsonReader reader)
+        {
+            JToken schemaToken = JToken.ReadFrom(reader);
+
+            _rootSchema = schemaToken as JObject;
+
+            JsonSchema schema = BuildSchema(schemaToken);
+
+            ResolveReferences(schema);
+
+            return schema;
+        }
+
+        private string UnescapeReference(string reference)
+        {
+            return Uri.UnescapeDataString(reference).Replace("~1", "/").Replace("~0", "~");
+        }
+
+        private JsonSchema ResolveReferences(JsonSchema schema)
+        {
+            if (schema.DeferredReference != null)
+            {
+                string reference = schema.DeferredReference;
+
+                bool locationReference = (reference.StartsWith("#", StringComparison.Ordinal));
+                if (locationReference)
+                {
+                    reference = UnescapeReference(reference);
+                }
+
+                JsonSchema resolvedSchema = _resolver.GetSchema(reference);
+
+                if (resolvedSchema == null)
+                {
+                    if (locationReference)
+                    {
+                        string[] escapedParts = schema.DeferredReference.TrimStart('#').Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
+                        JToken currentToken = _rootSchema;
+                        foreach (string escapedPart in escapedParts)
+                        {
+                            string part = UnescapeReference(escapedPart);
+
+                            if (currentToken.Type == JTokenType.Object)
+                            {
+                                currentToken = currentToken[part];
+                            }
+                            else if (currentToken.Type == JTokenType.Array || currentToken.Type == JTokenType.Constructor)
+                            {
+                                if (int.TryParse(part, out int index) && index >= 0 && index < currentToken.Count())
+                                {
+                                    currentToken = currentToken[index];
+                                }
+                                else
+                                {
+                                    currentToken = null;
+                                }
+                            }
+
+                            if (currentToken == null)
+                            {
+                                break;
+                            }
+                        }
+
+                        if (currentToken != null)
+                        {
+                            resolvedSchema = BuildSchema(currentToken);
+                        }
+                    }
+
+                    if (resolvedSchema == null)
+                    {
+                        throw new JsonException("Could not resolve schema reference '{0}'.".FormatWith(CultureInfo.InvariantCulture, schema.DeferredReference));
+                    }
+                }
+
+                schema = resolvedSchema;
+            }
+
+            if (schema.ReferencesResolved)
+            {
+                return schema;
+            }
+
+            schema.ReferencesResolved = true;
+
+            if (schema.Extends != null)
+            {
+                for (int i = 0; i < schema.Extends.Count; i++)
+                {
+                    schema.Extends[i] = ResolveReferences(schema.Extends[i]);
+                }
+            }
+
+            if (schema.Items != null)
+            {
+                for (int i = 0; i < schema.Items.Count; i++)
+                {
+                    schema.Items[i] = ResolveReferences(schema.Items[i]);
+                }
+            }
+
+            if (schema.AdditionalItems != null)
+            {
+                schema.AdditionalItems = ResolveReferences(schema.AdditionalItems);
+            }
+
+            if (schema.PatternProperties != null)
+            {
+                foreach (KeyValuePair<string, JsonSchema> patternProperty in schema.PatternProperties.ToList())
+                {
+                    schema.PatternProperties[patternProperty.Key] = ResolveReferences(patternProperty.Value);
+                }
+            }
+
+            if (schema.Properties != null)
+            {
+                foreach (KeyValuePair<string, JsonSchema> property in schema.Properties.ToList())
+                {
+                    schema.Properties[property.Key] = ResolveReferences(property.Value);
+                }
+            }
+
+            if (schema.AdditionalProperties != null)
+            {
+                schema.AdditionalProperties = ResolveReferences(schema.AdditionalProperties);
+            }
+
+            return schema;
+        }
+
+        private JsonSchema BuildSchema(JToken token)
+        {
+            if (!(token is JObject schemaObject))
+            {
+                throw JsonException.Create(token, token.Path, "Expected object while parsing schema object, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+            }
+
+            if (schemaObject.TryGetValue(JsonTypeReflector.RefPropertyName, out JToken referenceToken))
+            {
+                JsonSchema deferredSchema = new JsonSchema();
+                deferredSchema.DeferredReference = (string)referenceToken;
+
+                return deferredSchema;
+            }
+
+            string location = token.Path.Replace(".", "/").Replace("[", "/").Replace("]", string.Empty);
+            if (!StringUtils.IsNullOrEmpty(location))
+            {
+                location = "/" + location;
+            }
+            location = "#" + location;
+
+            if (_documentSchemas.TryGetValue(location, out JsonSchema existingSchema))
+            {
+                return existingSchema;
+            }
+
+            Push(new JsonSchema { Location = location });
+
+            ProcessSchemaProperties(schemaObject);
+
+            return Pop();
+        }
+
+        private void ProcessSchemaProperties(JObject schemaObject)
+        {
+            foreach (KeyValuePair<string, JToken> property in schemaObject)
+            {
+                switch (property.Key)
+                {
+                    case JsonSchemaConstants.TypePropertyName:
+                        CurrentSchema.Type = ProcessType(property.Value);
+                        break;
+                    case JsonSchemaConstants.IdPropertyName:
+                        CurrentSchema.Id = (string)property.Value;
+                        break;
+                    case JsonSchemaConstants.TitlePropertyName:
+                        CurrentSchema.Title = (string)property.Value;
+                        break;
+                    case JsonSchemaConstants.DescriptionPropertyName:
+                        CurrentSchema.Description = (string)property.Value;
+                        break;
+                    case JsonSchemaConstants.PropertiesPropertyName:
+                        CurrentSchema.Properties = ProcessProperties(property.Value);
+                        break;
+                    case JsonSchemaConstants.ItemsPropertyName:
+                        ProcessItems(property.Value);
+                        break;
+                    case JsonSchemaConstants.AdditionalPropertiesPropertyName:
+                        ProcessAdditionalProperties(property.Value);
+                        break;
+                    case JsonSchemaConstants.AdditionalItemsPropertyName:
+                        ProcessAdditionalItems(property.Value);
+                        break;
+                    case JsonSchemaConstants.PatternPropertiesPropertyName:
+                        CurrentSchema.PatternProperties = ProcessProperties(property.Value);
+                        break;
+                    case JsonSchemaConstants.RequiredPropertyName:
+                        CurrentSchema.Required = (bool)property.Value;
+                        break;
+                    case JsonSchemaConstants.RequiresPropertyName:
+                        CurrentSchema.Requires = (string)property.Value;
+                        break;
+                    case JsonSchemaConstants.MinimumPropertyName:
+                        CurrentSchema.Minimum = (double)property.Value;
+                        break;
+                    case JsonSchemaConstants.MaximumPropertyName:
+                        CurrentSchema.Maximum = (double)property.Value;
+                        break;
+                    case JsonSchemaConstants.ExclusiveMinimumPropertyName:
+                        CurrentSchema.ExclusiveMinimum = (bool)property.Value;
+                        break;
+                    case JsonSchemaConstants.ExclusiveMaximumPropertyName:
+                        CurrentSchema.ExclusiveMaximum = (bool)property.Value;
+                        break;
+                    case JsonSchemaConstants.MaximumLengthPropertyName:
+                        CurrentSchema.MaximumLength = (int)property.Value;
+                        break;
+                    case JsonSchemaConstants.MinimumLengthPropertyName:
+                        CurrentSchema.MinimumLength = (int)property.Value;
+                        break;
+                    case JsonSchemaConstants.MaximumItemsPropertyName:
+                        CurrentSchema.MaximumItems = (int)property.Value;
+                        break;
+                    case JsonSchemaConstants.MinimumItemsPropertyName:
+                        CurrentSchema.MinimumItems = (int)property.Value;
+                        break;
+                    case JsonSchemaConstants.DivisibleByPropertyName:
+                        CurrentSchema.DivisibleBy = (double)property.Value;
+                        break;
+                    case JsonSchemaConstants.DisallowPropertyName:
+                        CurrentSchema.Disallow = ProcessType(property.Value);
+                        break;
+                    case JsonSchemaConstants.DefaultPropertyName:
+                        CurrentSchema.Default = property.Value.DeepClone();
+                        break;
+                    case JsonSchemaConstants.HiddenPropertyName:
+                        CurrentSchema.Hidden = (bool)property.Value;
+                        break;
+                    case JsonSchemaConstants.ReadOnlyPropertyName:
+                        CurrentSchema.ReadOnly = (bool)property.Value;
+                        break;
+                    case JsonSchemaConstants.FormatPropertyName:
+                        CurrentSchema.Format = (string)property.Value;
+                        break;
+                    case JsonSchemaConstants.PatternPropertyName:
+                        CurrentSchema.Pattern = (string)property.Value;
+                        break;
+                    case JsonSchemaConstants.EnumPropertyName:
+                        ProcessEnum(property.Value);
+                        break;
+                    case JsonSchemaConstants.ExtendsPropertyName:
+                        ProcessExtends(property.Value);
+                        break;
+                    case JsonSchemaConstants.UniqueItemsPropertyName:
+                        CurrentSchema.UniqueItems = (bool)property.Value;
+                        break;
+                }
+            }
+        }
+
+        private void ProcessExtends(JToken token)
+        {
+            IList<JsonSchema> schemas = new List<JsonSchema>();
+
+            if (token.Type == JTokenType.Array)
+            {
+                foreach (JToken schemaObject in token)
+                {
+                    schemas.Add(BuildSchema(schemaObject));
+                }
+            }
+            else
+            {
+                JsonSchema schema = BuildSchema(token);
+                if (schema != null)
+                {
+                    schemas.Add(schema);
+                }
+            }
+
+            if (schemas.Count > 0)
+            {
+                CurrentSchema.Extends = schemas;
+            }
+        }
+
+        private void ProcessEnum(JToken token)
+        {
+            if (token.Type != JTokenType.Array)
+            {
+                throw JsonException.Create(token, token.Path, "Expected Array token while parsing enum values, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+            }
+
+            CurrentSchema.Enum = new List<JToken>();
+
+            foreach (JToken enumValue in token)
+            {
+                CurrentSchema.Enum.Add(enumValue.DeepClone());
+            }
+        }
+
+        private void ProcessAdditionalProperties(JToken token)
+        {
+            if (token.Type == JTokenType.Boolean)
+            {
+                CurrentSchema.AllowAdditionalProperties = (bool)token;
+            }
+            else
+            {
+                CurrentSchema.AdditionalProperties = BuildSchema(token);
+            }
+        }
+
+        private void ProcessAdditionalItems(JToken token)
+        {
+            if (token.Type == JTokenType.Boolean)
+            {
+                CurrentSchema.AllowAdditionalItems = (bool)token;
+            }
+            else
+            {
+                CurrentSchema.AdditionalItems = BuildSchema(token);
+            }
+        }
+
+        private IDictionary<string, JsonSchema> ProcessProperties(JToken token)
+        {
+            IDictionary<string, JsonSchema> properties = new Dictionary<string, JsonSchema>();
+
+            if (token.Type != JTokenType.Object)
+            {
+                throw JsonException.Create(token, token.Path, "Expected Object token while parsing schema properties, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+            }
+
+            foreach (JProperty propertyToken in token)
+            {
+                if (properties.ContainsKey(propertyToken.Name))
+                {
+                    throw new JsonException("Property {0} has already been defined in schema.".FormatWith(CultureInfo.InvariantCulture, propertyToken.Name));
+                }
+
+                properties.Add(propertyToken.Name, BuildSchema(propertyToken.Value));
+            }
+
+            return properties;
+        }
+
+        private void ProcessItems(JToken token)
+        {
+            CurrentSchema.Items = new List<JsonSchema>();
+
+            switch (token.Type)
+            {
+                case JTokenType.Object:
+                    CurrentSchema.Items.Add(BuildSchema(token));
+                    CurrentSchema.PositionalItemsValidation = false;
+                    break;
+                case JTokenType.Array:
+                    CurrentSchema.PositionalItemsValidation = true;
+                    foreach (JToken schemaToken in token)
+                    {
+                        CurrentSchema.Items.Add(BuildSchema(schemaToken));
+                    }
+                    break;
+                default:
+                    throw JsonException.Create(token, token.Path, "Expected array or JSON schema object, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+            }
+        }
+
+        private JsonSchemaType? ProcessType(JToken token)
+        {
+            switch (token.Type)
+            {
+                case JTokenType.Array:
+                    // ensure type is in blank state before ORing values
+                    JsonSchemaType? type = JsonSchemaType.None;
+
+                    foreach (JToken typeToken in token)
+                    {
+                        if (typeToken.Type != JTokenType.String)
+                        {
+                            throw JsonException.Create(typeToken, typeToken.Path, "Expected JSON schema type string token, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+                        }
+
+                        type = type | MapType((string)typeToken);
+                    }
+
+                    return type;
+                case JTokenType.String:
+                    return MapType((string)token);
+                default:
+                    throw JsonException.Create(token, token.Path, "Expected array or JSON schema type string token, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type));
+            }
+        }
+
+        internal static JsonSchemaType MapType(string type)
+        {
+            if (!JsonSchemaConstants.JsonSchemaTypeMapping.TryGetValue(type, out JsonSchemaType mappedType))
+            {
+                throw new JsonException("Invalid JSON schema type: {0}".FormatWith(CultureInfo.InvariantCulture, type));
+            }
+
+            return mappedType;
+        }
+
+        internal static string MapType(JsonSchemaType type)
+        {
+            return JsonSchemaConstants.JsonSchemaTypeMapping.Single(kv => kv.Value == type).Key;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaConstants.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaConstants.cs
new file mode 100644
index 0000000..5ac63b8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaConstants.cs
@@ -0,0 +1,82 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    internal static class JsonSchemaConstants
+    {
+        public const string TypePropertyName = "type";
+        public const string PropertiesPropertyName = "properties";
+        public const string ItemsPropertyName = "items";
+        public const string AdditionalItemsPropertyName = "additionalItems";
+        public const string RequiredPropertyName = "required";
+        public const string PatternPropertiesPropertyName = "patternProperties";
+        public const string AdditionalPropertiesPropertyName = "additionalProperties";
+        public const string RequiresPropertyName = "requires";
+        public const string MinimumPropertyName = "minimum";
+        public const string MaximumPropertyName = "maximum";
+        public const string ExclusiveMinimumPropertyName = "exclusiveMinimum";
+        public const string ExclusiveMaximumPropertyName = "exclusiveMaximum";
+        public const string MinimumItemsPropertyName = "minItems";
+        public const string MaximumItemsPropertyName = "maxItems";
+        public const string PatternPropertyName = "pattern";
+        public const string MaximumLengthPropertyName = "maxLength";
+        public const string MinimumLengthPropertyName = "minLength";
+        public const string EnumPropertyName = "enum";
+        public const string ReadOnlyPropertyName = "readonly";
+        public const string TitlePropertyName = "title";
+        public const string DescriptionPropertyName = "description";
+        public const string FormatPropertyName = "format";
+        public const string DefaultPropertyName = "default";
+        public const string TransientPropertyName = "transient";
+        public const string DivisibleByPropertyName = "divisibleBy";
+        public const string HiddenPropertyName = "hidden";
+        public const string DisallowPropertyName = "disallow";
+        public const string ExtendsPropertyName = "extends";
+        public const string IdPropertyName = "id";
+        public const string UniqueItemsPropertyName = "uniqueItems";
+
+        public const string OptionValuePropertyName = "value";
+        public const string OptionLabelPropertyName = "label";
+
+        public static readonly IDictionary<string, JsonSchemaType> JsonSchemaTypeMapping = new Dictionary<string, JsonSchemaType>
+        {
+            { "string", JsonSchemaType.String },
+            { "object", JsonSchemaType.Object },
+            { "integer", JsonSchemaType.Integer },
+            { "number", JsonSchemaType.Float },
+            { "null", JsonSchemaType.Null },
+            { "boolean", JsonSchemaType.Boolean },
+            { "array", JsonSchemaType.Array },
+            { "any", JsonSchemaType.Any }
+        };
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaException.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaException.cs
new file mode 100644
index 0000000..cf0af7e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaException.cs
@@ -0,0 +1,115 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Runtime.Serialization;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// Returns detailed information about the schema exception.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+    [Serializable]
+#endif
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public class JsonSchemaException : JsonException
+    {
+        /// <summary>
+        /// Gets the line number indicating where the error occurred.
+        /// </summary>
+        /// <value>The line number indicating where the error occurred.</value>
+        public int LineNumber { get; }
+
+        /// <summary>
+        /// Gets the line position indicating where the error occurred.
+        /// </summary>
+        /// <value>The line position indicating where the error occurred.</value>
+        public int LinePosition { get; }
+
+        /// <summary>
+        /// Gets the path to the JSON where the error occurred.
+        /// </summary>
+        /// <value>The path to the JSON where the error occurred.</value>
+        public string Path { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSchemaException"/> class.
+        /// </summary>
+        public JsonSchemaException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSchemaException"/> class
+        /// with a specified error message.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public JsonSchemaException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSchemaException"/> class
+        /// with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
+        public JsonSchemaException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+#if HAVE_BINARY_EXCEPTION_SERIALIZATION
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSchemaException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="info"/> parameter is <c>null</c>.</exception>
+        /// <exception cref="SerializationException">The class name is <c>null</c> or <see cref="Exception.HResult"/> is zero (0).</exception>
+        public JsonSchemaException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+
+        internal JsonSchemaException(string message, Exception innerException, string path, int lineNumber, int linePosition)
+            : base(message, innerException)
+        {
+            Path = path;
+            LineNumber = lineNumber;
+            LinePosition = linePosition;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaGenerator.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaGenerator.cs
new file mode 100644
index 0000000..268b5d2
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaGenerator.cs
@@ -0,0 +1,504 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.ComponentModel;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+using LC.Newtonsoft.Json.Serialization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// Generates a <see cref="JsonSchema"/> from a specified <see cref="Type"/>.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public class JsonSchemaGenerator
+    {
+        /// <summary>
+        /// Gets or sets how undefined schemas are handled by the serializer.
+        /// </summary>
+        public UndefinedSchemaIdHandling UndefinedSchemaIdHandling { get; set; }
+
+        private IContractResolver _contractResolver;
+
+        /// <summary>
+        /// Gets or sets the contract resolver.
+        /// </summary>
+        /// <value>The contract resolver.</value>
+        public IContractResolver ContractResolver
+        {
+            get
+            {
+                if (_contractResolver == null)
+                {
+                    return DefaultContractResolver.Instance;
+                }
+
+                return _contractResolver;
+            }
+            set => _contractResolver = value;
+        }
+
+        private class TypeSchema
+        {
+            public Type Type { get; }
+            public JsonSchema Schema { get; }
+
+            public TypeSchema(Type type, JsonSchema schema)
+            {
+                ValidationUtils.ArgumentNotNull(type, nameof(type));
+                ValidationUtils.ArgumentNotNull(schema, nameof(schema));
+
+                Type = type;
+                Schema = schema;
+            }
+        }
+
+        private JsonSchemaResolver _resolver;
+        private readonly IList<TypeSchema> _stack = new List<TypeSchema>();
+        private JsonSchema _currentSchema;
+
+        private JsonSchema CurrentSchema => _currentSchema;
+
+        private void Push(TypeSchema typeSchema)
+        {
+            _currentSchema = typeSchema.Schema;
+            _stack.Add(typeSchema);
+            _resolver.LoadedSchemas.Add(typeSchema.Schema);
+        }
+
+        private TypeSchema Pop()
+        {
+            TypeSchema popped = _stack[_stack.Count - 1];
+            _stack.RemoveAt(_stack.Count - 1);
+            TypeSchema newValue = _stack.LastOrDefault();
+            if (newValue != null)
+            {
+                _currentSchema = newValue.Schema;
+            }
+            else
+            {
+                _currentSchema = null;
+            }
+
+            return popped;
+        }
+
+        /// <summary>
+        /// Generate a <see cref="JsonSchema"/> from the specified type.
+        /// </summary>
+        /// <param name="type">The type to generate a <see cref="JsonSchema"/> from.</param>
+        /// <returns>A <see cref="JsonSchema"/> generated from the specified type.</returns>
+        public JsonSchema Generate(Type type)
+        {
+            return Generate(type, new JsonSchemaResolver(), false);
+        }
+
+        /// <summary>
+        /// Generate a <see cref="JsonSchema"/> from the specified type.
+        /// </summary>
+        /// <param name="type">The type to generate a <see cref="JsonSchema"/> from.</param>
+        /// <param name="resolver">The <see cref="JsonSchemaResolver"/> used to resolve schema references.</param>
+        /// <returns>A <see cref="JsonSchema"/> generated from the specified type.</returns>
+        public JsonSchema Generate(Type type, JsonSchemaResolver resolver)
+        {
+            return Generate(type, resolver, false);
+        }
+
+        /// <summary>
+        /// Generate a <see cref="JsonSchema"/> from the specified type.
+        /// </summary>
+        /// <param name="type">The type to generate a <see cref="JsonSchema"/> from.</param>
+        /// <param name="rootSchemaNullable">Specify whether the generated root <see cref="JsonSchema"/> will be nullable.</param>
+        /// <returns>A <see cref="JsonSchema"/> generated from the specified type.</returns>
+        public JsonSchema Generate(Type type, bool rootSchemaNullable)
+        {
+            return Generate(type, new JsonSchemaResolver(), rootSchemaNullable);
+        }
+
+        /// <summary>
+        /// Generate a <see cref="JsonSchema"/> from the specified type.
+        /// </summary>
+        /// <param name="type">The type to generate a <see cref="JsonSchema"/> from.</param>
+        /// <param name="resolver">The <see cref="JsonSchemaResolver"/> used to resolve schema references.</param>
+        /// <param name="rootSchemaNullable">Specify whether the generated root <see cref="JsonSchema"/> will be nullable.</param>
+        /// <returns>A <see cref="JsonSchema"/> generated from the specified type.</returns>
+        public JsonSchema Generate(Type type, JsonSchemaResolver resolver, bool rootSchemaNullable)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+            ValidationUtils.ArgumentNotNull(resolver, nameof(resolver));
+
+            _resolver = resolver;
+
+            return GenerateInternal(type, (!rootSchemaNullable) ? Required.Always : Required.Default, false);
+        }
+
+        private string GetTitle(Type type)
+        {
+            JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(type);
+
+            if (!StringUtils.IsNullOrEmpty(containerAttribute?.Title))
+            {
+                return containerAttribute.Title;
+            }
+
+            return null;
+        }
+
+        private string GetDescription(Type type)
+        {
+            JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(type);
+
+            if (!StringUtils.IsNullOrEmpty(containerAttribute?.Description))
+            {
+                return containerAttribute.Description;
+            }
+
+#if HAVE_ADO_NET
+            DescriptionAttribute descriptionAttribute = ReflectionUtils.GetAttribute<DescriptionAttribute>(type);
+            return descriptionAttribute?.Description;
+#else
+            return null;
+#endif
+        }
+
+        private string GetTypeId(Type type, bool explicitOnly)
+        {
+            JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(type);
+
+            if (!StringUtils.IsNullOrEmpty(containerAttribute?.Id))
+            {
+                return containerAttribute.Id;
+            }
+
+            if (explicitOnly)
+            {
+                return null;
+            }
+
+            switch (UndefinedSchemaIdHandling)
+            {
+                case UndefinedSchemaIdHandling.UseTypeName:
+                    return type.FullName;
+                case UndefinedSchemaIdHandling.UseAssemblyQualifiedName:
+                    return type.AssemblyQualifiedName;
+                default:
+                    return null;
+            }
+        }
+
+        private JsonSchema GenerateInternal(Type type, Required valueRequired, bool required)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+
+            string resolvedId = GetTypeId(type, false);
+            string explicitId = GetTypeId(type, true);
+
+            if (!StringUtils.IsNullOrEmpty(resolvedId))
+            {
+                JsonSchema resolvedSchema = _resolver.GetSchema(resolvedId);
+                if (resolvedSchema != null)
+                {
+                    // resolved schema is not null but referencing member allows nulls
+                    // change resolved schema to allow nulls. hacky but what are ya gonna do?
+                    if (valueRequired != Required.Always && !HasFlag(resolvedSchema.Type, JsonSchemaType.Null))
+                    {
+                        resolvedSchema.Type |= JsonSchemaType.Null;
+                    }
+                    if (required && resolvedSchema.Required != true)
+                    {
+                        resolvedSchema.Required = true;
+                    }
+
+                    return resolvedSchema;
+                }
+            }
+
+            // test for unresolved circular reference
+            if (_stack.Any(tc => tc.Type == type))
+            {
+                throw new JsonException("Unresolved circular reference for type '{0}'. Explicitly define an Id for the type using a JsonObject/JsonArray attribute or automatically generate a type Id using the UndefinedSchemaIdHandling property.".FormatWith(CultureInfo.InvariantCulture, type));
+            }
+
+            JsonContract contract = ContractResolver.ResolveContract(type);
+            JsonConverter converter = contract.Converter ?? contract.InternalConverter;
+
+            Push(new TypeSchema(type, new JsonSchema()));
+
+            if (explicitId != null)
+            {
+                CurrentSchema.Id = explicitId;
+            }
+
+            if (required)
+            {
+                CurrentSchema.Required = true;
+            }
+            CurrentSchema.Title = GetTitle(type);
+            CurrentSchema.Description = GetDescription(type);
+
+            if (converter != null)
+            {
+                // todo: Add GetSchema to JsonConverter and use here?
+                CurrentSchema.Type = JsonSchemaType.Any;
+            }
+            else
+            {
+                switch (contract.ContractType)
+                {
+                    case JsonContractType.Object:
+                        CurrentSchema.Type = AddNullType(JsonSchemaType.Object, valueRequired);
+                        CurrentSchema.Id = GetTypeId(type, false);
+                        GenerateObjectSchema(type, (JsonObjectContract)contract);
+                        break;
+                    case JsonContractType.Array:
+                        CurrentSchema.Type = AddNullType(JsonSchemaType.Array, valueRequired);
+
+                        CurrentSchema.Id = GetTypeId(type, false);
+
+                        JsonArrayAttribute arrayAttribute = JsonTypeReflector.GetCachedAttribute<JsonArrayAttribute>(type);
+                        bool allowNullItem = (arrayAttribute == null || arrayAttribute.AllowNullItems);
+
+                        Type collectionItemType = ReflectionUtils.GetCollectionItemType(type);
+                        if (collectionItemType != null)
+                        {
+                            CurrentSchema.Items = new List<JsonSchema>();
+                            CurrentSchema.Items.Add(GenerateInternal(collectionItemType, (!allowNullItem) ? Required.Always : Required.Default, false));
+                        }
+                        break;
+                    case JsonContractType.Primitive:
+                        CurrentSchema.Type = GetJsonSchemaType(type, valueRequired);
+
+                        if (CurrentSchema.Type == JsonSchemaType.Integer && type.IsEnum() && !type.IsDefined(typeof(FlagsAttribute), true))
+                        {
+                            CurrentSchema.Enum = new List<JToken>();
+
+                            EnumInfo enumValues = EnumUtils.GetEnumValuesAndNames(type);
+                            for (int i = 0; i < enumValues.Names.Length; i++)
+                            {
+                                ulong v = enumValues.Values[i];
+                                JToken value = JToken.FromObject(Enum.ToObject(type, v));
+
+                                CurrentSchema.Enum.Add(value);
+                            }
+                        }
+                        break;
+                    case JsonContractType.String:
+                        JsonSchemaType schemaType = (!ReflectionUtils.IsNullable(contract.UnderlyingType))
+                            ? JsonSchemaType.String
+                            : AddNullType(JsonSchemaType.String, valueRequired);
+
+                        CurrentSchema.Type = schemaType;
+                        break;
+                    case JsonContractType.Dictionary:
+                        CurrentSchema.Type = AddNullType(JsonSchemaType.Object, valueRequired);
+
+                        Type keyType;
+                        Type valueType;
+                        ReflectionUtils.GetDictionaryKeyValueTypes(type, out keyType, out valueType);
+
+                        if (keyType != null)
+                        {
+                            JsonContract keyContract = ContractResolver.ResolveContract(keyType);
+
+                            // can be converted to a string
+                            if (keyContract.ContractType == JsonContractType.Primitive)
+                            {
+                                CurrentSchema.AdditionalProperties = GenerateInternal(valueType, Required.Default, false);
+                            }
+                        }
+                        break;
+#if HAVE_BINARY_SERIALIZATION
+                    case JsonContractType.Serializable:
+                        CurrentSchema.Type = AddNullType(JsonSchemaType.Object, valueRequired);
+                        CurrentSchema.Id = GetTypeId(type, false);
+                        GenerateISerializableContract(type, (JsonISerializableContract)contract);
+                        break;
+#endif
+#if HAVE_DYNAMIC
+                    case JsonContractType.Dynamic:
+#endif
+                    case JsonContractType.Linq:
+                        CurrentSchema.Type = JsonSchemaType.Any;
+                        break;
+                    default:
+                        throw new JsonException("Unexpected contract type: {0}".FormatWith(CultureInfo.InvariantCulture, contract));
+                }
+            }
+
+            return Pop().Schema;
+        }
+
+        private JsonSchemaType AddNullType(JsonSchemaType type, Required valueRequired)
+        {
+            if (valueRequired != Required.Always)
+            {
+                return type | JsonSchemaType.Null;
+            }
+
+            return type;
+        }
+
+        private bool HasFlag(DefaultValueHandling value, DefaultValueHandling flag)
+        {
+            return ((value & flag) == flag);
+        }
+
+        private void GenerateObjectSchema(Type type, JsonObjectContract contract)
+        {
+            CurrentSchema.Properties = new Dictionary<string, JsonSchema>();
+            foreach (JsonProperty property in contract.Properties)
+            {
+                if (!property.Ignored)
+                {
+                    bool optional = property.NullValueHandling == NullValueHandling.Ignore ||
+                                    HasFlag(property.DefaultValueHandling.GetValueOrDefault(), DefaultValueHandling.Ignore) ||
+                                    property.ShouldSerialize != null ||
+                                    property.GetIsSpecified != null;
+
+                    JsonSchema propertySchema = GenerateInternal(property.PropertyType, property.Required, !optional);
+
+                    if (property.DefaultValue != null)
+                    {
+                        propertySchema.Default = JToken.FromObject(property.DefaultValue);
+                    }
+
+                    CurrentSchema.Properties.Add(property.PropertyName, propertySchema);
+                }
+            }
+
+            if (type.IsSealed())
+            {
+                CurrentSchema.AllowAdditionalProperties = false;
+            }
+        }
+
+#if HAVE_BINARY_SERIALIZATION
+        private void GenerateISerializableContract(Type type, JsonISerializableContract contract)
+        {
+            CurrentSchema.AllowAdditionalProperties = true;
+        }
+#endif
+
+        internal static bool HasFlag(JsonSchemaType? value, JsonSchemaType flag)
+        {
+            // default value is Any
+            if (value == null)
+            {
+                return true;
+            }
+
+            bool match = ((value & flag) == flag);
+            if (match)
+            {
+                return true;
+            }
+
+            // integer is a subset of float
+            if (flag == JsonSchemaType.Integer && (value & JsonSchemaType.Float) == JsonSchemaType.Float)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private JsonSchemaType GetJsonSchemaType(Type type, Required valueRequired)
+        {
+            JsonSchemaType schemaType = JsonSchemaType.None;
+            if (valueRequired != Required.Always && ReflectionUtils.IsNullable(type))
+            {
+                schemaType = JsonSchemaType.Null;
+                if (ReflectionUtils.IsNullableType(type))
+                {
+                    type = Nullable.GetUnderlyingType(type);
+                }
+            }
+
+            PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(type);
+
+            switch (typeCode)
+            {
+                case PrimitiveTypeCode.Empty:
+                case PrimitiveTypeCode.Object:
+                    return schemaType | JsonSchemaType.String;
+#if HAVE_DB_NULL_TYPE_CODE
+                case PrimitiveTypeCode.DBNull:
+                    return schemaType | JsonSchemaType.Null;
+#endif
+                case PrimitiveTypeCode.Boolean:
+                    return schemaType | JsonSchemaType.Boolean;
+                case PrimitiveTypeCode.Char:
+                    return schemaType | JsonSchemaType.String;
+                case PrimitiveTypeCode.SByte:
+                case PrimitiveTypeCode.Byte:
+                case PrimitiveTypeCode.Int16:
+                case PrimitiveTypeCode.UInt16:
+                case PrimitiveTypeCode.Int32:
+                case PrimitiveTypeCode.UInt32:
+                case PrimitiveTypeCode.Int64:
+                case PrimitiveTypeCode.UInt64:
+#if HAVE_BIG_INTEGER
+                case PrimitiveTypeCode.BigInteger:
+#endif
+                    return schemaType | JsonSchemaType.Integer;
+                case PrimitiveTypeCode.Single:
+                case PrimitiveTypeCode.Double:
+                case PrimitiveTypeCode.Decimal:
+                    return schemaType | JsonSchemaType.Float;
+                // convert to string?
+                case PrimitiveTypeCode.DateTime:
+#if HAVE_DATE_TIME_OFFSET
+                case PrimitiveTypeCode.DateTimeOffset:
+#endif
+                    return schemaType | JsonSchemaType.String;
+                case PrimitiveTypeCode.String:
+                case PrimitiveTypeCode.Uri:
+                case PrimitiveTypeCode.Guid:
+                case PrimitiveTypeCode.TimeSpan:
+                case PrimitiveTypeCode.Bytes:
+                    return schemaType | JsonSchemaType.String;
+                default:
+                    throw new JsonException("Unexpected type code '{0}' for type '{1}'.".FormatWith(CultureInfo.InvariantCulture, typeCode, type));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaModel.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaModel.cs
new file mode 100644
index 0000000..bc38ecb
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaModel.cs
@@ -0,0 +1,127 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    internal class JsonSchemaModel
+    {
+        public bool Required { get; set; }
+        public JsonSchemaType Type { get; set; }
+        public int? MinimumLength { get; set; }
+        public int? MaximumLength { get; set; }
+        public double? DivisibleBy { get; set; }
+        public double? Minimum { get; set; }
+        public double? Maximum { get; set; }
+        public bool ExclusiveMinimum { get; set; }
+        public bool ExclusiveMaximum { get; set; }
+        public int? MinimumItems { get; set; }
+        public int? MaximumItems { get; set; }
+        public IList<string> Patterns { get; set; }
+        public IList<JsonSchemaModel> Items { get; set; }
+        public IDictionary<string, JsonSchemaModel> Properties { get; set; }
+        public IDictionary<string, JsonSchemaModel> PatternProperties { get; set; }
+        public JsonSchemaModel AdditionalProperties { get; set; }
+        public JsonSchemaModel AdditionalItems { get; set; }
+        public bool PositionalItemsValidation { get; set; }
+        public bool AllowAdditionalProperties { get; set; }
+        public bool AllowAdditionalItems { get; set; }
+        public bool UniqueItems { get; set; }
+        public IList<JToken> Enum { get; set; }
+        public JsonSchemaType Disallow { get; set; }
+
+        public JsonSchemaModel()
+        {
+            Type = JsonSchemaType.Any;
+            AllowAdditionalProperties = true;
+            AllowAdditionalItems = true;
+            Required = false;
+        }
+
+        public static JsonSchemaModel Create(IList<JsonSchema> schemata)
+        {
+            JsonSchemaModel model = new JsonSchemaModel();
+
+            foreach (JsonSchema schema in schemata)
+            {
+                Combine(model, schema);
+            }
+
+            return model;
+        }
+
+        private static void Combine(JsonSchemaModel model, JsonSchema schema)
+        {
+            // Version 3 of the Draft JSON Schema has the default value of Not Required
+            model.Required = model.Required || (schema.Required ?? false);
+            model.Type = model.Type & (schema.Type ?? JsonSchemaType.Any);
+
+            model.MinimumLength = MathUtils.Max(model.MinimumLength, schema.MinimumLength);
+            model.MaximumLength = MathUtils.Min(model.MaximumLength, schema.MaximumLength);
+
+            // not sure what is the best way to combine divisibleBy
+            model.DivisibleBy = MathUtils.Max(model.DivisibleBy, schema.DivisibleBy);
+
+            model.Minimum = MathUtils.Max(model.Minimum, schema.Minimum);
+            model.Maximum = MathUtils.Max(model.Maximum, schema.Maximum);
+            model.ExclusiveMinimum = model.ExclusiveMinimum || (schema.ExclusiveMinimum ?? false);
+            model.ExclusiveMaximum = model.ExclusiveMaximum || (schema.ExclusiveMaximum ?? false);
+
+            model.MinimumItems = MathUtils.Max(model.MinimumItems, schema.MinimumItems);
+            model.MaximumItems = MathUtils.Min(model.MaximumItems, schema.MaximumItems);
+            model.PositionalItemsValidation = model.PositionalItemsValidation || schema.PositionalItemsValidation;
+            model.AllowAdditionalProperties = model.AllowAdditionalProperties && schema.AllowAdditionalProperties;
+            model.AllowAdditionalItems = model.AllowAdditionalItems && schema.AllowAdditionalItems;
+            model.UniqueItems = model.UniqueItems || schema.UniqueItems;
+            if (schema.Enum != null)
+            {
+                if (model.Enum == null)
+                {
+                    model.Enum = new List<JToken>();
+                }
+
+                model.Enum.AddRangeDistinct(schema.Enum, JToken.EqualityComparer);
+            }
+            model.Disallow = model.Disallow | (schema.Disallow ?? JsonSchemaType.None);
+
+            if (schema.Pattern != null)
+            {
+                if (model.Patterns == null)
+                {
+                    model.Patterns = new List<string>();
+                }
+
+                model.Patterns.AddDistinct(schema.Pattern);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaModelBuilder.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaModelBuilder.cs
new file mode 100644
index 0000000..39a19e7
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaModelBuilder.cs
@@ -0,0 +1,213 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    internal class JsonSchemaModelBuilder
+    {
+        private JsonSchemaNodeCollection _nodes = new JsonSchemaNodeCollection();
+        private Dictionary<JsonSchemaNode, JsonSchemaModel> _nodeModels = new Dictionary<JsonSchemaNode, JsonSchemaModel>();
+        private JsonSchemaNode _node;
+
+        public JsonSchemaModel Build(JsonSchema schema)
+        {
+            _nodes = new JsonSchemaNodeCollection();
+            _node = AddSchema(null, schema);
+
+            _nodeModels = new Dictionary<JsonSchemaNode, JsonSchemaModel>();
+            JsonSchemaModel model = BuildNodeModel(_node);
+
+            return model;
+        }
+
+        public JsonSchemaNode AddSchema(JsonSchemaNode existingNode, JsonSchema schema)
+        {
+            string newId;
+            if (existingNode != null)
+            {
+                if (existingNode.Schemas.Contains(schema))
+                {
+                    return existingNode;
+                }
+
+                newId = JsonSchemaNode.GetId(existingNode.Schemas.Union(new[] { schema }));
+            }
+            else
+            {
+                newId = JsonSchemaNode.GetId(new[] { schema });
+            }
+
+            if (_nodes.Contains(newId))
+            {
+                return _nodes[newId];
+            }
+
+            JsonSchemaNode currentNode = (existingNode != null)
+                ? existingNode.Combine(schema)
+                : new JsonSchemaNode(schema);
+
+            _nodes.Add(currentNode);
+
+            AddProperties(schema.Properties, currentNode.Properties);
+
+            AddProperties(schema.PatternProperties, currentNode.PatternProperties);
+
+            if (schema.Items != null)
+            {
+                for (int i = 0; i < schema.Items.Count; i++)
+                {
+                    AddItem(currentNode, i, schema.Items[i]);
+                }
+            }
+
+            if (schema.AdditionalItems != null)
+            {
+                AddAdditionalItems(currentNode, schema.AdditionalItems);
+            }
+
+            if (schema.AdditionalProperties != null)
+            {
+                AddAdditionalProperties(currentNode, schema.AdditionalProperties);
+            }
+
+            if (schema.Extends != null)
+            {
+                foreach (JsonSchema jsonSchema in schema.Extends)
+                {
+                    currentNode = AddSchema(currentNode, jsonSchema);
+                }
+            }
+
+            return currentNode;
+        }
+
+        public void AddProperties(IDictionary<string, JsonSchema> source, IDictionary<string, JsonSchemaNode> target)
+        {
+            if (source != null)
+            {
+                foreach (KeyValuePair<string, JsonSchema> property in source)
+                {
+                    AddProperty(target, property.Key, property.Value);
+                }
+            }
+        }
+
+        public void AddProperty(IDictionary<string, JsonSchemaNode> target, string propertyName, JsonSchema schema)
+        {
+            target.TryGetValue(propertyName, out JsonSchemaNode propertyNode);
+
+            target[propertyName] = AddSchema(propertyNode, schema);
+        }
+
+        public void AddItem(JsonSchemaNode parentNode, int index, JsonSchema schema)
+        {
+            JsonSchemaNode existingItemNode = (parentNode.Items.Count > index)
+                ? parentNode.Items[index]
+                : null;
+
+            JsonSchemaNode newItemNode = AddSchema(existingItemNode, schema);
+
+            if (!(parentNode.Items.Count > index))
+            {
+                parentNode.Items.Add(newItemNode);
+            }
+            else
+            {
+                parentNode.Items[index] = newItemNode;
+            }
+        }
+
+        public void AddAdditionalProperties(JsonSchemaNode parentNode, JsonSchema schema)
+        {
+            parentNode.AdditionalProperties = AddSchema(parentNode.AdditionalProperties, schema);
+        }
+
+        public void AddAdditionalItems(JsonSchemaNode parentNode, JsonSchema schema)
+        {
+            parentNode.AdditionalItems = AddSchema(parentNode.AdditionalItems, schema);
+        }
+
+        private JsonSchemaModel BuildNodeModel(JsonSchemaNode node)
+        {
+            if (_nodeModels.TryGetValue(node, out JsonSchemaModel model))
+            {
+                return model;
+            }
+
+            model = JsonSchemaModel.Create(node.Schemas);
+            _nodeModels[node] = model;
+
+            foreach (KeyValuePair<string, JsonSchemaNode> property in node.Properties)
+            {
+                if (model.Properties == null)
+                {
+                    model.Properties = new Dictionary<string, JsonSchemaModel>();
+                }
+
+                model.Properties[property.Key] = BuildNodeModel(property.Value);
+            }
+            foreach (KeyValuePair<string, JsonSchemaNode> property in node.PatternProperties)
+            {
+                if (model.PatternProperties == null)
+                {
+                    model.PatternProperties = new Dictionary<string, JsonSchemaModel>();
+                }
+
+                model.PatternProperties[property.Key] = BuildNodeModel(property.Value);
+            }
+            foreach (JsonSchemaNode t in node.Items)
+            {
+                if (model.Items == null)
+                {
+                    model.Items = new List<JsonSchemaModel>();
+                }
+
+                model.Items.Add(BuildNodeModel(t));
+            }
+            if (node.AdditionalProperties != null)
+            {
+                model.AdditionalProperties = BuildNodeModel(node.AdditionalProperties);
+            }
+            if (node.AdditionalItems != null)
+            {
+                model.AdditionalItems = BuildNodeModel(node.AdditionalItems);
+            }
+
+            return model;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaNode.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaNode.cs
new file mode 100644
index 0000000..8088ca8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaNode.cs
@@ -0,0 +1,87 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    internal class JsonSchemaNode
+    {
+        public string Id { get; }
+        public ReadOnlyCollection<JsonSchema> Schemas { get; }
+        public Dictionary<string, JsonSchemaNode> Properties { get; }
+        public Dictionary<string, JsonSchemaNode> PatternProperties { get; }
+        public List<JsonSchemaNode> Items { get; }
+        public JsonSchemaNode AdditionalProperties { get; set; }
+        public JsonSchemaNode AdditionalItems { get; set; }
+
+        public JsonSchemaNode(JsonSchema schema)
+        {
+            Schemas = new ReadOnlyCollection<JsonSchema>(new[] { schema });
+            Properties = new Dictionary<string, JsonSchemaNode>();
+            PatternProperties = new Dictionary<string, JsonSchemaNode>();
+            Items = new List<JsonSchemaNode>();
+
+            Id = GetId(Schemas);
+        }
+
+        private JsonSchemaNode(JsonSchemaNode source, JsonSchema schema)
+        {
+            Schemas = new ReadOnlyCollection<JsonSchema>(source.Schemas.Union(new[] { schema }).ToList());
+            Properties = new Dictionary<string, JsonSchemaNode>(source.Properties);
+            PatternProperties = new Dictionary<string, JsonSchemaNode>(source.PatternProperties);
+            Items = new List<JsonSchemaNode>(source.Items);
+            AdditionalProperties = source.AdditionalProperties;
+            AdditionalItems = source.AdditionalItems;
+
+            Id = GetId(Schemas);
+        }
+
+        public JsonSchemaNode Combine(JsonSchema schema)
+        {
+            return new JsonSchemaNode(this, schema);
+        }
+
+        public static string GetId(IEnumerable<JsonSchema> schemata)
+        {
+            return string.Join("-", schemata.Select(s => s.InternalId).OrderBy(id => id, StringComparer.Ordinal)
+#if !HAVE_STRING_JOIN_WITH_ENUMERABLE
+                    .ToArray()
+#endif
+                );
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaNodeCollection.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaNodeCollection.cs
new file mode 100644
index 0000000..b5e49bb
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaNodeCollection.cs
@@ -0,0 +1,41 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.ObjectModel;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    internal class JsonSchemaNodeCollection : KeyedCollection<string, JsonSchemaNode>
+    {
+        protected override string GetKeyForItem(JsonSchemaNode item)
+        {
+            return item.Id;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaResolver.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaResolver.cs
new file mode 100644
index 0000000..9737875
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaResolver.cs
@@ -0,0 +1,81 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// Resolves <see cref="JsonSchema"/> from an id.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public class JsonSchemaResolver
+    {
+        /// <summary>
+        /// Gets or sets the loaded schemas.
+        /// </summary>
+        /// <value>The loaded schemas.</value>
+        public IList<JsonSchema> LoadedSchemas { get; protected set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonSchemaResolver"/> class.
+        /// </summary>
+        public JsonSchemaResolver()
+        {
+            LoadedSchemas = new List<JsonSchema>();
+        }
+
+        /// <summary>
+        /// Gets a <see cref="JsonSchema"/> for the specified reference.
+        /// </summary>
+        /// <param name="reference">The id.</param>
+        /// <returns>A <see cref="JsonSchema"/> for the specified reference.</returns>
+        public virtual JsonSchema GetSchema(string reference)
+        {
+            JsonSchema schema = LoadedSchemas.SingleOrDefault(s => string.Equals(s.Id, reference, StringComparison.Ordinal));
+
+            if (schema == null)
+            {
+                schema = LoadedSchemas.SingleOrDefault(s => string.Equals(s.Location, reference, StringComparison.Ordinal));
+            }
+
+            return schema;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaType.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaType.cs
new file mode 100644
index 0000000..5a8c2d3
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaType.cs
@@ -0,0 +1,89 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// The value types allowed by the <see cref="JsonSchema"/>.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Flags]
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public enum JsonSchemaType
+    {
+        /// <summary>
+        /// No type specified.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// String type.
+        /// </summary>
+        String = 1,
+
+        /// <summary>
+        /// Float type.
+        /// </summary>
+        Float = 2,
+
+        /// <summary>
+        /// Integer type.
+        /// </summary>
+        Integer = 4,
+
+        /// <summary>
+        /// Boolean type.
+        /// </summary>
+        Boolean = 8,
+
+        /// <summary>
+        /// Object type.
+        /// </summary>
+        Object = 16,
+
+        /// <summary>
+        /// Array type.
+        /// </summary>
+        Array = 32,
+
+        /// <summary>
+        /// Null type.
+        /// </summary>
+        Null = 64,
+
+        /// <summary>
+        /// Any type.
+        /// </summary>
+        Any = String | Float | Integer | Boolean | Object | Array | Null
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/JsonSchemaWriter.cs b/Libs/Newtonsoft.Json/Schema/JsonSchemaWriter.cs
new file mode 100644
index 0000000..5665c27
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/JsonSchemaWriter.cs
@@ -0,0 +1,260 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    internal class JsonSchemaWriter
+    {
+        private readonly JsonWriter _writer;
+        private readonly JsonSchemaResolver _resolver;
+
+        public JsonSchemaWriter(JsonWriter writer, JsonSchemaResolver resolver)
+        {
+            ValidationUtils.ArgumentNotNull(writer, nameof(writer));
+            _writer = writer;
+            _resolver = resolver;
+        }
+
+        private void ReferenceOrWriteSchema(JsonSchema schema)
+        {
+            if (schema.Id != null && _resolver.GetSchema(schema.Id) != null)
+            {
+                _writer.WriteStartObject();
+                _writer.WritePropertyName(JsonTypeReflector.RefPropertyName);
+                _writer.WriteValue(schema.Id);
+                _writer.WriteEndObject();
+            }
+            else
+            {
+                WriteSchema(schema);
+            }
+        }
+
+        public void WriteSchema(JsonSchema schema)
+        {
+            ValidationUtils.ArgumentNotNull(schema, nameof(schema));
+
+            if (!_resolver.LoadedSchemas.Contains(schema))
+            {
+                _resolver.LoadedSchemas.Add(schema);
+            }
+
+            _writer.WriteStartObject();
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.IdPropertyName, schema.Id);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.TitlePropertyName, schema.Title);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.DescriptionPropertyName, schema.Description);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.RequiredPropertyName, schema.Required);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.ReadOnlyPropertyName, schema.ReadOnly);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.HiddenPropertyName, schema.Hidden);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.TransientPropertyName, schema.Transient);
+            if (schema.Type != null)
+            {
+                WriteType(JsonSchemaConstants.TypePropertyName, _writer, schema.Type.GetValueOrDefault());
+            }
+            if (!schema.AllowAdditionalProperties)
+            {
+                _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
+                _writer.WriteValue(schema.AllowAdditionalProperties);
+            }
+            else
+            {
+                if (schema.AdditionalProperties != null)
+                {
+                    _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName);
+                    ReferenceOrWriteSchema(schema.AdditionalProperties);
+                }
+            }
+            if (!schema.AllowAdditionalItems)
+            {
+                _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName);
+                _writer.WriteValue(schema.AllowAdditionalItems);
+            }
+            else
+            {
+                if (schema.AdditionalItems != null)
+                {
+                    _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName);
+                    ReferenceOrWriteSchema(schema.AdditionalItems);
+                }
+            }
+            WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PropertiesPropertyName, schema.Properties);
+            WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PatternPropertiesPropertyName, schema.PatternProperties);
+            WriteItems(schema);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumPropertyName, schema.Minimum);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumPropertyName, schema.Maximum);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMinimumPropertyName, schema.ExclusiveMinimum);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMaximumPropertyName, schema.ExclusiveMaximum);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumLengthPropertyName, schema.MinimumLength);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumLengthPropertyName, schema.MaximumLength);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumItemsPropertyName, schema.MinimumItems);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumItemsPropertyName, schema.MaximumItems);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.DivisibleByPropertyName, schema.DivisibleBy);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.FormatPropertyName, schema.Format);
+            WritePropertyIfNotNull(_writer, JsonSchemaConstants.PatternPropertyName, schema.Pattern);
+            if (schema.Enum != null)
+            {
+                _writer.WritePropertyName(JsonSchemaConstants.EnumPropertyName);
+                _writer.WriteStartArray();
+                foreach (JToken token in schema.Enum)
+                {
+                    token.WriteTo(_writer);
+                }
+                _writer.WriteEndArray();
+            }
+            if (schema.Default != null)
+            {
+                _writer.WritePropertyName(JsonSchemaConstants.DefaultPropertyName);
+                schema.Default.WriteTo(_writer);
+            }
+            if (schema.Disallow != null)
+            {
+                WriteType(JsonSchemaConstants.DisallowPropertyName, _writer, schema.Disallow.GetValueOrDefault());
+            }
+            if (schema.Extends != null && schema.Extends.Count > 0)
+            {
+                _writer.WritePropertyName(JsonSchemaConstants.ExtendsPropertyName);
+                if (schema.Extends.Count == 1)
+                {
+                    ReferenceOrWriteSchema(schema.Extends[0]);
+                }
+                else
+                {
+                    _writer.WriteStartArray();
+                    foreach (JsonSchema jsonSchema in schema.Extends)
+                    {
+                        ReferenceOrWriteSchema(jsonSchema);
+                    }
+                    _writer.WriteEndArray();
+                }
+            }
+            _writer.WriteEndObject();
+        }
+
+        private void WriteSchemaDictionaryIfNotNull(JsonWriter writer, string propertyName, IDictionary<string, JsonSchema> properties)
+        {
+            if (properties != null)
+            {
+                writer.WritePropertyName(propertyName);
+                writer.WriteStartObject();
+                foreach (KeyValuePair<string, JsonSchema> property in properties)
+                {
+                    writer.WritePropertyName(property.Key);
+                    ReferenceOrWriteSchema(property.Value);
+                }
+                writer.WriteEndObject();
+            }
+        }
+
+        private void WriteItems(JsonSchema schema)
+        {
+            if (schema.Items == null && !schema.PositionalItemsValidation)
+            {
+                return;
+            }
+
+            _writer.WritePropertyName(JsonSchemaConstants.ItemsPropertyName);
+
+            if (!schema.PositionalItemsValidation)
+            {
+                if (schema.Items != null && schema.Items.Count > 0)
+                {
+                    ReferenceOrWriteSchema(schema.Items[0]);
+                }
+                else
+                {
+                    _writer.WriteStartObject();
+                    _writer.WriteEndObject();
+                }
+                return;
+            }
+
+            _writer.WriteStartArray();
+            if (schema.Items != null)
+            {
+                foreach (JsonSchema itemSchema in schema.Items)
+                {
+                    ReferenceOrWriteSchema(itemSchema);
+                }
+            }
+            _writer.WriteEndArray();
+        }
+
+        private void WriteType(string propertyName, JsonWriter writer, JsonSchemaType type)
+        {
+            if (Enum.IsDefined(typeof(JsonSchemaType), type))
+            {
+                writer.WritePropertyName(propertyName);
+                writer.WriteValue(JsonSchemaBuilder.MapType(type));
+            }
+            else
+            {
+                IEnumerator<JsonSchemaType> en = EnumUtils.GetFlagsValues(type).Where(v => v != JsonSchemaType.None).GetEnumerator();
+                if (en.MoveNext())
+                {
+                    writer.WritePropertyName(propertyName);
+                    JsonSchemaType first = en.Current;
+                    if (en.MoveNext())
+                    {
+                        writer.WriteStartArray();
+                        writer.WriteValue(JsonSchemaBuilder.MapType(first));
+                        do
+                        {
+                            writer.WriteValue(JsonSchemaBuilder.MapType(en.Current));
+                        } while (en.MoveNext());
+                        writer.WriteEndArray();
+                    }
+                    else
+                    {
+                        writer.WriteValue(JsonSchemaBuilder.MapType(first));
+                    }
+                }
+            }
+        }
+
+        private void WritePropertyIfNotNull(JsonWriter writer, string propertyName, object value)
+        {
+            if (value != null)
+            {
+                writer.WritePropertyName(propertyName);
+                writer.WriteValue(value);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/UndefinedSchemaIdHandling.cs b/Libs/Newtonsoft.Json/Schema/UndefinedSchemaIdHandling.cs
new file mode 100644
index 0000000..ab51e6a
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/UndefinedSchemaIdHandling.cs
@@ -0,0 +1,58 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// Specifies undefined schema Id handling options for the <see cref="JsonSchemaGenerator"/>.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public enum UndefinedSchemaIdHandling
+    {
+        /// <summary>
+        /// Do not infer a schema Id.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Use the .NET type name as the schema Id.
+        /// </summary>
+        UseTypeName = 1,
+
+        /// <summary>
+        /// Use the assembly qualified .NET type name as the schema Id.
+        /// </summary>
+        UseAssemblyQualifiedName = 2,
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/ValidationEventArgs.cs b/Libs/Newtonsoft.Json/Schema/ValidationEventArgs.cs
new file mode 100644
index 0000000..83d81e8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/ValidationEventArgs.cs
@@ -0,0 +1,70 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Utilities;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// Returns detailed information related to the <see cref="ValidationEventHandler"/>.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public class ValidationEventArgs : EventArgs
+    {
+        private readonly JsonSchemaException _ex;
+
+        internal ValidationEventArgs(JsonSchemaException ex)
+        {
+            ValidationUtils.ArgumentNotNull(ex, nameof(ex));
+            _ex = ex;
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JsonSchemaException"/> associated with the validation error.
+        /// </summary>
+        /// <value>The JsonSchemaException associated with the validation error.</value>
+        public JsonSchemaException Exception => _ex;
+
+        /// <summary>
+        /// Gets the path of the JSON location where the validation error occurred.
+        /// </summary>
+        /// <value>The path of the JSON location where the validation error occurred.</value>
+        public string Path => _ex.Path;
+
+        /// <summary>
+        /// Gets the text description corresponding to the validation error.
+        /// </summary>
+        /// <value>The text description.</value>
+        public string Message => _ex.Message;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Schema/ValidationEventHandler.cs b/Libs/Newtonsoft.Json/Schema/ValidationEventHandler.cs
new file mode 100644
index 0000000..2e4e98c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Schema/ValidationEventHandler.cs
@@ -0,0 +1,42 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Schema
+{
+    /// <summary>
+    /// <para>
+    /// Represents the callback method that will handle JSON schema validation events and the <see cref="ValidationEventArgs"/>.
+    /// </para>
+    /// <note type="caution">
+    /// JSON Schema validation has been moved to its own package. See <see href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</see> for more details.
+    /// </note>
+    /// </summary>
+    [Obsolete("JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details.")]
+    public delegate void ValidationEventHandler(object sender, ValidationEventArgs e);
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/CachedAttributeGetter.cs b/Libs/Newtonsoft.Json/Serialization/CachedAttributeGetter.cs
new file mode 100644
index 0000000..b4e372b
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/CachedAttributeGetter.cs
@@ -0,0 +1,41 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal static class CachedAttributeGetter<T> where T : Attribute
+    {
+        private static readonly ThreadSafeStore<object, T?> TypeAttributeCache = new ThreadSafeStore<object, T?>(JsonTypeReflector.GetAttribute<T>);
+
+        public static T? GetAttribute(object type)
+        {
+            return TypeAttributeCache.Get(type);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/CamelCaseNamingStrategy.cs b/Libs/Newtonsoft.Json/Serialization/CamelCaseNamingStrategy.cs
new file mode 100644
index 0000000..2555f38
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/CamelCaseNamingStrategy.cs
@@ -0,0 +1,87 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// A camel case naming strategy.
+    /// </summary>
+    public class CamelCaseNamingStrategy : NamingStrategy
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CamelCaseNamingStrategy"/> class.
+        /// </summary>
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
+        /// </param>
+        /// <param name="overrideSpecifiedNames">
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
+        /// </param>
+        public CamelCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames)
+        {
+            ProcessDictionaryKeys = processDictionaryKeys;
+            OverrideSpecifiedNames = overrideSpecifiedNames;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CamelCaseNamingStrategy"/> class.
+        /// </summary>
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
+        /// </param>
+        /// <param name="overrideSpecifiedNames">
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
+        /// </param>
+        /// <param name="processExtensionDataNames">
+        /// A flag indicating whether extension data names should be processed.
+        /// </param>
+        public CamelCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames, bool processExtensionDataNames)
+            : this(processDictionaryKeys, overrideSpecifiedNames)
+        {
+            ProcessExtensionDataNames = processExtensionDataNames;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CamelCaseNamingStrategy"/> class.
+        /// </summary>
+        public CamelCaseNamingStrategy()
+        {
+        }
+
+        /// <summary>
+        /// Resolves the specified property name.
+        /// </summary>
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected override string ResolvePropertyName(string name)
+        {
+            return StringUtils.ToCamelCase(name);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/CamelCasePropertyNamesContractResolver.cs b/Libs/Newtonsoft.Json/Serialization/CamelCasePropertyNamesContractResolver.cs
new file mode 100644
index 0000000..582d3ac
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/CamelCasePropertyNamesContractResolver.cs
@@ -0,0 +1,94 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Resolves member mappings for a type, camel casing property names.
+    /// </summary>
+    public class CamelCasePropertyNamesContractResolver : DefaultContractResolver
+    {
+        private static readonly object TypeContractCacheLock = new object();
+        private static readonly DefaultJsonNameTable NameTable = new DefaultJsonNameTable();
+        private static Dictionary<StructMultiKey<Type, Type>, JsonContract>? _contractCache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CamelCasePropertyNamesContractResolver"/> class.
+        /// </summary>
+        public CamelCasePropertyNamesContractResolver()
+        {
+            NamingStrategy = new CamelCaseNamingStrategy
+            {
+                ProcessDictionaryKeys = true,
+                OverrideSpecifiedNames = true
+            };
+        }
+
+        /// <summary>
+        /// Resolves the contract for a given type.
+        /// </summary>
+        /// <param name="type">The type to resolve a contract for.</param>
+        /// <returns>The contract for a given type.</returns>
+        public override JsonContract ResolveContract(Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            // for backwards compadibility the CamelCasePropertyNamesContractResolver shares contracts between instances
+            StructMultiKey<Type, Type> key = new StructMultiKey<Type, Type>(GetType(), type);
+            Dictionary<StructMultiKey<Type, Type>, JsonContract>? cache = _contractCache;
+            if (cache == null || !cache.TryGetValue(key, out JsonContract contract))
+            {
+                contract = CreateContract(type);
+
+                // avoid the possibility of modifying the cache dictionary while another thread is accessing it
+                lock (TypeContractCacheLock)
+                {
+                    cache = _contractCache;
+                    Dictionary<StructMultiKey<Type, Type>, JsonContract> updatedCache = (cache != null)
+                        ? new Dictionary<StructMultiKey<Type, Type>, JsonContract>(cache)
+                        : new Dictionary<StructMultiKey<Type, Type>, JsonContract>();
+                    updatedCache[key] = contract;
+
+                    _contractCache = updatedCache;
+                }
+            }
+
+            return contract;
+        }
+
+        internal override DefaultJsonNameTable GetNameTable()
+        {
+            return NameTable;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/DefaultContractResolver.cs b/Libs/Newtonsoft.Json/Serialization/DefaultContractResolver.cs
new file mode 100644
index 0000000..6d21f84
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/DefaultContractResolver.cs
@@ -0,0 +1,1731 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+#if HAVE_CONCURRENT_DICTIONARY
+using System.Collections.Concurrent;
+#endif
+using LC.Newtonsoft.Json.Schema;
+using System.Collections.Generic;
+using System.ComponentModel;
+#if HAVE_DYNAMIC
+using System.Dynamic;
+#endif
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+using System.Runtime.Serialization;
+#if HAVE_CAS
+using System.Security.Permissions;
+#endif
+using LC.Newtonsoft.Json.Converters;
+using LC.Newtonsoft.Json.Utilities;
+using LC.Newtonsoft.Json.Linq;
+using System.Runtime.CompilerServices;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Used by <see cref="JsonSerializer"/> to resolve a <see cref="JsonContract"/> for a given <see cref="System.Type"/>.
+    /// </summary>
+    public class DefaultContractResolver : IContractResolver
+    {
+        private static readonly IContractResolver _instance = new DefaultContractResolver();
+
+        // Json.NET Schema requires a property
+        internal static IContractResolver Instance => _instance;
+
+        private static readonly string[] BlacklistedTypeNames =
+        {
+            "System.IO.DriveInfo",
+            "System.IO.FileInfo",
+            "System.IO.DirectoryInfo"
+        };
+
+        private static readonly JsonConverter[] BuiltInConverters =
+        {
+#if HAVE_ENTITY_FRAMEWORK
+            new EntityKeyMemberConverter(),
+#endif
+#if HAVE_DYNAMIC
+            new ExpandoObjectConverter(),
+#endif
+#if (HAVE_XML_DOCUMENT || HAVE_XLINQ)
+            new XmlNodeConverter(),
+#endif
+#if HAVE_ADO_NET
+            new BinaryConverter(),
+            new DataSetConverter(),
+            new DataTableConverter(),
+#endif
+#if HAVE_FSHARP_TYPES
+            new DiscriminatedUnionConverter(),
+#endif
+            new KeyValuePairConverter(),
+#pragma warning disable 618
+            new BsonObjectIdConverter(),
+#pragma warning restore 618
+            new RegexConverter()
+        };
+
+        private readonly DefaultJsonNameTable _nameTable = new DefaultJsonNameTable();
+
+        private readonly ThreadSafeStore<Type, JsonContract> _contractCache;
+
+        /// <summary>
+        /// Gets a value indicating whether members are being get and set using dynamic code generation.
+        /// This value is determined by the runtime permissions available.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if using dynamic code generation; otherwise, <c>false</c>.
+        /// </value>
+        public bool DynamicCodeGeneration => JsonTypeReflector.DynamicCodeGeneration;
+
+#if !PORTABLE
+        /// <summary>
+        /// Gets or sets the default members search flags.
+        /// </summary>
+        /// <value>The default members search flags.</value>
+        [Obsolete("DefaultMembersSearchFlags is obsolete. To modify the members serialized inherit from DefaultContractResolver and override the GetSerializableMembers method instead.")]
+        public BindingFlags DefaultMembersSearchFlags { get; set; }
+#else
+        private readonly BindingFlags DefaultMembersSearchFlags;
+#endif
+
+        /// <summary>
+        /// Gets or sets a value indicating whether compiler generated members should be serialized.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if serialized compiler generated members; otherwise, <c>false</c>.
+        /// </value>
+        public bool SerializeCompilerGeneratedMembers { get; set; }
+
+#if HAVE_BINARY_SERIALIZATION
+        /// <summary>
+        /// Gets or sets a value indicating whether to ignore the <see cref="ISerializable"/> interface when serializing and deserializing types.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if the <see cref="ISerializable"/> interface will be ignored when serializing and deserializing types; otherwise, <c>false</c>.
+        /// </value>
+        public bool IgnoreSerializableInterface { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to ignore the <see cref="SerializableAttribute"/> attribute when serializing and deserializing types.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if the <see cref="SerializableAttribute"/> attribute will be ignored when serializing and deserializing types; otherwise, <c>false</c>.
+        /// </value>
+        public bool IgnoreSerializableAttribute { get; set; }
+#endif
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to ignore IsSpecified members when serializing and deserializing types.
+        /// </summary>
+        /// <value>
+        ///     <c>true</c> if the IsSpecified members will be ignored when serializing and deserializing types; otherwise, <c>false</c>.
+        /// </value>
+        public bool IgnoreIsSpecifiedMembers { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to ignore ShouldSerialize members when serializing and deserializing types.
+        /// </summary>
+        /// <value>
+        ///     <c>true</c> if the ShouldSerialize members will be ignored when serializing and deserializing types; otherwise, <c>false</c>.
+        /// </value>
+        public bool IgnoreShouldSerializeMembers { get; set; }
+
+        /// <summary>
+        /// Gets or sets the naming strategy used to resolve how property names and dictionary keys are serialized.
+        /// </summary>
+        /// <value>The naming strategy used to resolve how property names and dictionary keys are serialized.</value>
+        public NamingStrategy? NamingStrategy { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultContractResolver"/> class.
+        /// </summary>
+        public DefaultContractResolver()
+        {
+#if HAVE_BINARY_SERIALIZATION
+            IgnoreSerializableAttribute = true;
+#endif
+
+#pragma warning disable 618
+            DefaultMembersSearchFlags = BindingFlags.Instance | BindingFlags.Public;
+#pragma warning restore 618
+
+            _contractCache = new ThreadSafeStore<Type, JsonContract>(CreateContract);
+        }
+
+        /// <summary>
+        /// Resolves the contract for a given type.
+        /// </summary>
+        /// <param name="type">The type to resolve a contract for.</param>
+        /// <returns>The contract for a given type.</returns>
+        public virtual JsonContract ResolveContract(Type type)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+
+            return _contractCache.Get(type);
+        }
+
+        private static bool FilterMembers(MemberInfo member)
+        {
+            if (member is PropertyInfo property)
+            {
+                if (ReflectionUtils.IsIndexedProperty(property))
+                {
+                    return false;
+                }
+
+                return !ReflectionUtils.IsByRefLikeType(property.PropertyType);
+            }
+            else if (member is FieldInfo field)
+            {
+                return !ReflectionUtils.IsByRefLikeType(field.FieldType);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the serializable members for the type.
+        /// </summary>
+        /// <param name="objectType">The type to get serializable members for.</param>
+        /// <returns>The serializable members for the type.</returns>
+        protected virtual List<MemberInfo> GetSerializableMembers(Type objectType)
+        {
+            bool ignoreSerializableAttribute;
+#if HAVE_BINARY_SERIALIZATION
+            ignoreSerializableAttribute = IgnoreSerializableAttribute;
+#else
+            ignoreSerializableAttribute = true;
+#endif
+
+            MemberSerialization memberSerialization = JsonTypeReflector.GetObjectMemberSerialization(objectType, ignoreSerializableAttribute);
+
+            // Exclude index properties
+            // Do not filter ByRef types here because accessing FieldType/PropertyType can trigger additonal assembly loads
+            IEnumerable<MemberInfo> allMembers = ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)
+                .Where(m => m is PropertyInfo p ? !ReflectionUtils.IsIndexedProperty(p) : true);
+
+            List<MemberInfo> serializableMembers = new List<MemberInfo>();
+
+            if (memberSerialization != MemberSerialization.Fields)
+            {
+#if HAVE_DATA_CONTRACTS
+                DataContractAttribute? dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType);
+#endif
+
+#pragma warning disable 618
+                // Exclude index properties and ByRef types
+                List<MemberInfo> defaultMembers = ReflectionUtils.GetFieldsAndProperties(objectType, DefaultMembersSearchFlags)
+                    .Where(FilterMembers).ToList();
+#pragma warning restore 618
+
+                foreach (MemberInfo member in allMembers)
+                {
+                    // exclude members that are compiler generated if set
+                    if (SerializeCompilerGeneratedMembers || !member.IsDefined(typeof(CompilerGeneratedAttribute), true))
+                    {
+                        if (defaultMembers.Contains(member))
+                        {
+                            // add all members that are found by default member search
+                            serializableMembers.Add(member);
+                        }
+                        else
+                        {
+                            // add members that are explicitly marked with JsonProperty/DataMember attribute
+                            // or are a field if serializing just fields
+                            if (JsonTypeReflector.GetAttribute<JsonPropertyAttribute>(member) != null)
+                            {
+                                serializableMembers.Add(member);
+                            }
+                            else if (JsonTypeReflector.GetAttribute<JsonRequiredAttribute>(member) != null)
+                            {
+                                serializableMembers.Add(member);
+                            }
+#if HAVE_DATA_CONTRACTS
+                            else if (dataContractAttribute != null && JsonTypeReflector.GetAttribute<DataMemberAttribute>(member) != null)
+                            {
+                                serializableMembers.Add(member);
+                            }
+#endif
+                            else if (memberSerialization == MemberSerialization.Fields && member.MemberType() == MemberTypes.Field)
+                            {
+                                serializableMembers.Add(member);
+                            }
+                        }
+                    }
+                }
+
+#if HAVE_DATA_CONTRACTS
+                // don't include EntityKey on entities objects... this is a bit hacky
+                if (objectType.AssignableToTypeName("System.Data.Objects.DataClasses.EntityObject", false, out _))
+                {
+                    serializableMembers = serializableMembers.Where(ShouldSerializeEntityMember).ToList();
+                }
+#endif
+                // don't include TargetSite on non-serializable exceptions
+                // MemberBase is problematic to serialize. Large, self referencing instances, etc
+                if (typeof(Exception).IsAssignableFrom(objectType))
+                {
+                    serializableMembers = serializableMembers.Where(m => !string.Equals(m.Name, "TargetSite", StringComparison.Ordinal)).ToList();
+                }
+            }
+            else
+            {
+                // serialize all fields
+                foreach (MemberInfo member in allMembers)
+                {
+                    if (member is FieldInfo field && !field.IsStatic)
+                    {
+                        serializableMembers.Add(member);
+                    }
+                }
+            }
+
+            return serializableMembers;
+        }
+
+#if HAVE_DATA_CONTRACTS
+        private bool ShouldSerializeEntityMember(MemberInfo memberInfo)
+        {
+            if (memberInfo is PropertyInfo propertyInfo)
+            {
+                if (propertyInfo.PropertyType.IsGenericType() && propertyInfo.PropertyType.GetGenericTypeDefinition().FullName == "System.Data.Objects.DataClasses.EntityReference`1")
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+#endif
+
+        /// <summary>
+        /// Creates a <see cref="JsonObjectContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonObjectContract"/> for the given type.</returns>
+        protected virtual JsonObjectContract CreateObjectContract(Type objectType)
+        {
+            JsonObjectContract contract = new JsonObjectContract(objectType);
+            InitializeContract(contract);
+
+            bool ignoreSerializableAttribute;
+#if HAVE_BINARY_SERIALIZATION
+            ignoreSerializableAttribute = IgnoreSerializableAttribute;
+#else
+            ignoreSerializableAttribute = true;
+#endif
+
+            contract.MemberSerialization = JsonTypeReflector.GetObjectMemberSerialization(contract.NonNullableUnderlyingType, ignoreSerializableAttribute);
+            contract.Properties.AddRange(CreateProperties(contract.NonNullableUnderlyingType, contract.MemberSerialization));
+
+            Func<string, string>? extensionDataNameResolver = null;
+
+            JsonObjectAttribute? attribute = JsonTypeReflector.GetCachedAttribute<JsonObjectAttribute>(contract.NonNullableUnderlyingType);
+            if (attribute != null)
+            {
+                contract.ItemRequired = attribute._itemRequired;
+                contract.ItemNullValueHandling = attribute._itemNullValueHandling;
+                contract.MissingMemberHandling = attribute._missingMemberHandling;
+
+                if (attribute.NamingStrategyType != null)
+                {
+                    NamingStrategy namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(attribute)!;
+                    extensionDataNameResolver = s => namingStrategy.GetDictionaryKey(s);
+                }
+            }
+
+            if (extensionDataNameResolver == null)
+            {
+                extensionDataNameResolver = ResolveExtensionDataName;
+            }
+
+            contract.ExtensionDataNameResolver = extensionDataNameResolver;
+
+            if (contract.IsInstantiable)
+            {
+                ConstructorInfo? overrideConstructor = GetAttributeConstructor(contract.NonNullableUnderlyingType);
+
+                // check if a JsonConstructorAttribute has been defined and use that
+                if (overrideConstructor != null)
+                {
+                    contract.OverrideCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(overrideConstructor);
+                    contract.CreatorParameters.AddRange(CreateConstructorParameters(overrideConstructor, contract.Properties));
+                }
+                else if (contract.MemberSerialization == MemberSerialization.Fields)
+                {
+#if HAVE_BINARY_FORMATTER
+                    // mimic DataContractSerializer behaviour when populating fields by overriding default creator to create an uninitialized object
+                    // note that this is only possible when the application is fully trusted so fall back to using the default constructor (if available) in partial trust
+                    if (JsonTypeReflector.FullyTrusted)
+                    {
+                        contract.DefaultCreator = contract.GetUninitializedObject;
+                    }
+#endif
+                }
+                else if (contract.DefaultCreator == null || contract.DefaultCreatorNonPublic)
+                {
+                    ConstructorInfo? constructor = GetParameterizedConstructor(contract.NonNullableUnderlyingType);
+                    if (constructor != null)
+                    {
+                        contract.ParameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(constructor);
+                        contract.CreatorParameters.AddRange(CreateConstructorParameters(constructor, contract.Properties));
+                    }
+                }
+                else if (contract.NonNullableUnderlyingType.IsValueType())
+                {
+                    // value types always have default constructor
+                    // check whether there is a constructor that matches with non-writable properties on value type
+                    ConstructorInfo? constructor = GetImmutableConstructor(contract.NonNullableUnderlyingType, contract.Properties);
+                    if (constructor != null)
+                    {
+                        contract.OverrideCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(constructor);
+                        contract.CreatorParameters.AddRange(CreateConstructorParameters(constructor, contract.Properties));
+                    }
+                }
+            }
+
+            MemberInfo extensionDataMember = GetExtensionDataMemberForType(contract.NonNullableUnderlyingType);
+            if (extensionDataMember != null)
+            {
+                SetExtensionDataDelegates(contract, extensionDataMember);
+            }
+
+            // serializing DirectoryInfo without ISerializable will stackoverflow
+            // https://github.com/JamesNK/Newtonsoft.Json/issues/1541
+            if (Array.IndexOf(BlacklistedTypeNames, objectType.FullName) != -1)
+            {
+                contract.OnSerializingCallbacks.Add(ThrowUnableToSerializeError);
+            }
+
+            return contract;
+        }
+
+        private static void ThrowUnableToSerializeError(object o, StreamingContext context)
+        {
+            throw new JsonSerializationException("Unable to serialize instance of '{0}'.".FormatWith(CultureInfo.InvariantCulture, o.GetType()));
+        }
+
+        private MemberInfo GetExtensionDataMemberForType(Type type)
+        {
+            IEnumerable<MemberInfo> members = GetClassHierarchyForType(type).SelectMany(baseType =>
+            {
+                IList<MemberInfo> m = new List<MemberInfo>();
+                m.AddRange(baseType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
+                m.AddRange(baseType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
+
+                return m;
+            });
+
+            MemberInfo extensionDataMember = members.LastOrDefault(m =>
+            {
+                MemberTypes memberType = m.MemberType();
+                if (memberType != MemberTypes.Property && memberType != MemberTypes.Field)
+                {
+                    return false;
+                }
+
+                // last instance of attribute wins on type if there are multiple
+                if (!m.IsDefined(typeof(JsonExtensionDataAttribute), false))
+                {
+                    return false;
+                }
+
+                if (!ReflectionUtils.CanReadMemberValue(m, true))
+                {
+                    throw new JsonException("Invalid extension data attribute on '{0}'. Member '{1}' must have a getter.".FormatWith(CultureInfo.InvariantCulture, GetClrTypeFullName(m.DeclaringType), m.Name));
+                }
+
+                Type t = ReflectionUtils.GetMemberUnderlyingType(m);
+
+                if (ReflectionUtils.ImplementsGenericDefinition(t, typeof(IDictionary<,>), out Type? dictionaryType))
+                {
+                    Type keyType = dictionaryType.GetGenericArguments()[0];
+                    Type valueType = dictionaryType.GetGenericArguments()[1];
+
+                    if (keyType.IsAssignableFrom(typeof(string)) && valueType.IsAssignableFrom(typeof(JToken)))
+                    {
+                        return true;
+                    }
+                }
+
+                throw new JsonException("Invalid extension data attribute on '{0}'. Member '{1}' type must implement IDictionary<string, JToken>.".FormatWith(CultureInfo.InvariantCulture, GetClrTypeFullName(m.DeclaringType), m.Name));
+            });
+
+            return extensionDataMember;
+        }
+
+        private static void SetExtensionDataDelegates(JsonObjectContract contract, MemberInfo member)
+        {
+            JsonExtensionDataAttribute? extensionDataAttribute = ReflectionUtils.GetAttribute<JsonExtensionDataAttribute>(member);
+            if (extensionDataAttribute == null)
+            {
+                return;
+            }
+
+            Type t = ReflectionUtils.GetMemberUnderlyingType(member);
+
+            ReflectionUtils.ImplementsGenericDefinition(t, typeof(IDictionary<,>), out Type? dictionaryType);
+
+            Type keyType = dictionaryType!.GetGenericArguments()[0];
+            Type valueType = dictionaryType!.GetGenericArguments()[1];
+
+            Type createdType;
+
+            // change type to a class if it is the base interface so it can be instantiated if needed
+            if (ReflectionUtils.IsGenericDefinition(t, typeof(IDictionary<,>)))
+            {
+                createdType = typeof(Dictionary<,>).MakeGenericType(keyType, valueType);
+            }
+            else
+            {
+                createdType = t;
+            }
+
+            Func<object, object?> getExtensionDataDictionary = JsonTypeReflector.ReflectionDelegateFactory.CreateGet<object>(member);
+
+            if (extensionDataAttribute.ReadData)
+            {
+                Action<object, object?>? setExtensionDataDictionary = (ReflectionUtils.CanSetMemberValue(member, true, false))
+                 ? JsonTypeReflector.ReflectionDelegateFactory.CreateSet<object>(member)
+                 : null;
+                Func<object> createExtensionDataDictionary = JsonTypeReflector.ReflectionDelegateFactory.CreateDefaultConstructor<object>(createdType);
+                MethodInfo? setMethod = t.GetProperty("Item", BindingFlags.Public | BindingFlags.Instance, null, valueType, new[] { keyType }, null)?.GetSetMethod();
+                if (setMethod == null)
+                {
+                    // Item is explicitly implemented and non-public
+                    // get from dictionary interface
+                    setMethod = dictionaryType!.GetProperty("Item", BindingFlags.Public | BindingFlags.Instance, null, valueType, new[] { keyType }, null)?.GetSetMethod();
+                }
+
+                MethodCall<object, object?> setExtensionDataDictionaryValue = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object>(setMethod!);
+
+                ExtensionDataSetter extensionDataSetter = (o, key, value) =>
+                {
+                    object? dictionary = getExtensionDataDictionary(o);
+                    if (dictionary == null)
+                    {
+                        if (setExtensionDataDictionary == null)
+                        {
+                            throw new JsonSerializationException("Cannot set value onto extension data member '{0}'. The extension data collection is null and it cannot be set.".FormatWith(CultureInfo.InvariantCulture, member.Name));
+                        }
+
+                        dictionary = createExtensionDataDictionary();
+                        setExtensionDataDictionary(o, dictionary);
+                    }
+
+                    setExtensionDataDictionaryValue(dictionary, key, value);
+                };
+
+                contract.ExtensionDataSetter = extensionDataSetter;
+            }
+
+            if (extensionDataAttribute.WriteData)
+            {
+                Type enumerableWrapper = typeof(EnumerableDictionaryWrapper<,>).MakeGenericType(keyType, valueType);
+                ConstructorInfo constructors = enumerableWrapper.GetConstructors().First();
+                ObjectConstructor<object> createEnumerableWrapper = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(constructors);
+
+                ExtensionDataGetter extensionDataGetter = o =>
+                {
+                    object? dictionary = getExtensionDataDictionary(o);
+                    if (dictionary == null)
+                    {
+                        return null;
+                    }
+
+                    return (IEnumerable<KeyValuePair<object, object>>)createEnumerableWrapper(dictionary);
+                };
+
+                contract.ExtensionDataGetter = extensionDataGetter;
+            }
+
+            contract.ExtensionDataValueType = valueType;
+        }
+
+        // leave as class instead of struct
+        // will be always return as an interface and boxed
+        internal class EnumerableDictionaryWrapper<TEnumeratorKey, TEnumeratorValue> : IEnumerable<KeyValuePair<object, object>>
+        {
+            private readonly IEnumerable<KeyValuePair<TEnumeratorKey, TEnumeratorValue>> _e;
+
+            public EnumerableDictionaryWrapper(IEnumerable<KeyValuePair<TEnumeratorKey, TEnumeratorValue>> e)
+            {
+                ValidationUtils.ArgumentNotNull(e, nameof(e));
+                _e = e;
+            }
+
+            public IEnumerator<KeyValuePair<object, object>> GetEnumerator()
+            {
+                foreach (KeyValuePair<TEnumeratorKey, TEnumeratorValue> item in _e)
+                {
+                    yield return new KeyValuePair<object, object>(item.Key!, item.Value!);
+                }
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+        }
+
+        private ConstructorInfo? GetAttributeConstructor(Type objectType)
+        {
+            IEnumerator<ConstructorInfo> en = objectType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Where(c => c.IsDefined(typeof(JsonConstructorAttribute), true)).GetEnumerator();
+
+            if (en.MoveNext())
+            {
+                ConstructorInfo conInfo = en.Current;
+                if (en.MoveNext())
+                {
+                    throw new JsonException("Multiple constructors with the JsonConstructorAttribute.");
+                }
+
+                return conInfo;
+            }
+
+            // little hack to get Version objects to deserialize correctly
+            if (objectType == typeof(Version))
+            {
+                return objectType.GetConstructor(new[] { typeof(int), typeof(int), typeof(int), typeof(int) });
+            }
+
+            return null;
+        }
+
+        private ConstructorInfo? GetImmutableConstructor(Type objectType, JsonPropertyCollection memberProperties)
+        {
+            IEnumerable<ConstructorInfo> constructors = objectType.GetConstructors();
+            IEnumerator<ConstructorInfo> en = constructors.GetEnumerator();
+            if (en.MoveNext())
+            {
+                ConstructorInfo constructor = en.Current;
+                if (!en.MoveNext())
+                {
+                    ParameterInfo[] parameters = constructor.GetParameters();
+                    if (parameters.Length > 0)
+                    {
+                        foreach (ParameterInfo parameterInfo in parameters)
+                        {
+                            JsonProperty? memberProperty = MatchProperty(memberProperties, parameterInfo.Name, parameterInfo.ParameterType);
+                            if (memberProperty == null || memberProperty.Writable)
+                            {
+                                return null;
+                            }
+                        }
+
+                        return constructor;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private ConstructorInfo? GetParameterizedConstructor(Type objectType)
+        {
+#if PORTABLE
+            IEnumerable<ConstructorInfo> constructors = objectType.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+            IEnumerator<ConstructorInfo> en = constructors.GetEnumerator();
+            if (en.MoveNext())
+            {
+                ConstructorInfo conInfo = en.Current;
+                if (!en.MoveNext())
+                {
+                    return conInfo;
+                }
+            }
+#else
+            ConstructorInfo[] constructors = objectType.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+            if (constructors.Length == 1)
+            {
+                return constructors[0];
+            }
+#endif
+            return null;
+        }
+
+        /// <summary>
+        /// Creates the constructor parameters.
+        /// </summary>
+        /// <param name="constructor">The constructor to create properties for.</param>
+        /// <param name="memberProperties">The type's member properties.</param>
+        /// <returns>Properties for the given <see cref="ConstructorInfo"/>.</returns>
+        protected virtual IList<JsonProperty> CreateConstructorParameters(ConstructorInfo constructor, JsonPropertyCollection memberProperties)
+        {
+            ParameterInfo[] constructorParameters = constructor.GetParameters();
+
+            JsonPropertyCollection parameterCollection = new JsonPropertyCollection(constructor.DeclaringType);
+
+            foreach (ParameterInfo parameterInfo in constructorParameters)
+            {
+                if (parameterInfo.Name == null)
+                {
+                    continue;
+                }
+
+                JsonProperty? matchingMemberProperty = MatchProperty(memberProperties, parameterInfo.Name, parameterInfo.ParameterType);
+
+                // ensure that property will have a name from matching property or from parameterinfo
+                // parameterinfo could have no name if generated by a proxy (I'm looking at you Castle)
+                if (matchingMemberProperty != null || parameterInfo.Name != null)
+                {
+                    JsonProperty property = CreatePropertyFromConstructorParameter(matchingMemberProperty, parameterInfo);
+
+                    if (property != null)
+                    {
+                        parameterCollection.AddProperty(property);
+                    }
+                }
+            }
+
+            return parameterCollection;
+        }
+
+        private JsonProperty? MatchProperty(JsonPropertyCollection properties, string name, Type type)
+        {
+            // it is possible to generate a member with a null name using Reflection.Emit
+            // protect against an ArgumentNullException from GetClosestMatchProperty by testing for null here
+            if (name == null)
+            {
+                return null;
+            }
+
+            JsonProperty? property = properties.GetClosestMatchProperty(name);
+            // must match type as well as name
+            if (property == null || property.PropertyType != type)
+            {
+                return null;
+            }
+
+            return property;
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JsonProperty"/> for the given <see cref="ParameterInfo"/>.
+        /// </summary>
+        /// <param name="matchingMemberProperty">The matching member property.</param>
+        /// <param name="parameterInfo">The constructor parameter.</param>
+        /// <returns>A created <see cref="JsonProperty"/> for the given <see cref="ParameterInfo"/>.</returns>
+        protected virtual JsonProperty CreatePropertyFromConstructorParameter(JsonProperty? matchingMemberProperty, ParameterInfo parameterInfo)
+        {
+            JsonProperty property = new JsonProperty();
+            property.PropertyType = parameterInfo.ParameterType;
+            property.AttributeProvider = new ReflectionAttributeProvider(parameterInfo);
+
+            SetPropertySettingsFromAttributes(property, parameterInfo, parameterInfo.Name, parameterInfo.Member.DeclaringType, MemberSerialization.OptOut, out _);
+
+            property.Readable = false;
+            property.Writable = true;
+
+            // "inherit" values from matching member property if unset on parameter
+            if (matchingMemberProperty != null)
+            {
+                property.PropertyName = (property.PropertyName != parameterInfo.Name) ? property.PropertyName : matchingMemberProperty.PropertyName;
+                property.Converter = property.Converter ?? matchingMemberProperty.Converter;
+
+                if (!property._hasExplicitDefaultValue && matchingMemberProperty._hasExplicitDefaultValue)
+                {
+                    property.DefaultValue = matchingMemberProperty.DefaultValue;
+                }
+
+                property._required = property._required ?? matchingMemberProperty._required;
+                property.IsReference = property.IsReference ?? matchingMemberProperty.IsReference;
+                property.NullValueHandling = property.NullValueHandling ?? matchingMemberProperty.NullValueHandling;
+                property.DefaultValueHandling = property.DefaultValueHandling ?? matchingMemberProperty.DefaultValueHandling;
+                property.ReferenceLoopHandling = property.ReferenceLoopHandling ?? matchingMemberProperty.ReferenceLoopHandling;
+                property.ObjectCreationHandling = property.ObjectCreationHandling ?? matchingMemberProperty.ObjectCreationHandling;
+                property.TypeNameHandling = property.TypeNameHandling ?? matchingMemberProperty.TypeNameHandling;
+            }
+
+            return property;
+        }
+
+        /// <summary>
+        /// Resolves the default <see cref="JsonConverter" /> for the contract.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>The contract's default <see cref="JsonConverter" />.</returns>
+        protected virtual JsonConverter? ResolveContractConverter(Type objectType)
+        {
+            return JsonTypeReflector.GetJsonConverter(objectType);
+        }
+
+        private Func<object> GetDefaultCreator(Type createdType)
+        {
+            return JsonTypeReflector.ReflectionDelegateFactory.CreateDefaultConstructor<object>(createdType);
+        }
+
+#if NET35
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Portability", "CA1903:UseOnlyApiFromTargetedFramework", MessageId = "System.Runtime.Serialization.DataContractAttribute.#get_IsReference()")]
+#endif
+        private void InitializeContract(JsonContract contract)
+        {
+            JsonContainerAttribute? containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(contract.NonNullableUnderlyingType);
+            if (containerAttribute != null)
+            {
+                contract.IsReference = containerAttribute._isReference;
+            }
+#if HAVE_DATA_CONTRACTS
+            else
+            {
+                DataContractAttribute? dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(contract.NonNullableUnderlyingType);
+                // doesn't have a null value
+                if (dataContractAttribute != null && dataContractAttribute.IsReference)
+                {
+                    contract.IsReference = true;
+                }
+            }
+#endif
+
+            contract.Converter = ResolveContractConverter(contract.NonNullableUnderlyingType);
+
+            // then see whether object is compatible with any of the built in converters
+            contract.InternalConverter = JsonSerializer.GetMatchingConverter(BuiltInConverters, contract.NonNullableUnderlyingType);
+
+            if (contract.IsInstantiable
+                && (ReflectionUtils.HasDefaultConstructor(contract.CreatedType, true) || contract.CreatedType.IsValueType()))
+            {
+                contract.DefaultCreator = GetDefaultCreator(contract.CreatedType);
+
+                contract.DefaultCreatorNonPublic = (!contract.CreatedType.IsValueType() &&
+                                                    ReflectionUtils.GetDefaultConstructor(contract.CreatedType) == null);
+            }
+
+            ResolveCallbackMethods(contract, contract.NonNullableUnderlyingType);
+        }
+
+        private void ResolveCallbackMethods(JsonContract contract, Type t)
+        {
+            GetCallbackMethodsForType(
+                t,
+                out List<SerializationCallback>? onSerializing,
+                out List<SerializationCallback>? onSerialized,
+                out List<SerializationCallback>? onDeserializing,
+                out List<SerializationCallback>? onDeserialized,
+                out List<SerializationErrorCallback>? onError);
+
+            if (onSerializing != null)
+            {
+                contract.OnSerializingCallbacks.AddRange(onSerializing);
+            }
+
+            if (onSerialized != null)
+            {
+                contract.OnSerializedCallbacks.AddRange(onSerialized);
+            }
+
+            if (onDeserializing != null)
+            {
+                contract.OnDeserializingCallbacks.AddRange(onDeserializing);
+            }
+
+            if (onDeserialized != null)
+            {
+                contract.OnDeserializedCallbacks.AddRange(onDeserialized);
+            }
+
+            if (onError != null)
+            {
+                contract.OnErrorCallbacks.AddRange(onError);
+            }
+        }
+
+        private void GetCallbackMethodsForType(Type type, out List<SerializationCallback>? onSerializing, out List<SerializationCallback>? onSerialized, out List<SerializationCallback>? onDeserializing, out List<SerializationCallback>? onDeserialized, out List<SerializationErrorCallback>? onError)
+        {
+            onSerializing = null;
+            onSerialized = null;
+            onDeserializing = null;
+            onDeserialized = null;
+            onError = null;
+
+            foreach (Type baseType in GetClassHierarchyForType(type))
+            {
+                // while we allow more than one OnSerialized total, only one can be defined per class
+                MethodInfo? currentOnSerializing = null;
+                MethodInfo? currentOnSerialized = null;
+                MethodInfo? currentOnDeserializing = null;
+                MethodInfo? currentOnDeserialized = null;
+                MethodInfo? currentOnError = null;
+
+                bool skipSerializing = ShouldSkipSerializing(baseType);
+                bool skipDeserialized = ShouldSkipDeserialized(baseType);
+
+                foreach (MethodInfo method in baseType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
+                {
+                    // compact framework errors when getting parameters for a generic method
+                    // lame, but generic methods should not be callbacks anyway
+                    if (method.ContainsGenericParameters)
+                    {
+                        continue;
+                    }
+
+                    Type? prevAttributeType = null;
+                    ParameterInfo[] parameters = method.GetParameters();
+
+                    if (!skipSerializing && IsValidCallback(method, parameters, typeof(OnSerializingAttribute), currentOnSerializing, ref prevAttributeType))
+                    {
+                        onSerializing = onSerializing ?? new List<SerializationCallback>();
+                        onSerializing.Add(JsonContract.CreateSerializationCallback(method));
+                        currentOnSerializing = method;
+                    }
+                    if (IsValidCallback(method, parameters, typeof(OnSerializedAttribute), currentOnSerialized, ref prevAttributeType))
+                    {
+                        onSerialized = onSerialized ?? new List<SerializationCallback>();
+                        onSerialized.Add(JsonContract.CreateSerializationCallback(method));
+                        currentOnSerialized = method;
+                    }
+                    if (IsValidCallback(method, parameters, typeof(OnDeserializingAttribute), currentOnDeserializing, ref prevAttributeType))
+                    {
+                        onDeserializing = onDeserializing ?? new List<SerializationCallback>();
+                        onDeserializing.Add(JsonContract.CreateSerializationCallback(method));
+                        currentOnDeserializing = method;
+                    }
+                    if (!skipDeserialized && IsValidCallback(method, parameters, typeof(OnDeserializedAttribute), currentOnDeserialized, ref prevAttributeType))
+                    {
+                        onDeserialized = onDeserialized ?? new List<SerializationCallback>();
+                        onDeserialized.Add(JsonContract.CreateSerializationCallback(method));
+                        currentOnDeserialized = method;
+                    }
+                    if (IsValidCallback(method, parameters, typeof(OnErrorAttribute), currentOnError, ref prevAttributeType))
+                    {
+                        onError = onError ?? new List<SerializationErrorCallback>();
+                        onError.Add(JsonContract.CreateSerializationErrorCallback(method));
+                        currentOnError = method;
+                    }
+                }
+            }
+        }
+
+        private static bool IsConcurrentOrObservableCollection(Type t)
+        {
+            if (t.IsGenericType())
+            {
+                Type definition = t.GetGenericTypeDefinition();
+
+                switch (definition.FullName)
+                {
+                    case "System.Collections.Concurrent.ConcurrentQueue`1":
+                    case "System.Collections.Concurrent.ConcurrentStack`1":
+                    case "System.Collections.Concurrent.ConcurrentBag`1":
+                    case JsonTypeReflector.ConcurrentDictionaryTypeName:
+                    case "System.Collections.ObjectModel.ObservableCollection`1":
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool ShouldSkipDeserialized(Type t)
+        {
+            // ConcurrentDictionary throws an error in its OnDeserialized so ignore - http://json.codeplex.com/discussions/257093
+            if (IsConcurrentOrObservableCollection(t))
+            {
+                return true;
+            }
+
+#if HAVE_FSHARP_TYPES
+            if (t.Name == FSharpUtils.FSharpSetTypeName || t.Name == FSharpUtils.FSharpMapTypeName)
+            {
+                return true;
+            }
+#endif
+
+            return false;
+        }
+
+        private static bool ShouldSkipSerializing(Type t)
+        {
+            if (IsConcurrentOrObservableCollection(t))
+            {
+                return true;
+            }
+
+#if HAVE_FSHARP_TYPES
+            if (t.Name == FSharpUtils.FSharpSetTypeName || t.Name == FSharpUtils.FSharpMapTypeName)
+            {
+                return true;
+            }
+#endif
+
+            return false;
+        }
+
+        private List<Type> GetClassHierarchyForType(Type type)
+        {
+            List<Type> ret = new List<Type>();
+
+            Type current = type;
+            while (current != null && current != typeof(object))
+            {
+                ret.Add(current);
+                current = current.BaseType();
+            }
+
+            // Return the class list in order of simple => complex
+            ret.Reverse();
+            return ret;
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JsonDictionaryContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonDictionaryContract"/> for the given type.</returns>
+        protected virtual JsonDictionaryContract CreateDictionaryContract(Type objectType)
+        {
+            JsonDictionaryContract contract = new JsonDictionaryContract(objectType);
+            InitializeContract(contract);
+
+            JsonContainerAttribute? containerAttribute = JsonTypeReflector.GetAttribute<JsonContainerAttribute>(objectType);
+            if (containerAttribute?.NamingStrategyType != null)
+            {
+                NamingStrategy namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(containerAttribute)!;
+                contract.DictionaryKeyResolver = s => namingStrategy.GetDictionaryKey(s);
+            }
+            else
+            {
+                contract.DictionaryKeyResolver = ResolveDictionaryKey;
+            }
+
+            ConstructorInfo? overrideConstructor = GetAttributeConstructor(contract.NonNullableUnderlyingType);
+
+            if (overrideConstructor != null)
+            {
+                ParameterInfo[] parameters = overrideConstructor.GetParameters();
+                Type expectedParameterType = (contract.DictionaryKeyType != null && contract.DictionaryValueType != null)
+                    ? typeof(IEnumerable<>).MakeGenericType(typeof(KeyValuePair<,>).MakeGenericType(contract.DictionaryKeyType, contract.DictionaryValueType))
+                    : typeof(IDictionary);
+
+                if (parameters.Length == 0)
+                {
+                    contract.HasParameterizedCreator = false;
+                }
+                else if (parameters.Length == 1 && expectedParameterType.IsAssignableFrom(parameters[0].ParameterType))
+                {
+                    contract.HasParameterizedCreator = true;
+                }
+                else
+                {
+                    throw new JsonException("Constructor for '{0}' must have no parameters or a single parameter that implements '{1}'.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType, expectedParameterType));
+                }
+
+                contract.OverrideCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(overrideConstructor);
+            }
+
+            return contract;
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JsonArrayContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonArrayContract"/> for the given type.</returns>
+        protected virtual JsonArrayContract CreateArrayContract(Type objectType)
+        {
+            JsonArrayContract contract = new JsonArrayContract(objectType);
+            InitializeContract(contract);
+
+            ConstructorInfo? overrideConstructor = GetAttributeConstructor(contract.NonNullableUnderlyingType);
+
+            if (overrideConstructor != null)
+            {
+                ParameterInfo[] parameters = overrideConstructor.GetParameters();
+                Type expectedParameterType = (contract.CollectionItemType != null)
+                    ? typeof(IEnumerable<>).MakeGenericType(contract.CollectionItemType)
+                    : typeof(IEnumerable);
+
+                if (parameters.Length == 0)
+                {
+                    contract.HasParameterizedCreator = false;
+                }
+                else if (parameters.Length == 1 && expectedParameterType.IsAssignableFrom(parameters[0].ParameterType))
+                {
+                    contract.HasParameterizedCreator = true;
+                }
+                else
+                {
+                    throw new JsonException("Constructor for '{0}' must have no parameters or a single parameter that implements '{1}'.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType, expectedParameterType));
+                }
+
+                contract.OverrideCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(overrideConstructor);
+            }
+
+            return contract;
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JsonPrimitiveContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonPrimitiveContract"/> for the given type.</returns>
+        protected virtual JsonPrimitiveContract CreatePrimitiveContract(Type objectType)
+        {
+            JsonPrimitiveContract contract = new JsonPrimitiveContract(objectType);
+            InitializeContract(contract);
+
+            return contract;
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JsonLinqContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonLinqContract"/> for the given type.</returns>
+        protected virtual JsonLinqContract CreateLinqContract(Type objectType)
+        {
+            JsonLinqContract contract = new JsonLinqContract(objectType);
+            InitializeContract(contract);
+
+            return contract;
+        }
+
+#if HAVE_BINARY_SERIALIZATION
+        /// <summary>
+        /// Creates a <see cref="JsonISerializableContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonISerializableContract"/> for the given type.</returns>
+        protected virtual JsonISerializableContract CreateISerializableContract(Type objectType)
+        {
+            JsonISerializableContract contract = new JsonISerializableContract(objectType);
+            InitializeContract(contract);
+
+            if (contract.IsInstantiable)
+            {
+                ConstructorInfo constructorInfo = contract.NonNullableUnderlyingType.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new[] {typeof(SerializationInfo), typeof(StreamingContext)}, null);
+                if (constructorInfo != null)
+                {
+                    ObjectConstructor<object> creator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(constructorInfo);
+
+                    contract.ISerializableCreator = creator;
+                }
+            }
+
+            return contract;
+        }
+#endif
+
+#if HAVE_DYNAMIC
+        /// <summary>
+        /// Creates a <see cref="JsonDynamicContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonDynamicContract"/> for the given type.</returns>
+        protected virtual JsonDynamicContract CreateDynamicContract(Type objectType)
+        {
+            JsonDynamicContract contract = new JsonDynamicContract(objectType);
+            InitializeContract(contract);
+
+            JsonContainerAttribute? containerAttribute = JsonTypeReflector.GetAttribute<JsonContainerAttribute>(objectType);
+            if (containerAttribute?.NamingStrategyType != null)
+            {
+                NamingStrategy namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(containerAttribute)!;
+                contract.PropertyNameResolver = s => namingStrategy.GetDictionaryKey(s);
+            }
+            else
+            {
+                contract.PropertyNameResolver = ResolveDictionaryKey;
+            }
+
+            contract.Properties.AddRange(CreateProperties(objectType, MemberSerialization.OptOut));
+
+            return contract;
+        }
+#endif
+
+        /// <summary>
+        /// Creates a <see cref="JsonStringContract"/> for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonStringContract"/> for the given type.</returns>
+        protected virtual JsonStringContract CreateStringContract(Type objectType)
+        {
+            JsonStringContract contract = new JsonStringContract(objectType);
+            InitializeContract(contract);
+
+            return contract;
+        }
+
+        /// <summary>
+        /// Determines which contract type is created for the given type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>A <see cref="JsonContract"/> for the given type.</returns>
+        protected virtual JsonContract CreateContract(Type objectType)
+        {
+            Type t = ReflectionUtils.EnsureNotByRefType(objectType);
+
+            if (IsJsonPrimitiveType(t))
+            {
+                return CreatePrimitiveContract(objectType);
+            }
+
+            t = ReflectionUtils.EnsureNotNullableType(t);
+            JsonContainerAttribute? containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(t);
+
+            if (containerAttribute is JsonObjectAttribute)
+            {
+                return CreateObjectContract(objectType);
+            }
+
+            if (containerAttribute is JsonArrayAttribute)
+            {
+                return CreateArrayContract(objectType);
+            }
+
+            if (containerAttribute is JsonDictionaryAttribute)
+            {
+                return CreateDictionaryContract(objectType);
+            }
+
+            if (t == typeof(JToken) || t.IsSubclassOf(typeof(JToken)))
+            {
+                return CreateLinqContract(objectType);
+            }
+
+            if (CollectionUtils.IsDictionaryType(t))
+            {
+                return CreateDictionaryContract(objectType);
+            }
+
+            if (typeof(IEnumerable).IsAssignableFrom(t))
+            {
+                return CreateArrayContract(objectType);
+            }
+
+            if (CanConvertToString(t))
+            {
+                return CreateStringContract(objectType);
+            }
+
+#if HAVE_BINARY_SERIALIZATION
+            if (!IgnoreSerializableInterface && typeof(ISerializable).IsAssignableFrom(t) && JsonTypeReflector.IsSerializable(t))
+            {
+                return CreateISerializableContract(objectType);
+            }
+#endif
+
+#if HAVE_DYNAMIC
+            if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(t))
+            {
+                return CreateDynamicContract(objectType);
+            }
+#endif
+
+#if HAVE_ICONVERTIBLE
+            // tested last because it is not possible to automatically deserialize custom IConvertible types
+            if (IsIConvertible(t))
+            {
+                return CreatePrimitiveContract(t);
+            }
+#endif
+
+            return CreateObjectContract(objectType);
+        }
+
+        internal static bool IsJsonPrimitiveType(Type t)
+        {
+            PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(t);
+
+            return (typeCode != PrimitiveTypeCode.Empty && typeCode != PrimitiveTypeCode.Object);
+        }
+
+#if HAVE_ICONVERTIBLE
+        internal static bool IsIConvertible(Type t)
+        {
+            if (typeof(IConvertible).IsAssignableFrom(t)
+                || (ReflectionUtils.IsNullableType(t) && typeof(IConvertible).IsAssignableFrom(Nullable.GetUnderlyingType(t))))
+            {
+                return !typeof(JToken).IsAssignableFrom(t);
+            }
+
+            return false;
+        }
+#endif
+
+        internal static bool CanConvertToString(Type type)
+        {
+#if HAVE_TYPE_DESCRIPTOR
+            if (JsonTypeReflector.CanTypeDescriptorConvertString(type, out _))
+            {
+                return true;
+            }
+#endif
+
+            if (type == typeof(Type) || type.IsSubclassOf(typeof(Type)))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private static bool IsValidCallback(MethodInfo method, ParameterInfo[] parameters, Type attributeType, MethodInfo? currentCallback, ref Type? prevAttributeType)
+        {
+            if (!method.IsDefined(attributeType, false))
+            {
+                return false;
+            }
+
+            if (currentCallback != null)
+            {
+                throw new JsonException("Invalid attribute. Both '{0}' and '{1}' in type '{2}' have '{3}'.".FormatWith(CultureInfo.InvariantCulture, method, currentCallback, GetClrTypeFullName(method.DeclaringType), attributeType));
+            }
+
+            if (prevAttributeType != null)
+            {
+                throw new JsonException("Invalid Callback. Method '{3}' in type '{2}' has both '{0}' and '{1}'.".FormatWith(CultureInfo.InvariantCulture, prevAttributeType, attributeType, GetClrTypeFullName(method.DeclaringType), method));
+            }
+
+            if (method.IsVirtual)
+            {
+                throw new JsonException("Virtual Method '{0}' of type '{1}' cannot be marked with '{2}' attribute.".FormatWith(CultureInfo.InvariantCulture, method, GetClrTypeFullName(method.DeclaringType), attributeType));
+            }
+
+            if (method.ReturnType != typeof(void))
+            {
+                throw new JsonException("Serialization Callback '{1}' in type '{0}' must return void.".FormatWith(CultureInfo.InvariantCulture, GetClrTypeFullName(method.DeclaringType), method));
+            }
+
+            if (attributeType == typeof(OnErrorAttribute))
+            {
+                if (parameters == null || parameters.Length != 2 || parameters[0].ParameterType != typeof(StreamingContext) || parameters[1].ParameterType != typeof(ErrorContext))
+                {
+                    throw new JsonException("Serialization Error Callback '{1}' in type '{0}' must have two parameters of type '{2}' and '{3}'.".FormatWith(CultureInfo.InvariantCulture, GetClrTypeFullName(method.DeclaringType), method, typeof(StreamingContext), typeof(ErrorContext)));
+                }
+            }
+            else
+            {
+                if (parameters == null || parameters.Length != 1 || parameters[0].ParameterType != typeof(StreamingContext))
+                {
+                    throw new JsonException("Serialization Callback '{1}' in type '{0}' must have a single parameter of type '{2}'.".FormatWith(CultureInfo.InvariantCulture, GetClrTypeFullName(method.DeclaringType), method, typeof(StreamingContext)));
+                }
+            }
+
+            prevAttributeType = attributeType;
+
+            return true;
+        }
+
+        internal static string GetClrTypeFullName(Type type)
+        {
+            if (type.IsGenericTypeDefinition() || !type.ContainsGenericParameters())
+            {
+                return type.FullName;
+            }
+
+            return "{0}.{1}".FormatWith(CultureInfo.InvariantCulture, type.Namespace, type.Name);
+        }
+
+        /// <summary>
+        /// Creates properties for the given <see cref="JsonContract"/>.
+        /// </summary>
+        /// <param name="type">The type to create properties for.</param>
+        /// /// <param name="memberSerialization">The member serialization mode for the type.</param>
+        /// <returns>Properties for the given <see cref="JsonContract"/>.</returns>
+        protected virtual IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
+        {
+            List<MemberInfo> members = GetSerializableMembers(type);
+            if (members == null)
+            {
+                throw new JsonSerializationException("Null collection of serializable members returned.");
+            }
+
+            DefaultJsonNameTable nameTable = GetNameTable();
+
+            JsonPropertyCollection properties = new JsonPropertyCollection(type);
+
+            foreach (MemberInfo member in members)
+            {
+                JsonProperty property = CreateProperty(member, memberSerialization);
+
+                if (property != null)
+                {
+                    // nametable is not thread-safe for multiple writers
+                    lock (nameTable)
+                    {
+                        property.PropertyName = nameTable.Add(property.PropertyName!);
+                    }
+
+                    properties.AddProperty(property);
+                }
+            }
+
+            IList<JsonProperty> orderedProperties = properties.OrderBy(p => p.Order ?? -1).ToList();
+            return orderedProperties;
+        }
+
+        internal virtual DefaultJsonNameTable GetNameTable()
+        {
+            return _nameTable;
+        }
+
+        /// <summary>
+        /// Creates the <see cref="IValueProvider"/> used by the serializer to get and set values from a member.
+        /// </summary>
+        /// <param name="member">The member.</param>
+        /// <returns>The <see cref="IValueProvider"/> used by the serializer to get and set values from a member.</returns>
+        protected virtual IValueProvider CreateMemberValueProvider(MemberInfo member)
+        {
+            // warning - this method use to cause errors with Intellitrace. Retest in VS Ultimate after changes
+            IValueProvider valueProvider;
+
+#if !(PORTABLE40 || PORTABLE || DOTNET || NETSTANDARD2_0)
+            if (DynamicCodeGeneration)
+            {
+                valueProvider = new DynamicValueProvider(member);
+            }
+            else
+            {
+                valueProvider = new ReflectionValueProvider(member);
+            }
+#elif !(PORTABLE40)
+            valueProvider = new ExpressionValueProvider(member);
+#else
+            valueProvider = new ReflectionValueProvider(member);
+#endif
+
+            return valueProvider;
+        }
+
+        /// <summary>
+        /// Creates a <see cref="JsonProperty"/> for the given <see cref="MemberInfo"/>.
+        /// </summary>
+        /// <param name="memberSerialization">The member's parent <see cref="MemberSerialization"/>.</param>
+        /// <param name="member">The member to create a <see cref="JsonProperty"/> for.</param>
+        /// <returns>A created <see cref="JsonProperty"/> for the given <see cref="MemberInfo"/>.</returns>
+        protected virtual JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
+        {
+            JsonProperty property = new JsonProperty();
+            property.PropertyType = ReflectionUtils.GetMemberUnderlyingType(member);
+            property.DeclaringType = member.DeclaringType;
+            property.ValueProvider = CreateMemberValueProvider(member);
+            property.AttributeProvider = new ReflectionAttributeProvider(member);
+
+            SetPropertySettingsFromAttributes(property, member, member.Name, member.DeclaringType, memberSerialization, out bool allowNonPublicAccess);
+
+            if (memberSerialization != MemberSerialization.Fields)
+            {
+                property.Readable = ReflectionUtils.CanReadMemberValue(member, allowNonPublicAccess);
+                property.Writable = ReflectionUtils.CanSetMemberValue(member, allowNonPublicAccess, property.HasMemberAttribute);
+            }
+            else
+            {
+                // write to readonly fields
+                property.Readable = true;
+                property.Writable = true;
+            }
+
+            if (!IgnoreShouldSerializeMembers)
+            {
+                property.ShouldSerialize = CreateShouldSerializeTest(member);
+            }
+
+            if (!IgnoreIsSpecifiedMembers)
+            {
+                SetIsSpecifiedActions(property, member, allowNonPublicAccess);
+            }
+
+            return property;
+        }
+
+        private void SetPropertySettingsFromAttributes(JsonProperty property, object attributeProvider, string name, Type declaringType, MemberSerialization memberSerialization, out bool allowNonPublicAccess)
+        {
+#if HAVE_DATA_CONTRACTS
+            DataContractAttribute? dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(declaringType);
+
+            MemberInfo? memberInfo = attributeProvider as MemberInfo;
+
+            DataMemberAttribute? dataMemberAttribute;
+            if (dataContractAttribute != null && memberInfo != null)
+            {
+                dataMemberAttribute = JsonTypeReflector.GetDataMemberAttribute((MemberInfo)memberInfo);
+            }
+            else
+            {
+                dataMemberAttribute = null;
+            }
+#endif
+
+            JsonPropertyAttribute? propertyAttribute = JsonTypeReflector.GetAttribute<JsonPropertyAttribute>(attributeProvider);
+            JsonRequiredAttribute? requiredAttribute = JsonTypeReflector.GetAttribute<JsonRequiredAttribute>(attributeProvider);
+
+            string mappedName;
+            bool hasSpecifiedName;
+            if (propertyAttribute?.PropertyName != null)
+            {
+                mappedName = propertyAttribute.PropertyName;
+                hasSpecifiedName = true;
+            }
+#if HAVE_DATA_CONTRACTS
+            else if (dataMemberAttribute?.Name != null)
+            {
+                mappedName = dataMemberAttribute.Name;
+                hasSpecifiedName = true;
+            }
+#endif
+            else
+            {
+                mappedName = name;
+                hasSpecifiedName = false;
+            }
+
+            JsonContainerAttribute? containerAttribute = JsonTypeReflector.GetAttribute<JsonContainerAttribute>(declaringType);
+
+            NamingStrategy? namingStrategy;
+            if (propertyAttribute?.NamingStrategyType != null)
+            {
+                namingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(propertyAttribute.NamingStrategyType, propertyAttribute.NamingStrategyParameters);
+            }
+            else if (containerAttribute?.NamingStrategyType != null)
+            {
+                namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(containerAttribute);
+            }
+            else
+            {
+                namingStrategy = NamingStrategy;
+            }
+
+            if (namingStrategy != null)
+            {
+                property.PropertyName = namingStrategy.GetPropertyName(mappedName, hasSpecifiedName);
+            }
+            else
+            {
+                property.PropertyName = ResolvePropertyName(mappedName);
+            }
+            
+            property.UnderlyingName = name;
+
+            bool hasMemberAttribute = false;
+            if (propertyAttribute != null)
+            {
+                property._required = propertyAttribute._required;
+                property.Order = propertyAttribute._order;
+                property.DefaultValueHandling = propertyAttribute._defaultValueHandling;
+                hasMemberAttribute = true;
+                property.NullValueHandling = propertyAttribute._nullValueHandling;
+                property.ReferenceLoopHandling = propertyAttribute._referenceLoopHandling;
+                property.ObjectCreationHandling = propertyAttribute._objectCreationHandling;
+                property.TypeNameHandling = propertyAttribute._typeNameHandling;
+                property.IsReference = propertyAttribute._isReference;
+
+                property.ItemIsReference = propertyAttribute._itemIsReference;
+                property.ItemConverter = propertyAttribute.ItemConverterType != null ? JsonTypeReflector.CreateJsonConverterInstance(propertyAttribute.ItemConverterType, propertyAttribute.ItemConverterParameters) : null;
+                property.ItemReferenceLoopHandling = propertyAttribute._itemReferenceLoopHandling;
+                property.ItemTypeNameHandling = propertyAttribute._itemTypeNameHandling;
+            }
+            else
+            {
+                property.NullValueHandling = null;
+                property.ReferenceLoopHandling = null;
+                property.ObjectCreationHandling = null;
+                property.TypeNameHandling = null;
+                property.IsReference = null;
+                property.ItemIsReference = null;
+                property.ItemConverter = null;
+                property.ItemReferenceLoopHandling = null;
+                property.ItemTypeNameHandling = null;
+#if HAVE_DATA_CONTRACTS
+                if (dataMemberAttribute != null)
+                {
+                    property._required = (dataMemberAttribute.IsRequired) ? Required.AllowNull : Required.Default;
+                    property.Order = (dataMemberAttribute.Order != -1) ? (int?)dataMemberAttribute.Order : null;
+                    property.DefaultValueHandling = (!dataMemberAttribute.EmitDefaultValue) ? (DefaultValueHandling?)DefaultValueHandling.Ignore : null;
+                    hasMemberAttribute = true;
+                }
+#endif
+            }
+
+            if (requiredAttribute != null)
+            {
+                property._required = Required.Always;
+                hasMemberAttribute = true;
+            }
+
+            property.HasMemberAttribute = hasMemberAttribute;
+
+            bool hasJsonIgnoreAttribute =
+                JsonTypeReflector.GetAttribute<JsonIgnoreAttribute>(attributeProvider) != null
+                    // automatically ignore extension data dictionary property if it is public
+                || JsonTypeReflector.GetAttribute<JsonExtensionDataAttribute>(attributeProvider) != null
+#if HAVE_NON_SERIALIZED_ATTRIBUTE
+                || JsonTypeReflector.IsNonSerializable(attributeProvider)
+#endif
+                ;
+
+            if (memberSerialization != MemberSerialization.OptIn)
+            {
+                bool hasIgnoreDataMemberAttribute = false;
+
+#if HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE
+                hasIgnoreDataMemberAttribute = (JsonTypeReflector.GetAttribute<IgnoreDataMemberAttribute>(attributeProvider) != null);
+#endif
+
+                // ignored if it has JsonIgnore or NonSerialized or IgnoreDataMember attributes
+                property.Ignored = (hasJsonIgnoreAttribute || hasIgnoreDataMemberAttribute);
+            }
+            else
+            {
+                // ignored if it has JsonIgnore/NonSerialized or does not have DataMember or JsonProperty attributes
+                property.Ignored = (hasJsonIgnoreAttribute || !hasMemberAttribute);
+            }
+
+            // resolve converter for property
+            // the class type might have a converter but the property converter takes precedence
+            property.Converter = JsonTypeReflector.GetJsonConverter(attributeProvider);
+
+            DefaultValueAttribute? defaultValueAttribute = JsonTypeReflector.GetAttribute<DefaultValueAttribute>(attributeProvider);
+            if (defaultValueAttribute != null)
+            {
+                property.DefaultValue = defaultValueAttribute.Value;
+            }
+
+            allowNonPublicAccess = false;
+#pragma warning disable 618
+            if ((DefaultMembersSearchFlags & BindingFlags.NonPublic) == BindingFlags.NonPublic)
+            {
+                allowNonPublicAccess = true;
+            }
+#pragma warning restore 618
+            if (hasMemberAttribute)
+            {
+                allowNonPublicAccess = true;
+            }
+            if (memberSerialization == MemberSerialization.Fields)
+            {
+                allowNonPublicAccess = true;
+            }
+        }
+
+        private Predicate<object>? CreateShouldSerializeTest(MemberInfo member)
+        {
+            MethodInfo shouldSerializeMethod = member.DeclaringType.GetMethod(JsonTypeReflector.ShouldSerializePrefix + member.Name, ReflectionUtils.EmptyTypes);
+
+            if (shouldSerializeMethod == null || shouldSerializeMethod.ReturnType != typeof(bool))
+            {
+                return null;
+            }
+
+            MethodCall<object, object?> shouldSerializeCall =
+                JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object>(shouldSerializeMethod);
+
+            return o => (bool)shouldSerializeCall(o)!;
+        }
+
+        private void SetIsSpecifiedActions(JsonProperty property, MemberInfo member, bool allowNonPublicAccess)
+        {
+            MemberInfo? specifiedMember = member.DeclaringType.GetProperty(member.Name + JsonTypeReflector.SpecifiedPostfix, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            if (specifiedMember == null)
+            {
+                specifiedMember = member.DeclaringType.GetField(member.Name + JsonTypeReflector.SpecifiedPostfix, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            }
+
+            if (specifiedMember == null || ReflectionUtils.GetMemberUnderlyingType(specifiedMember) != typeof(bool))
+            {
+                return;
+            }
+
+            Func<object, object> specifiedPropertyGet = JsonTypeReflector.ReflectionDelegateFactory.CreateGet<object>(specifiedMember)!;
+
+            property.GetIsSpecified = o => (bool)specifiedPropertyGet(o);
+
+            if (ReflectionUtils.CanSetMemberValue(specifiedMember, allowNonPublicAccess, false))
+            {
+                property.SetIsSpecified = JsonTypeReflector.ReflectionDelegateFactory.CreateSet<object>(specifiedMember);
+            }
+        }
+
+        /// <summary>
+        /// Resolves the name of the property.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <returns>Resolved name of the property.</returns>
+        protected virtual string ResolvePropertyName(string propertyName)
+        {
+            if (NamingStrategy != null)
+            {
+                return NamingStrategy.GetPropertyName(propertyName, false);
+            }
+
+            return propertyName;
+        }
+
+        /// <summary>
+        /// Resolves the name of the extension data. By default no changes are made to extension data names.
+        /// </summary>
+        /// <param name="extensionDataName">Name of the extension data.</param>
+        /// <returns>Resolved name of the extension data.</returns>
+        protected virtual string ResolveExtensionDataName(string extensionDataName)
+        {
+            if (NamingStrategy != null)
+            {
+                return NamingStrategy.GetExtensionDataName(extensionDataName);
+            }
+
+            return extensionDataName;
+        }
+
+        /// <summary>
+        /// Resolves the key of the dictionary. By default <see cref="ResolvePropertyName"/> is used to resolve dictionary keys.
+        /// </summary>
+        /// <param name="dictionaryKey">Key of the dictionary.</param>
+        /// <returns>Resolved key of the dictionary.</returns>
+        protected virtual string ResolveDictionaryKey(string dictionaryKey)
+        {
+            if (NamingStrategy != null)
+            {
+                return NamingStrategy.GetDictionaryKey(dictionaryKey);
+            }
+
+            return ResolvePropertyName(dictionaryKey);
+        }
+
+        /// <summary>
+        /// Gets the resolved name of the property.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <returns>Name of the property.</returns>
+        public string GetResolvedPropertyName(string propertyName)
+        {
+            // this is a new method rather than changing the visibility of ResolvePropertyName to avoid
+            // a breaking change for anyone who has overidden the method
+            return ResolvePropertyName(propertyName);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/DefaultNamingStrategy.cs b/Libs/Newtonsoft.Json/Serialization/DefaultNamingStrategy.cs
new file mode 100644
index 0000000..920b27e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/DefaultNamingStrategy.cs
@@ -0,0 +1,18 @@
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// The default naming strategy. Property names and dictionary keys are unchanged.
+    /// </summary>
+    public class DefaultNamingStrategy : NamingStrategy
+    {
+        /// <summary>
+        /// Resolves the specified property name.
+        /// </summary>
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected override string ResolvePropertyName(string name)
+        {
+            return name;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/DefaultReferenceResolver.cs b/Libs/Newtonsoft.Json/Serialization/DefaultReferenceResolver.cs
new file mode 100644
index 0000000..7499bbc
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/DefaultReferenceResolver.cs
@@ -0,0 +1,83 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class DefaultReferenceResolver : IReferenceResolver
+    {
+        private int _referenceCount;
+
+        private BidirectionalDictionary<string, object> GetMappings(object context)
+        {
+            if (!(context is JsonSerializerInternalBase internalSerializer))
+            {
+                if (context is JsonSerializerProxy proxy)
+                {
+                    internalSerializer = proxy.GetInternalSerializer();
+                }
+                else
+                {
+                    throw new JsonException("The DefaultReferenceResolver can only be used internally.");
+                }
+            }
+
+            return internalSerializer.DefaultReferenceMappings;
+        }
+
+        public object ResolveReference(object context, string reference)
+        {
+            GetMappings(context).TryGetByFirst(reference, out object value);
+            return value;
+        }
+
+        public string GetReference(object context, object value)
+        {
+            BidirectionalDictionary<string, object> mappings = GetMappings(context);
+
+            if (!mappings.TryGetBySecond(value, out string reference))
+            {
+                _referenceCount++;
+                reference = _referenceCount.ToString(CultureInfo.InvariantCulture);
+                mappings.Set(reference, value);
+            }
+
+            return reference;
+        }
+
+        public void AddReference(object context, string reference, object value)
+        {
+            GetMappings(context).Set(reference, value);
+        }
+
+        public bool IsReferenced(object context, object value)
+        {
+            return GetMappings(context).TryGetBySecond(value, out _);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/DefaultSerializationBinder.cs b/Libs/Newtonsoft.Json/Serialization/DefaultSerializationBinder.cs
new file mode 100644
index 0000000..6c9e0d6
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/DefaultSerializationBinder.cs
@@ -0,0 +1,215 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Runtime.Serialization;
+using System.Reflection;
+using System.Globalization;
+using LC.Newtonsoft.Json.Utilities;
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// The default serialization binder used when resolving and loading classes from type names.
+    /// </summary>
+    public class DefaultSerializationBinder :
+#pragma warning disable 618
+        SerializationBinder,
+#pragma warning restore 618
+        ISerializationBinder
+    {
+        internal static readonly DefaultSerializationBinder Instance = new DefaultSerializationBinder();
+
+        private readonly ThreadSafeStore<StructMultiKey<string?, string>, Type> _typeCache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultSerializationBinder"/> class.
+        /// </summary>
+        public DefaultSerializationBinder()
+        {
+            _typeCache = new ThreadSafeStore<StructMultiKey<string?, string>, Type>(GetTypeFromTypeNameKey);
+        }
+
+        private Type GetTypeFromTypeNameKey(StructMultiKey<string?, string> typeNameKey)
+        {
+            string? assemblyName = typeNameKey.Value1;
+            string typeName = typeNameKey.Value2;
+
+            if (assemblyName != null)
+            {
+                Assembly assembly;
+
+#if !(DOTNET || PORTABLE40 || PORTABLE)
+                // look, I don't like using obsolete methods as much as you do but this is the only way
+                // Assembly.Load won't check the GAC for a partial name
+#pragma warning disable 618,612
+                assembly = Assembly.LoadWithPartialName(assemblyName);
+#pragma warning restore 618,612
+#elif DOTNET || PORTABLE
+                assembly = Assembly.Load(new AssemblyName(assemblyName));
+#else
+                assembly = Assembly.Load(assemblyName);
+#endif
+
+#if HAVE_APP_DOMAIN
+                if (assembly == null)
+                {
+                    // will find assemblies loaded with Assembly.LoadFile outside of the main directory
+                    Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+                    foreach (Assembly a in loadedAssemblies)
+                    {
+                        // check for both full name or partial name match
+                        if (a.FullName == assemblyName || a.GetName().Name == assemblyName)
+                        {
+                            assembly = a;
+                            break;
+                        }
+                    }
+                }
+#endif
+
+                if (assembly == null)
+                {
+                    throw new JsonSerializationException("Could not load assembly '{0}'.".FormatWith(CultureInfo.InvariantCulture, assemblyName));
+                }
+
+                Type? type = assembly.GetType(typeName);
+                if (type == null)
+                {
+                    // if generic type, try manually parsing the type arguments for the case of dynamically loaded assemblies
+                    // example generic typeName format: System.Collections.Generic.Dictionary`2[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
+                    if (typeName.IndexOf('`') >= 0)
+                    {
+                        try
+                        {
+                            type = GetGenericTypeFromTypeName(typeName, assembly);
+                        }
+                        catch (Exception ex)
+                        {
+                            throw new JsonSerializationException("Could not find type '{0}' in assembly '{1}'.".FormatWith(CultureInfo.InvariantCulture, typeName, assembly.FullName), ex);
+                        }
+                    }
+
+                    if (type == null)
+                    {
+                        throw new JsonSerializationException("Could not find type '{0}' in assembly '{1}'.".FormatWith(CultureInfo.InvariantCulture, typeName, assembly.FullName));
+                    }
+                }
+
+                return type;
+            }
+            else
+            {
+                return Type.GetType(typeName);
+            }
+        }
+
+        private Type? GetGenericTypeFromTypeName(string typeName, Assembly assembly)
+        {
+            Type? type = null;
+            int openBracketIndex = typeName.IndexOf('[');
+            if (openBracketIndex >= 0)
+            {
+                string genericTypeDefName = typeName.Substring(0, openBracketIndex);
+                Type genericTypeDef = assembly.GetType(genericTypeDefName);
+                if (genericTypeDef != null)
+                {
+                    List<Type> genericTypeArguments = new List<Type>();
+                    int scope = 0;
+                    int typeArgStartIndex = 0;
+                    int endIndex = typeName.Length - 1;
+                    for (int i = openBracketIndex + 1; i < endIndex; ++i)
+                    {
+                        char current = typeName[i];
+                        switch (current)
+                        {
+                            case '[':
+                                if (scope == 0)
+                                {
+                                    typeArgStartIndex = i + 1;
+                                }
+                                ++scope;
+                                break;
+                            case ']':
+                                --scope;
+                                if (scope == 0)
+                                {
+                                    string typeArgAssemblyQualifiedName = typeName.Substring(typeArgStartIndex, i - typeArgStartIndex);
+
+                                    StructMultiKey<string?, string> typeNameKey = ReflectionUtils.SplitFullyQualifiedTypeName(typeArgAssemblyQualifiedName);
+                                    genericTypeArguments.Add(GetTypeByName(typeNameKey));
+                                }
+                                break;
+                        }
+                    }
+
+                    type = genericTypeDef.MakeGenericType(genericTypeArguments.ToArray());
+                }
+            }
+
+            return type;
+        }
+
+        private Type GetTypeByName(StructMultiKey<string?, string> typeNameKey)
+        {
+            return _typeCache.Get(typeNameKey);
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, controls the binding of a serialized object to a type.
+        /// </summary>
+        /// <param name="assemblyName">Specifies the <see cref="Assembly"/> name of the serialized object.</param>
+        /// <param name="typeName">Specifies the <see cref="System.Type"/> name of the serialized object.</param>
+        /// <returns>
+        /// The type of the object the formatter creates a new instance of.
+        /// </returns>
+        public override Type BindToType(string? assemblyName, string typeName)
+        {
+            return GetTypeByName(new StructMultiKey<string?, string>(assemblyName, typeName));
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, controls the binding of a serialized object to a type.
+        /// </summary>
+        /// <param name="serializedType">The type of the object the formatter creates a new instance of.</param>
+        /// <param name="assemblyName">Specifies the <see cref="Assembly"/> name of the serialized object.</param>
+        /// <param name="typeName">Specifies the <see cref="System.Type"/> name of the serialized object.</param>
+        public
+#if HAVE_SERIALIZATION_BINDER_BIND_TO_NAME
+        override
+#endif
+        void BindToName(Type serializedType, out string? assemblyName, out string? typeName)
+        {
+#if !HAVE_FULL_REFLECTION
+            assemblyName = serializedType.GetTypeInfo().Assembly.FullName;
+            typeName = serializedType.FullName;
+#else
+            assemblyName = serializedType.Assembly.FullName;
+            typeName = serializedType.FullName;
+#endif
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/DiagnosticsTraceWriter.cs b/Libs/Newtonsoft.Json/Serialization/DiagnosticsTraceWriter.cs
new file mode 100644
index 0000000..d8047ba
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/DiagnosticsTraceWriter.cs
@@ -0,0 +1,79 @@
+#if HAVE_TRACE_WRITER
+using System;
+using System.Diagnostics;
+using DiagnosticsTrace = System.Diagnostics.Trace;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Represents a trace writer that writes to the application's <see cref="TraceListener"/> instances.
+    /// </summary>
+    public class DiagnosticsTraceWriter : ITraceWriter
+    {
+        /// <summary>
+        /// Gets the <see cref="TraceLevel"/> that will be used to filter the trace messages passed to the writer.
+        /// For example a filter level of <see cref="TraceLevel.Info"/> will exclude <see cref="TraceLevel.Verbose"/> messages and include <see cref="TraceLevel.Info"/>,
+        /// <see cref="TraceLevel.Warning"/> and <see cref="TraceLevel.Error"/> messages.
+        /// </summary>
+        /// <value>
+        /// The <see cref="TraceLevel"/> that will be used to filter the trace messages passed to the writer.
+        /// </value>
+        public TraceLevel LevelFilter { get; set; }
+
+        private TraceEventType GetTraceEventType(TraceLevel level)
+        {
+            switch (level)
+            {
+                case TraceLevel.Error:
+                    return TraceEventType.Error;
+                case TraceLevel.Warning:
+                    return TraceEventType.Warning;
+                case TraceLevel.Info:
+                    return TraceEventType.Information;
+                case TraceLevel.Verbose:
+                    return TraceEventType.Verbose;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(level));
+            }
+        }
+
+        /// <summary>
+        /// Writes the specified trace level, message and optional exception.
+        /// </summary>
+        /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param>
+        /// <param name="message">The trace message.</param>
+        /// <param name="ex">The trace exception. This parameter is optional.</param>
+        public void Trace(TraceLevel level, string message, Exception? ex)
+        {
+            if (level == TraceLevel.Off)
+            {
+                return;
+            }
+
+            TraceEventCache eventCache = new TraceEventCache();
+            TraceEventType traceEventType = GetTraceEventType(level);
+
+            foreach (TraceListener listener in DiagnosticsTrace.Listeners)
+            {
+                if (!listener.IsThreadSafe)
+                {
+                    lock (listener)
+                    {
+                        listener.TraceEvent(eventCache, "Newtonsoft.Json", traceEventType, 0, message);
+                    }
+                }
+                else
+                {
+                    listener.TraceEvent(eventCache, "Newtonsoft.Json", traceEventType, 0, message);
+                }
+
+                if (DiagnosticsTrace.AutoFlush)
+                {
+                    listener.Flush();
+                }
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/DynamicValueProvider.cs b/Libs/Newtonsoft.Json/Serialization/DynamicValueProvider.cs
new file mode 100644
index 0000000..9840d98
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/DynamicValueProvider.cs
@@ -0,0 +1,120 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_REFLECTION_EMIT
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+using System.Text;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Get and set values for a <see cref="MemberInfo"/> using dynamic methods.
+    /// </summary>
+    public class DynamicValueProvider : IValueProvider
+    {
+        private readonly MemberInfo _memberInfo;
+        private Func<object, object?>? _getter;
+        private Action<object, object?>? _setter;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DynamicValueProvider"/> class.
+        /// </summary>
+        /// <param name="memberInfo">The member info.</param>
+        public DynamicValueProvider(MemberInfo memberInfo)
+        {
+            ValidationUtils.ArgumentNotNull(memberInfo, nameof(memberInfo));
+            _memberInfo = memberInfo;
+        }
+
+        /// <summary>
+        /// Sets the value.
+        /// </summary>
+        /// <param name="target">The target to set the value on.</param>
+        /// <param name="value">The value to set on the target.</param>
+        public void SetValue(object target, object? value)
+        {
+            try
+            {
+                if (_setter == null)
+                {
+                    _setter = DynamicReflectionDelegateFactory.Instance.CreateSet<object>(_memberInfo);
+                }
+
+#if DEBUG
+                // dynamic method doesn't check whether the type is 'legal' to set
+                // add this check for unit tests
+                if (value == null)
+                {
+                    if (!ReflectionUtils.IsNullable(ReflectionUtils.GetMemberUnderlyingType(_memberInfo)))
+                    {
+                        throw new JsonSerializationException("Incompatible value. Cannot set {0} to null.".FormatWith(CultureInfo.InvariantCulture, _memberInfo));
+                    }
+                }
+                else if (!ReflectionUtils.GetMemberUnderlyingType(_memberInfo).IsAssignableFrom(value.GetType()))
+                {
+                    throw new JsonSerializationException("Incompatible value. Cannot set {0} to type {1}.".FormatWith(CultureInfo.InvariantCulture, _memberInfo, value.GetType()));
+                }
+#endif
+
+                _setter(target, value);
+            }
+            catch (Exception ex)
+            {
+                throw new JsonSerializationException("Error setting value to '{0}' on '{1}'.".FormatWith(CultureInfo.InvariantCulture, _memberInfo.Name, target.GetType()), ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        /// <param name="target">The target to get the value from.</param>
+        /// <returns>The value.</returns>
+        public object? GetValue(object target)
+        {
+            try
+            {
+                if (_getter == null)
+                {
+                    _getter = DynamicReflectionDelegateFactory.Instance.CreateGet<object>(_memberInfo);
+                }
+
+                return _getter(target);
+            }
+            catch (Exception ex)
+            {
+                throw new JsonSerializationException("Error getting value from '{0}' on '{1}'.".FormatWith(CultureInfo.InvariantCulture, _memberInfo.Name, target.GetType()), ex);
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ErrorContext.cs b/Libs/Newtonsoft.Json/Serialization/ErrorContext.cs
new file mode 100644
index 0000000..82c75ec
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ErrorContext.cs
@@ -0,0 +1,75 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Provides information surrounding an error.
+    /// </summary>
+    public class ErrorContext
+    {
+        internal ErrorContext(object? originalObject, object? member, string path, Exception error)
+        {
+            OriginalObject = originalObject;
+            Member = member;
+            Error = error;
+            Path = path;
+        }
+
+        internal bool Traced { get; set; }
+
+        /// <summary>
+        /// Gets the error.
+        /// </summary>
+        /// <value>The error.</value>
+        public Exception Error { get; }
+
+        /// <summary>
+        /// Gets the original object that caused the error.
+        /// </summary>
+        /// <value>The original object that caused the error.</value>
+        public object? OriginalObject { get; }
+
+        /// <summary>
+        /// Gets the member that caused the error.
+        /// </summary>
+        /// <value>The member that caused the error.</value>
+        public object? Member { get; }
+
+        /// <summary>
+        /// Gets the path of the JSON location where the error occurred.
+        /// </summary>
+        /// <value>The path of the JSON location where the error occurred.</value>
+        public string Path { get; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="ErrorContext"/> is handled.
+        /// </summary>
+        /// <value><c>true</c> if handled; otherwise, <c>false</c>.</value>
+        public bool Handled { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ErrorEventArgs.cs b/Libs/Newtonsoft.Json/Serialization/ErrorEventArgs.cs
new file mode 100644
index 0000000..54556a0
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ErrorEventArgs.cs
@@ -0,0 +1,58 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Provides data for the Error event.
+    /// </summary>
+    public class ErrorEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets the current object the error event is being raised against.
+        /// </summary>
+        /// <value>The current object the error event is being raised against.</value>
+        public object? CurrentObject { get; }
+
+        /// <summary>
+        /// Gets the error context.
+        /// </summary>
+        /// <value>The error context.</value>
+        public ErrorContext ErrorContext { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ErrorEventArgs"/> class.
+        /// </summary>
+        /// <param name="currentObject">The current object.</param>
+        /// <param name="errorContext">The error context.</param>
+        public ErrorEventArgs(object? currentObject, ErrorContext errorContext)
+        {
+            CurrentObject = currentObject;
+            ErrorContext = errorContext;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ExpressionValueProvider.cs b/Libs/Newtonsoft.Json/Serialization/ExpressionValueProvider.cs
new file mode 100644
index 0000000..9467e89
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ExpressionValueProvider.cs
@@ -0,0 +1,121 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if !(NET20 || NET35)
+
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+using System.Text;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Get and set values for a <see cref="MemberInfo"/> using dynamic methods.
+    /// </summary>
+    public class ExpressionValueProvider : IValueProvider
+    {
+        private readonly MemberInfo _memberInfo;
+        private Func<object, object?>? _getter;
+        private Action<object, object?>? _setter;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExpressionValueProvider"/> class.
+        /// </summary>
+        /// <param name="memberInfo">The member info.</param>
+        public ExpressionValueProvider(MemberInfo memberInfo)
+        {
+            ValidationUtils.ArgumentNotNull(memberInfo, nameof(memberInfo));
+            _memberInfo = memberInfo;
+        }
+
+        /// <summary>
+        /// Sets the value.
+        /// </summary>
+        /// <param name="target">The target to set the value on.</param>
+        /// <param name="value">The value to set on the target.</param>
+        public void SetValue(object target, object? value)
+        {
+            try
+            {
+                if (_setter == null)
+                {
+                    _setter = ExpressionReflectionDelegateFactory.Instance.CreateSet<object>(_memberInfo);
+                }
+
+#if DEBUG
+                // dynamic method doesn't check whether the type is 'legal' to set
+                // add this check for unit tests
+                if (value == null)
+                {
+                    if (!ReflectionUtils.IsNullable(ReflectionUtils.GetMemberUnderlyingType(_memberInfo)))
+                    {
+                        throw new JsonSerializationException("Incompatible value. Cannot set {0} to null.".FormatWith(CultureInfo.InvariantCulture, _memberInfo));
+                    }
+                }
+                else if (!ReflectionUtils.GetMemberUnderlyingType(_memberInfo).IsAssignableFrom(value.GetType()))
+                {
+                    throw new JsonSerializationException("Incompatible value. Cannot set {0} to type {1}.".FormatWith(CultureInfo.InvariantCulture, _memberInfo, value.GetType()));
+                }
+#endif
+
+                _setter(target, value);
+            }
+            catch (Exception ex)
+            {
+                throw new JsonSerializationException("Error setting value to '{0}' on '{1}'.".FormatWith(CultureInfo.InvariantCulture, _memberInfo.Name, target.GetType()), ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        /// <param name="target">The target to get the value from.</param>
+        /// <returns>The value.</returns>
+        public object? GetValue(object target)
+        {
+            try
+            {
+                if (_getter == null)
+                {
+                    _getter = ExpressionReflectionDelegateFactory.Instance.CreateGet<object>(_memberInfo);
+                }
+
+                return _getter(target);
+            }
+            catch (Exception ex)
+            {
+                throw new JsonSerializationException("Error getting value from '{0}' on '{1}'.".FormatWith(CultureInfo.InvariantCulture, _memberInfo.Name, target.GetType()), ex);
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/FormatterConverter.cs b/Libs/Newtonsoft.Json/Serialization/FormatterConverter.cs
new file mode 100644
index 0000000..47ad70f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/FormatterConverter.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+
+#if HAVE_BINARY_SERIALIZATION && !HAVE_BINARY_FORMATTER
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class FormatterConverter : IFormatterConverter
+    {
+        public object Convert(object value, Type type)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
+        }
+
+        public object Convert(object value, TypeCode typeCode)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ChangeType(value, typeCode, CultureInfo.InvariantCulture);
+        }
+
+        public bool ToBoolean(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToBoolean(value, CultureInfo.InvariantCulture);
+        }
+
+        public byte ToByte(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToByte(value, CultureInfo.InvariantCulture);
+        }
+
+        public char ToChar(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToChar(value, CultureInfo.InvariantCulture);
+        }
+
+        public DateTime ToDateTime(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToDateTime(value, CultureInfo.InvariantCulture);
+        }
+
+        public decimal ToDecimal(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToDecimal(value, CultureInfo.InvariantCulture);
+        }
+
+        public double ToDouble(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToDouble(value, CultureInfo.InvariantCulture);
+        }
+
+        public short ToInt16(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToInt16(value, CultureInfo.InvariantCulture);
+        }
+
+        public int ToInt32(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToInt32(value, CultureInfo.InvariantCulture);
+        }
+
+        public long ToInt64(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToInt64(value, CultureInfo.InvariantCulture);
+        }
+
+        public sbyte ToSByte(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToSByte(value, CultureInfo.InvariantCulture);
+        }
+
+        public float ToSingle(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToSingle(value, CultureInfo.InvariantCulture);
+        }
+
+        public string ToString(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToString(value, CultureInfo.InvariantCulture);
+        }
+
+        public ushort ToUInt16(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToUInt16(value, CultureInfo.InvariantCulture);
+        }
+
+        public uint ToUInt32(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToUInt32(value, CultureInfo.InvariantCulture);
+        }
+
+        public ulong ToUInt64(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+            return System.Convert.ToUInt64(value, CultureInfo.InvariantCulture);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/IAttributeProvider.cs b/Libs/Newtonsoft.Json/Serialization/IAttributeProvider.cs
new file mode 100644
index 0000000..1274533
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/IAttributeProvider.cs
@@ -0,0 +1,51 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Provides methods to get attributes.
+    /// </summary>
+    public interface IAttributeProvider
+    {
+        /// <summary>
+        /// Returns a collection of all of the attributes, or an empty collection if there are no attributes.
+        /// </summary>
+        /// <param name="inherit">When <c>true</c>, look up the hierarchy chain for the inherited custom attribute.</param>
+        /// <returns>A collection of <see cref="Attribute"/>s, or an empty collection.</returns>
+        IList<Attribute> GetAttributes(bool inherit);
+
+        /// <summary>
+        /// Returns a collection of attributes, identified by type, or an empty collection if there are no attributes.
+        /// </summary>
+        /// <param name="attributeType">The type of the attributes.</param>
+        /// <param name="inherit">When <c>true</c>, look up the hierarchy chain for the inherited custom attribute.</param>
+        /// <returns>A collection of <see cref="Attribute"/>s, or an empty collection.</returns>
+        IList<Attribute> GetAttributes(Type attributeType, bool inherit);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/IContractResolver.cs b/Libs/Newtonsoft.Json/Serialization/IContractResolver.cs
new file mode 100644
index 0000000..ddd39b1
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/IContractResolver.cs
@@ -0,0 +1,46 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Used by <see cref="JsonSerializer"/> to resolve a <see cref="JsonContract"/> for a given <see cref="Type"/>.
+    /// </summary>
+    /// <example>
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="ReducingSerializedJsonSizeContractResolverObject" title="IContractResolver Class" />
+    ///   <code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="ReducingSerializedJsonSizeContractResolverExample" title="IContractResolver Example" />
+    /// </example>
+    public interface IContractResolver
+    {
+        /// <summary>
+        /// Resolves the contract for a given type.
+        /// </summary>
+        /// <param name="type">The type to resolve a contract for.</param>
+        /// <returns>The contract for a given type.</returns>
+        JsonContract ResolveContract(Type type);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/IReferenceResolver.cs b/Libs/Newtonsoft.Json/Serialization/IReferenceResolver.cs
new file mode 100644
index 0000000..ae9a5bd
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/IReferenceResolver.cs
@@ -0,0 +1,67 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Used to resolve references when serializing and deserializing JSON by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public interface IReferenceResolver
+    {
+        /// <summary>
+        /// Resolves a reference to its object.
+        /// </summary>
+        /// <param name="context">The serialization context.</param>
+        /// <param name="reference">The reference to resolve.</param>
+        /// <returns>The object that was resolved from the reference.</returns>
+        object ResolveReference(object context, string reference);
+
+        /// <summary>
+        /// Gets the reference for the specified object.
+        /// </summary>
+        /// <param name="context">The serialization context.</param>
+        /// <param name="value">The object to get a reference for.</param>
+        /// <returns>The reference to the object.</returns>
+        string GetReference(object context, object value);
+
+        /// <summary>
+        /// Determines whether the specified object is referenced.
+        /// </summary>
+        /// <param name="context">The serialization context.</param>
+        /// <param name="value">The object to test for a reference.</param>
+        /// <returns>
+        /// 	<c>true</c> if the specified object is referenced; otherwise, <c>false</c>.
+        /// </returns>
+        bool IsReferenced(object context, object value);
+
+        /// <summary>
+        /// Adds a reference to the specified object.
+        /// </summary>
+        /// <param name="context">The serialization context.</param>
+        /// <param name="reference">The reference.</param>
+        /// <param name="value">The object to reference.</param>
+        void AddReference(object context, string reference, object value);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ISerializationBinder.cs b/Libs/Newtonsoft.Json/Serialization/ISerializationBinder.cs
new file mode 100644
index 0000000..c4f3984
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ISerializationBinder.cs
@@ -0,0 +1,53 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Reflection;
+using System.Runtime.Serialization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Allows users to control class loading and mandate what class to load.
+    /// </summary>
+    public interface ISerializationBinder
+    {
+        /// <summary>
+        /// When implemented, controls the binding of a serialized object to a type.
+        /// </summary>
+        /// <param name="assemblyName">Specifies the <see cref="Assembly"/> name of the serialized object.</param>
+        /// <param name="typeName">Specifies the <see cref="System.Type"/> name of the serialized object</param>
+        /// <returns>The type of the object the formatter creates a new instance of.</returns>
+        Type BindToType(string? assemblyName, string typeName);
+
+        /// <summary>
+        /// When implemented, controls the binding of a serialized object to a type.
+        /// </summary>
+        /// <param name="serializedType">The type of the object the formatter creates a new instance of.</param>
+        /// <param name="assemblyName">Specifies the <see cref="Assembly"/> name of the serialized object.</param>
+        /// <param name="typeName">Specifies the <see cref="System.Type"/> name of the serialized object.</param>
+        void BindToName(Type serializedType, out string? assemblyName, out string? typeName);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ITraceWriter.cs b/Libs/Newtonsoft.Json/Serialization/ITraceWriter.cs
new file mode 100644
index 0000000..b29ad68
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ITraceWriter.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Represents a trace writer.
+    /// </summary>
+    public interface ITraceWriter
+    {
+        /// <summary>
+        /// Gets the <see cref="TraceLevel"/> that will be used to filter the trace messages passed to the writer.
+        /// For example a filter level of <see cref="TraceLevel.Info"/> will exclude <see cref="TraceLevel.Verbose"/> messages and include <see cref="TraceLevel.Info"/>,
+        /// <see cref="TraceLevel.Warning"/> and <see cref="TraceLevel.Error"/> messages.
+        /// </summary>
+        /// <value>The <see cref="TraceLevel"/> that will be used to filter the trace messages passed to the writer.</value>
+        TraceLevel LevelFilter { get; }
+
+        /// <summary>
+        /// Writes the specified trace level, message and optional exception.
+        /// </summary>
+        /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param>
+        /// <param name="message">The trace message.</param>
+        /// <param name="ex">The trace exception. This parameter is optional.</param>
+        void Trace(TraceLevel level, string message, Exception? ex);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/IValueProvider.cs b/Libs/Newtonsoft.Json/Serialization/IValueProvider.cs
new file mode 100644
index 0000000..0f72330
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/IValueProvider.cs
@@ -0,0 +1,47 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Provides methods to get and set values.
+    /// </summary>
+    public interface IValueProvider
+    {
+        /// <summary>
+        /// Sets the value.
+        /// </summary>
+        /// <param name="target">The target to set the value on.</param>
+        /// <param name="value">The value to set on the target.</param>
+        void SetValue(object target, object? value);
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        /// <param name="target">The target to get the value from.</param>
+        /// <returns>The value.</returns>
+        object? GetValue(object target);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonArrayContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonArrayContract.cs
new file mode 100644
index 0000000..6cbf93d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonArrayContract.cs
@@ -0,0 +1,326 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+using System.Collections;
+using System.Diagnostics;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="System.Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonArrayContract : JsonContainerContract
+    {
+        /// <summary>
+        /// Gets the <see cref="System.Type"/> of the collection items.
+        /// </summary>
+        /// <value>The <see cref="System.Type"/> of the collection items.</value>
+        public Type? CollectionItemType { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether the collection type is a multidimensional array.
+        /// </summary>
+        /// <value><c>true</c> if the collection type is a multidimensional array; otherwise, <c>false</c>.</value>
+        public bool IsMultidimensionalArray { get; }
+
+        private readonly Type? _genericCollectionDefinitionType;
+
+        private Type? _genericWrapperType;
+        private ObjectConstructor<object>? _genericWrapperCreator;
+        private Func<object>? _genericTemporaryCollectionCreator;
+
+        internal bool IsArray { get; }
+        internal bool ShouldCreateWrapper { get; }
+        internal bool CanDeserialize { get; private set; }
+
+        private readonly ConstructorInfo? _parameterizedConstructor;
+
+        private ObjectConstructor<object>? _parameterizedCreator;
+        private ObjectConstructor<object>? _overrideCreator;
+
+        internal ObjectConstructor<object>? ParameterizedCreator
+        {
+            get
+            {
+                if (_parameterizedCreator == null && _parameterizedConstructor != null)
+                {
+                    _parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(_parameterizedConstructor);
+                }
+
+                return _parameterizedCreator;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the function used to create the object. When set this function will override <see cref="JsonContract.DefaultCreator"/>.
+        /// </summary>
+        /// <value>The function used to create the object.</value>
+        public ObjectConstructor<object>? OverrideCreator
+        {
+            get => _overrideCreator;
+            set
+            {
+                _overrideCreator = value;
+                // hacky
+                CanDeserialize = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the creator has a parameter with the collection values.
+        /// </summary>
+        /// <value><c>true</c> if the creator has a parameter with the collection values; otherwise, <c>false</c>.</value>
+        public bool HasParameterizedCreator { get; set; }
+
+        internal bool HasParameterizedCreatorInternal => (HasParameterizedCreator || _parameterizedCreator != null || _parameterizedConstructor != null);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonArrayContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonArrayContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.Array;
+
+            // netcoreapp3.0 uses EmptyPartition for empty enumerable. Treat as an empty array.
+            IsArray = CreatedType.IsArray ||
+                (NonNullableUnderlyingType.IsGenericType() && NonNullableUnderlyingType.GetGenericTypeDefinition().FullName == "System.Linq.EmptyPartition`1");
+
+            bool canDeserialize;
+
+            Type? tempCollectionType;
+            if (IsArray)
+            {
+                CollectionItemType = ReflectionUtils.GetCollectionItemType(UnderlyingType);
+                IsReadOnlyOrFixedSize = true;
+                _genericCollectionDefinitionType = typeof(List<>).MakeGenericType(CollectionItemType);
+
+                canDeserialize = true;
+                IsMultidimensionalArray = (CreatedType.IsArray && UnderlyingType.GetArrayRank() > 1);
+            }
+            else if (typeof(IList).IsAssignableFrom(NonNullableUnderlyingType))
+            {
+                if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(ICollection<>), out _genericCollectionDefinitionType))
+                {
+                    CollectionItemType = _genericCollectionDefinitionType.GetGenericArguments()[0];
+                }
+                else
+                {
+                    CollectionItemType = ReflectionUtils.GetCollectionItemType(NonNullableUnderlyingType);
+                }
+
+                if (NonNullableUnderlyingType == typeof(IList))
+                {
+                    CreatedType = typeof(List<object>);
+                }
+
+                if (CollectionItemType != null)
+                {
+                    _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(NonNullableUnderlyingType, CollectionItemType);
+                }
+
+                IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(NonNullableUnderlyingType, typeof(ReadOnlyCollection<>));
+                canDeserialize = true;
+            }
+            else if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(ICollection<>), out _genericCollectionDefinitionType))
+            {
+                CollectionItemType = _genericCollectionDefinitionType.GetGenericArguments()[0];
+
+                if (ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(ICollection<>))
+                    || ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(IList<>)))
+                {
+                    CreatedType = typeof(List<>).MakeGenericType(CollectionItemType);
+                }
+
+#if HAVE_ISET
+                if (ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(ISet<>)))
+                {
+                    CreatedType = typeof(HashSet<>).MakeGenericType(CollectionItemType);
+                }
+#endif
+
+                _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(NonNullableUnderlyingType, CollectionItemType);
+                canDeserialize = true;
+                ShouldCreateWrapper = true;
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(IReadOnlyCollection<>), out tempCollectionType))
+            {
+                CollectionItemType = tempCollectionType.GetGenericArguments()[0];
+
+                if (ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(IReadOnlyCollection<>))
+                    || ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(IReadOnlyList<>)))
+                {
+                    CreatedType = typeof(ReadOnlyCollection<>).MakeGenericType(CollectionItemType);
+                }
+
+                _genericCollectionDefinitionType = typeof(List<>).MakeGenericType(CollectionItemType);
+                _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, CollectionItemType);
+
+#if HAVE_FSHARP_TYPES
+                StoreFSharpListCreatorIfNecessary(NonNullableUnderlyingType);
+#endif
+
+                IsReadOnlyOrFixedSize = true;
+                canDeserialize = HasParameterizedCreatorInternal;
+            }
+#endif
+            else if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(IEnumerable<>), out tempCollectionType))
+            {
+                CollectionItemType = tempCollectionType.GetGenericArguments()[0];
+
+                if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IEnumerable<>)))
+                {
+                    CreatedType = typeof(List<>).MakeGenericType(CollectionItemType);
+                }
+
+                _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(NonNullableUnderlyingType, CollectionItemType);
+
+#if HAVE_FSHARP_TYPES
+                StoreFSharpListCreatorIfNecessary(NonNullableUnderlyingType);
+#endif
+
+                if (NonNullableUnderlyingType.IsGenericType() && NonNullableUnderlyingType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+                {
+                    _genericCollectionDefinitionType = tempCollectionType;
+
+                    IsReadOnlyOrFixedSize = false;
+                    ShouldCreateWrapper = false;
+                    canDeserialize = true;
+                }
+                else
+                {
+                    _genericCollectionDefinitionType = typeof(List<>).MakeGenericType(CollectionItemType);
+
+                    IsReadOnlyOrFixedSize = true;
+                    ShouldCreateWrapper = true;
+                    canDeserialize = HasParameterizedCreatorInternal;
+                }
+            }
+            else
+            {
+                // types that implement IEnumerable and nothing else
+                canDeserialize = false;
+                ShouldCreateWrapper = true;
+            }
+
+            CanDeserialize = canDeserialize;
+
+#if (NET20 || NET35)
+            if (CollectionItemType != null && ReflectionUtils.IsNullableType(CollectionItemType))
+            {
+                // bug in .NET 2.0 & 3.5 that List<Nullable<T>> throws an error when adding null via IList.Add(object)
+                // wrapper will handle calling Add(T) instead
+                if (ReflectionUtils.InheritsGenericDefinition(CreatedType, typeof(List<>), out tempCollectionType)
+                    || (IsArray && !IsMultidimensionalArray))
+                {
+                    ShouldCreateWrapper = true;
+                }
+            }
+#endif
+
+            if (CollectionItemType != null &&
+                ImmutableCollectionsUtils.TryBuildImmutableForArrayContract(
+                NonNullableUnderlyingType,
+                CollectionItemType,
+                out Type? immutableCreatedType,
+                out ObjectConstructor<object>? immutableParameterizedCreator))
+            {
+                CreatedType = immutableCreatedType;
+                _parameterizedCreator = immutableParameterizedCreator;
+                IsReadOnlyOrFixedSize = true;
+                CanDeserialize = true;
+            }
+        }
+
+        internal IWrappedCollection CreateWrapper(object list)
+        {
+            if (_genericWrapperCreator == null)
+            {
+                MiscellaneousUtils.Assert(_genericCollectionDefinitionType != null);
+
+                _genericWrapperType = typeof(CollectionWrapper<>).MakeGenericType(CollectionItemType);
+
+                Type constructorArgument;
+
+                if (ReflectionUtils.InheritsGenericDefinition(_genericCollectionDefinitionType, typeof(List<>))
+                    || _genericCollectionDefinitionType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+                {
+                    constructorArgument = typeof(ICollection<>).MakeGenericType(CollectionItemType);
+                }
+                else
+                {
+                    constructorArgument = _genericCollectionDefinitionType;
+                }
+
+                ConstructorInfo genericWrapperConstructor = _genericWrapperType.GetConstructor(new[] { constructorArgument });
+                _genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(genericWrapperConstructor);
+            }
+
+            return (IWrappedCollection)_genericWrapperCreator(list);
+        }
+
+        internal IList CreateTemporaryCollection()
+        {
+            if (_genericTemporaryCollectionCreator == null)
+            {
+                // multidimensional array will also have array instances in it
+                Type collectionItemType = (IsMultidimensionalArray || CollectionItemType == null)
+                    ? typeof(object)
+                    : CollectionItemType;
+
+                Type temporaryListType = typeof(List<>).MakeGenericType(collectionItemType);
+                _genericTemporaryCollectionCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateDefaultConstructor<object>(temporaryListType);
+            }
+
+            return (IList)_genericTemporaryCollectionCreator();
+        }
+
+#if HAVE_FSHARP_TYPES
+        private void StoreFSharpListCreatorIfNecessary(Type underlyingType)
+        {
+            if (!HasParameterizedCreatorInternal && underlyingType.Name == FSharpUtils.FSharpListTypeName)
+            {
+                FSharpUtils.EnsureInitialized(underlyingType.Assembly());
+                _parameterizedCreator = FSharpUtils.Instance.CreateSeq(CollectionItemType!);
+            }
+        }
+#endif
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonContainerContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonContainerContract.cs
new file mode 100644
index 0000000..826b027
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonContainerContract.cs
@@ -0,0 +1,117 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+using System.Collections;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="System.Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonContainerContract : JsonContract
+    {
+        private JsonContract? _itemContract;
+        private JsonContract? _finalItemContract;
+
+        // will be null for containers that don't have an item type (e.g. IList) or for complex objects
+        internal JsonContract? ItemContract
+        {
+            get => _itemContract;
+            set
+            {
+                _itemContract = value;
+                if (_itemContract != null)
+                {
+                    _finalItemContract = (_itemContract.UnderlyingType.IsSealed()) ? _itemContract : null;
+                }
+                else
+                {
+                    _finalItemContract = null;
+                }
+            }
+        }
+
+        // the final (i.e. can't be inherited from like a sealed class or valuetype) item contract
+        internal JsonContract? FinalItemContract => _finalItemContract;
+
+        /// <summary>
+        /// Gets or sets the default collection items <see cref="JsonConverter" />.
+        /// </summary>
+        /// <value>The converter.</value>
+        public JsonConverter? ItemConverter { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the collection items preserve object references.
+        /// </summary>
+        /// <value><c>true</c> if collection items preserve object references; otherwise, <c>false</c>.</value>
+        public bool? ItemIsReference { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection item reference loop handling.
+        /// </summary>
+        /// <value>The reference loop handling.</value>
+        public ReferenceLoopHandling? ItemReferenceLoopHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection item type name handling.
+        /// </summary>
+        /// <value>The type name handling.</value>
+        public TypeNameHandling? ItemTypeNameHandling { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonContainerContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        internal JsonContainerContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            JsonContainerAttribute? jsonContainerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(underlyingType);
+
+            if (jsonContainerAttribute != null)
+            {
+                if (jsonContainerAttribute.ItemConverterType != null)
+                {
+                    ItemConverter = JsonTypeReflector.CreateJsonConverterInstance(
+                        jsonContainerAttribute.ItemConverterType,
+                        jsonContainerAttribute.ItemConverterParameters);
+                }
+
+                ItemIsReference = jsonContainerAttribute._itemIsReference;
+                ItemReferenceLoopHandling = jsonContainerAttribute._itemReferenceLoopHandling;
+                ItemTypeNameHandling = jsonContainerAttribute._itemTypeNameHandling;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonContract.cs
new file mode 100644
index 0000000..d0493a0
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonContract.cs
@@ -0,0 +1,326 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.Serialization;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal enum JsonContractType
+    {
+        None = 0,
+        Object = 1,
+        Array = 2,
+        Primitive = 3,
+        String = 4,
+        Dictionary = 5,
+        Dynamic = 6,
+        Serializable = 7,
+        Linq = 8
+    }
+
+    /// <summary>
+    /// Handles <see cref="JsonSerializer"/> serialization callback events.
+    /// </summary>
+    /// <param name="o">The object that raised the callback event.</param>
+    /// <param name="context">The streaming context.</param>
+    public delegate void SerializationCallback(object o, StreamingContext context);
+
+    /// <summary>
+    /// Handles <see cref="JsonSerializer"/> serialization error callback events.
+    /// </summary>
+    /// <param name="o">The object that raised the callback event.</param>
+    /// <param name="context">The streaming context.</param>
+    /// <param name="errorContext">The error context.</param>
+    public delegate void SerializationErrorCallback(object o, StreamingContext context, ErrorContext errorContext);
+
+    /// <summary>
+    /// Sets extension data for an object during deserialization.
+    /// </summary>
+    /// <param name="o">The object to set extension data on.</param>
+    /// <param name="key">The extension data key.</param>
+    /// <param name="value">The extension data value.</param>
+    public delegate void ExtensionDataSetter(object o, string key, object? value);
+
+    /// <summary>
+    /// Gets extension data for an object during serialization.
+    /// </summary>
+    /// <param name="o">The object to set extension data on.</param>
+    public delegate IEnumerable<KeyValuePair<object, object>>? ExtensionDataGetter(object o);
+
+    /// <summary>
+    /// Contract details for a <see cref="System.Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public abstract class JsonContract
+    {
+        internal bool IsNullable;
+        internal bool IsConvertable;
+        internal bool IsEnum;
+        internal Type NonNullableUnderlyingType;
+        internal ReadType InternalReadType;
+        internal JsonContractType ContractType;
+        internal bool IsReadOnlyOrFixedSize;
+        internal bool IsSealed;
+        internal bool IsInstantiable;
+
+        private List<SerializationCallback>? _onDeserializedCallbacks;
+        private List<SerializationCallback>? _onDeserializingCallbacks;
+        private List<SerializationCallback>? _onSerializedCallbacks;
+        private List<SerializationCallback>? _onSerializingCallbacks;
+        private List<SerializationErrorCallback>? _onErrorCallbacks;
+        private Type _createdType;
+
+        /// <summary>
+        /// Gets the underlying type for the contract.
+        /// </summary>
+        /// <value>The underlying type for the contract.</value>
+        public Type UnderlyingType { get; }
+
+        /// <summary>
+        /// Gets or sets the type created during deserialization.
+        /// </summary>
+        /// <value>The type created during deserialization.</value>
+        public Type CreatedType
+        {
+            get => _createdType;
+            set
+            {
+                ValidationUtils.ArgumentNotNull(value, nameof(value));
+                _createdType = value;
+
+                IsSealed = _createdType.IsSealed();
+                IsInstantiable = !(_createdType.IsInterface() || _createdType.IsAbstract());
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets whether this type contract is serialized as a reference.
+        /// </summary>
+        /// <value>Whether this type contract is serialized as a reference.</value>
+        public bool? IsReference { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default <see cref="JsonConverter" /> for this contract.
+        /// </summary>
+        /// <value>The converter.</value>
+        public JsonConverter? Converter { get; set; }
+
+        /// <summary>
+        /// Gets the internally resolved <see cref="JsonConverter"/> for the contract's type.
+        /// This converter is used as a fallback converter when no other converter is resolved.
+        /// Setting <see cref="Converter"/> will always override this converter.
+        /// </summary>
+        public JsonConverter? InternalConverter { get; internal set; }
+
+        /// <summary>
+        /// Gets or sets all methods called immediately after deserialization of the object.
+        /// </summary>
+        /// <value>The methods called immediately after deserialization of the object.</value>
+        public IList<SerializationCallback> OnDeserializedCallbacks
+        {
+            get
+            {
+                if (_onDeserializedCallbacks == null)
+                {
+                    _onDeserializedCallbacks = new List<SerializationCallback>();
+                }
+
+                return _onDeserializedCallbacks;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets all methods called during deserialization of the object.
+        /// </summary>
+        /// <value>The methods called during deserialization of the object.</value>
+        public IList<SerializationCallback> OnDeserializingCallbacks
+        {
+            get
+            {
+                if (_onDeserializingCallbacks == null)
+                {
+                    _onDeserializingCallbacks = new List<SerializationCallback>();
+                }
+
+                return _onDeserializingCallbacks;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets all methods called after serialization of the object graph.
+        /// </summary>
+        /// <value>The methods called after serialization of the object graph.</value>
+        public IList<SerializationCallback> OnSerializedCallbacks
+        {
+            get
+            {
+                if (_onSerializedCallbacks == null)
+                {
+                    _onSerializedCallbacks = new List<SerializationCallback>();
+                }
+
+                return _onSerializedCallbacks;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets all methods called before serialization of the object.
+        /// </summary>
+        /// <value>The methods called before serialization of the object.</value>
+        public IList<SerializationCallback> OnSerializingCallbacks
+        {
+            get
+            {
+                if (_onSerializingCallbacks == null)
+                {
+                    _onSerializingCallbacks = new List<SerializationCallback>();
+                }
+
+                return _onSerializingCallbacks;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets all method called when an error is thrown during the serialization of the object.
+        /// </summary>
+        /// <value>The methods called when an error is thrown during the serialization of the object.</value>
+        public IList<SerializationErrorCallback> OnErrorCallbacks
+        {
+            get
+            {
+                if (_onErrorCallbacks == null)
+                {
+                    _onErrorCallbacks = new List<SerializationErrorCallback>();
+                }
+
+                return _onErrorCallbacks;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the default creator method used to create the object.
+        /// </summary>
+        /// <value>The default creator method used to create the object.</value>
+        public Func<object>? DefaultCreator { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the default creator is non-public.
+        /// </summary>
+        /// <value><c>true</c> if the default object creator is non-public; otherwise, <c>false</c>.</value>
+        public bool DefaultCreatorNonPublic { get; set; }
+
+        internal JsonContract(Type underlyingType)
+        {
+            ValidationUtils.ArgumentNotNull(underlyingType, nameof(underlyingType));
+
+            UnderlyingType = underlyingType;
+
+            // resolve ByRef types
+            // typically comes from in and ref parameters on methods/ctors
+            underlyingType = ReflectionUtils.EnsureNotByRefType(underlyingType);
+
+            IsNullable = ReflectionUtils.IsNullable(underlyingType);
+             
+            NonNullableUnderlyingType = (IsNullable && ReflectionUtils.IsNullableType(underlyingType)) ? Nullable.GetUnderlyingType(underlyingType) : underlyingType;
+
+            _createdType = CreatedType = NonNullableUnderlyingType;
+
+            IsConvertable = ConvertUtils.IsConvertible(NonNullableUnderlyingType);
+            IsEnum = NonNullableUnderlyingType.IsEnum();
+
+            InternalReadType = ReadType.Read;
+        }
+
+        internal void InvokeOnSerializing(object o, StreamingContext context)
+        {
+            if (_onSerializingCallbacks != null)
+            {
+                foreach (SerializationCallback callback in _onSerializingCallbacks)
+                {
+                    callback(o, context);
+                }
+            }
+        }
+
+        internal void InvokeOnSerialized(object o, StreamingContext context)
+        {
+            if (_onSerializedCallbacks != null)
+            {
+                foreach (SerializationCallback callback in _onSerializedCallbacks)
+                {
+                    callback(o, context);
+                }
+            }
+        }
+
+        internal void InvokeOnDeserializing(object o, StreamingContext context)
+        {
+            if (_onDeserializingCallbacks != null)
+            {
+                foreach (SerializationCallback callback in _onDeserializingCallbacks)
+                {
+                    callback(o, context);
+                }
+            }
+        }
+
+        internal void InvokeOnDeserialized(object o, StreamingContext context)
+        {
+            if (_onDeserializedCallbacks != null)
+            {
+                foreach (SerializationCallback callback in _onDeserializedCallbacks)
+                {
+                    callback(o, context);
+                }
+            }
+        }
+
+        internal void InvokeOnError(object o, StreamingContext context, ErrorContext errorContext)
+        {
+            if (_onErrorCallbacks != null)
+            {
+                foreach (SerializationErrorCallback callback in _onErrorCallbacks)
+                {
+                    callback(o, context, errorContext);
+                }
+            }
+        }
+
+        internal static SerializationCallback CreateSerializationCallback(MethodInfo callbackMethodInfo)
+        {
+            return (o, context) => callbackMethodInfo.Invoke(o, new object[] { context });
+        }
+
+        internal static SerializationErrorCallback CreateSerializationErrorCallback(MethodInfo callbackMethodInfo)
+        {
+            return (o, context, econtext) => callbackMethodInfo.Invoke(o, new object[] { context, econtext });
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs
new file mode 100644
index 0000000..c28f415
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs
@@ -0,0 +1,247 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+using System.Collections;
+
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="System.Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonDictionaryContract : JsonContainerContract
+    {
+        /// <summary>
+        /// Gets or sets the dictionary key resolver.
+        /// </summary>
+        /// <value>The dictionary key resolver.</value>
+        public Func<string, string>? DictionaryKeyResolver { get; set; }
+
+        /// <summary>
+        /// Gets the <see cref="System.Type"/> of the dictionary keys.
+        /// </summary>
+        /// <value>The <see cref="System.Type"/> of the dictionary keys.</value>
+        public Type? DictionaryKeyType { get; }
+
+        /// <summary>
+        /// Gets the <see cref="System.Type"/> of the dictionary values.
+        /// </summary>
+        /// <value>The <see cref="System.Type"/> of the dictionary values.</value>
+        public Type? DictionaryValueType { get; }
+
+        internal JsonContract? KeyContract { get; set; }
+
+        private readonly Type? _genericCollectionDefinitionType;
+
+        private Type? _genericWrapperType;
+        private ObjectConstructor<object>? _genericWrapperCreator;
+
+        private Func<object>? _genericTemporaryDictionaryCreator;
+
+        internal bool ShouldCreateWrapper { get; }
+
+        private readonly ConstructorInfo? _parameterizedConstructor;
+
+        private ObjectConstructor<object>? _overrideCreator;
+        private ObjectConstructor<object>? _parameterizedCreator;
+
+        internal ObjectConstructor<object>? ParameterizedCreator
+        {
+            get
+            {
+                if (_parameterizedCreator == null && _parameterizedConstructor != null)
+                {
+                    _parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(_parameterizedConstructor);
+                }
+
+                return _parameterizedCreator;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the function used to create the object. When set this function will override <see cref="JsonContract.DefaultCreator"/>.
+        /// </summary>
+        /// <value>The function used to create the object.</value>
+        public ObjectConstructor<object>? OverrideCreator
+        {
+            get => _overrideCreator;
+            set => _overrideCreator = value;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the creator has a parameter with the dictionary values.
+        /// </summary>
+        /// <value><c>true</c> if the creator has a parameter with the dictionary values; otherwise, <c>false</c>.</value>
+        public bool HasParameterizedCreator { get; set; }
+
+        internal bool HasParameterizedCreatorInternal => (HasParameterizedCreator || _parameterizedCreator != null || _parameterizedConstructor != null);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonDictionaryContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonDictionaryContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.Dictionary;
+
+            Type? keyType;
+            Type? valueType;
+
+            if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(IDictionary<,>), out _genericCollectionDefinitionType))
+            {
+                keyType = _genericCollectionDefinitionType.GetGenericArguments()[0];
+                valueType = _genericCollectionDefinitionType.GetGenericArguments()[1];
+
+                if (ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(IDictionary<,>)))
+                {
+                    CreatedType = typeof(Dictionary<,>).MakeGenericType(keyType, valueType);
+                }
+                else if (NonNullableUnderlyingType.IsGenericType())
+                {
+                    // ConcurrentDictionary<,> + IDictionary setter + null value = error
+                    // wrap to use generic setter
+                    // https://github.com/JamesNK/Newtonsoft.Json/issues/1582
+                    Type typeDefinition = NonNullableUnderlyingType.GetGenericTypeDefinition();
+                    if (typeDefinition.FullName == JsonTypeReflector.ConcurrentDictionaryTypeName)
+                    {
+                        ShouldCreateWrapper = true;
+                    }
+                }
+
+#if HAVE_READ_ONLY_COLLECTIONS
+                IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(NonNullableUnderlyingType, typeof(ReadOnlyDictionary<,>));
+#endif
+
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(IReadOnlyDictionary<,>), out _genericCollectionDefinitionType))
+            {
+                keyType = _genericCollectionDefinitionType.GetGenericArguments()[0];
+                valueType = _genericCollectionDefinitionType.GetGenericArguments()[1];
+
+                if (ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(IReadOnlyDictionary<,>)))
+                {
+                    CreatedType = typeof(ReadOnlyDictionary<,>).MakeGenericType(keyType, valueType);
+                }
+
+                IsReadOnlyOrFixedSize = true;
+            }
+#endif
+            else
+            {
+                ReflectionUtils.GetDictionaryKeyValueTypes(NonNullableUnderlyingType, out keyType, out valueType);
+
+                if (NonNullableUnderlyingType == typeof(IDictionary))
+                {
+                    CreatedType = typeof(Dictionary<object, object>);
+                }
+            }
+
+            if (keyType != null && valueType != null)
+            {
+                _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(
+                    CreatedType,
+                    typeof(KeyValuePair<,>).MakeGenericType(keyType, valueType),
+                    typeof(IDictionary<,>).MakeGenericType(keyType, valueType));
+
+#if HAVE_FSHARP_TYPES
+                if (!HasParameterizedCreatorInternal && NonNullableUnderlyingType.Name == FSharpUtils.FSharpMapTypeName)
+                {
+                    FSharpUtils.EnsureInitialized(NonNullableUnderlyingType.Assembly());
+                    _parameterizedCreator = FSharpUtils.Instance.CreateMap(keyType, valueType);
+                }
+#endif
+            }
+
+            if (!typeof(IDictionary).IsAssignableFrom(CreatedType))
+            {
+                ShouldCreateWrapper = true;
+            }
+
+            DictionaryKeyType = keyType;
+            DictionaryValueType = valueType;
+
+#if (NET20 || NET35)
+            if (DictionaryValueType != null && ReflectionUtils.IsNullableType(DictionaryValueType))
+            {
+                // bug in .NET 2.0 & 3.5 that Dictionary<TKey, Nullable<TValue>> throws an error when adding null via IDictionary[key] = object
+                // wrapper will handle calling Add(T) instead
+                if (ReflectionUtils.InheritsGenericDefinition(CreatedType, typeof(Dictionary<,>), out _))
+                {
+                    ShouldCreateWrapper = true;
+                }
+            }
+#endif
+
+            if (DictionaryKeyType != null && 
+                DictionaryValueType != null &&
+                ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract(
+                    NonNullableUnderlyingType,
+                    DictionaryKeyType,
+                    DictionaryValueType,
+                    out Type? immutableCreatedType,
+                    out ObjectConstructor<object>? immutableParameterizedCreator))
+            {
+                CreatedType = immutableCreatedType;
+                _parameterizedCreator = immutableParameterizedCreator;
+                IsReadOnlyOrFixedSize = true;
+            }
+        }
+
+        internal IWrappedDictionary CreateWrapper(object dictionary)
+        {
+            if (_genericWrapperCreator == null)
+            {
+                _genericWrapperType = typeof(DictionaryWrapper<,>).MakeGenericType(DictionaryKeyType, DictionaryValueType);
+
+                ConstructorInfo genericWrapperConstructor = _genericWrapperType.GetConstructor(new[] { _genericCollectionDefinitionType! });
+                _genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(genericWrapperConstructor);
+            }
+
+            return (IWrappedDictionary)_genericWrapperCreator(dictionary);
+        }
+
+        internal IDictionary CreateTemporaryDictionary()
+        {
+            if (_genericTemporaryDictionaryCreator == null)
+            {
+                Type temporaryDictionaryType = typeof(Dictionary<,>).MakeGenericType(DictionaryKeyType ?? typeof(object), DictionaryValueType ?? typeof(object));
+
+                _genericTemporaryDictionaryCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateDefaultConstructor<object>(temporaryDictionaryType);
+            }
+
+            return (IDictionary)_genericTemporaryDictionaryCreator();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonDynamicContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonDynamicContract.cs
new file mode 100644
index 0000000..1332a7d
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonDynamicContract.cs
@@ -0,0 +1,116 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_DYNAMIC
+using System;
+using System.Dynamic;
+using System.Runtime.CompilerServices;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonDynamicContract : JsonContainerContract
+    {
+        /// <summary>
+        /// Gets the object's properties.
+        /// </summary>
+        /// <value>The object's properties.</value>
+        public JsonPropertyCollection Properties { get; }
+
+        /// <summary>
+        /// Gets or sets the property name resolver.
+        /// </summary>
+        /// <value>The property name resolver.</value>
+        public Func<string, string>? PropertyNameResolver { get; set; }
+
+        private readonly ThreadSafeStore<string, CallSite<Func<CallSite, object, object>>> _callSiteGetters =
+            new ThreadSafeStore<string, CallSite<Func<CallSite, object, object>>>(CreateCallSiteGetter);
+
+        private readonly ThreadSafeStore<string, CallSite<Func<CallSite, object, object?, object>>> _callSiteSetters =
+            new ThreadSafeStore<string, CallSite<Func<CallSite, object, object?, object>>>(CreateCallSiteSetter);
+
+        private static CallSite<Func<CallSite, object, object>> CreateCallSiteGetter(string name)
+        {
+            GetMemberBinder getMemberBinder = (GetMemberBinder)DynamicUtils.BinderWrapper.GetMember(name, typeof(DynamicUtils));
+
+            return CallSite<Func<CallSite, object, object>>.Create(new NoThrowGetBinderMember(getMemberBinder));
+        }
+
+        private static CallSite<Func<CallSite, object, object?, object>> CreateCallSiteSetter(string name)
+        {
+            SetMemberBinder binder = (SetMemberBinder)DynamicUtils.BinderWrapper.SetMember(name, typeof(DynamicUtils));
+
+            return CallSite<Func<CallSite, object, object?, object>>.Create(new NoThrowSetBinderMember(binder));
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonDynamicContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonDynamicContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.Dynamic;
+
+            Properties = new JsonPropertyCollection(UnderlyingType);
+        }
+
+        internal bool TryGetMember(IDynamicMetaObjectProvider dynamicProvider, string name, out object? value)
+        {
+            ValidationUtils.ArgumentNotNull(dynamicProvider, nameof(dynamicProvider));
+
+            CallSite<Func<CallSite, object, object>> callSite = _callSiteGetters.Get(name);
+
+            object result = callSite.Target(callSite, dynamicProvider);
+
+            if (!ReferenceEquals(result, NoThrowExpressionVisitor.ErrorResult))
+            {
+                value = result;
+                return true;
+            }
+            else
+            {
+                value = null;
+                return false;
+            }
+        }
+
+        internal bool TrySetMember(IDynamicMetaObjectProvider dynamicProvider, string name, object? value)
+        {
+            ValidationUtils.ArgumentNotNull(dynamicProvider, nameof(dynamicProvider));
+
+            CallSite<Func<CallSite, object, object?, object>> callSite = _callSiteSetters.Get(name);
+
+            object result = callSite.Target(callSite, dynamicProvider, value);
+
+            return !ReferenceEquals(result, NoThrowExpressionVisitor.ErrorResult);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonFormatterConverter.cs b/Libs/Newtonsoft.Json/Serialization/JsonFormatterConverter.cs
new file mode 100644
index 0000000..edbb027
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonFormatterConverter.cs
@@ -0,0 +1,157 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_BINARY_SERIALIZATION
+using System;
+using System.Globalization;
+using System.Runtime.Serialization;
+using LC.Newtonsoft.Json.Utilities;
+using LC.Newtonsoft.Json.Linq;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class JsonFormatterConverter : IFormatterConverter
+    {
+        private readonly JsonSerializerInternalReader _reader;
+        private readonly JsonISerializableContract _contract;
+        private readonly JsonProperty? _member;
+
+        public JsonFormatterConverter(JsonSerializerInternalReader reader, JsonISerializableContract contract, JsonProperty? member)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+            ValidationUtils.ArgumentNotNull(contract, nameof(contract));
+
+            _reader = reader;
+            _contract = contract;
+            _member = member;
+        }
+
+        private T GetTokenValue<T>(object value)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+
+            JValue v = (JValue)value;
+            return (T)System.Convert.ChangeType(v.Value, typeof(T), CultureInfo.InvariantCulture);
+        }
+
+        public object? Convert(object value, Type type)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+
+            if (!(value is JToken token))
+            {
+                throw new ArgumentException("Value is not a JToken.", nameof(value));
+            }
+
+            return _reader.CreateISerializableItem(token, type, _contract, _member);
+        }
+
+        public object Convert(object value, TypeCode typeCode)
+        {
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+
+            object? resolvedValue = (value is JValue v) ? v.Value : value;
+
+            return System.Convert.ChangeType(resolvedValue, typeCode, CultureInfo.InvariantCulture);
+        }
+
+        public bool ToBoolean(object value)
+        {
+            return GetTokenValue<bool>(value);
+        }
+
+        public byte ToByte(object value)
+        {
+            return GetTokenValue<byte>(value);
+        }
+
+        public char ToChar(object value)
+        {
+            return GetTokenValue<char>(value);
+        }
+
+        public DateTime ToDateTime(object value)
+        {
+            return GetTokenValue<DateTime>(value);
+        }
+
+        public decimal ToDecimal(object value)
+        {
+            return GetTokenValue<decimal>(value);
+        }
+
+        public double ToDouble(object value)
+        {
+            return GetTokenValue<double>(value);
+        }
+
+        public short ToInt16(object value)
+        {
+            return GetTokenValue<short>(value);
+        }
+
+        public int ToInt32(object value)
+        {
+            return GetTokenValue<int>(value);
+        }
+
+        public long ToInt64(object value)
+        {
+            return GetTokenValue<long>(value);
+        }
+
+        public sbyte ToSByte(object value)
+        {
+            return GetTokenValue<sbyte>(value);
+        }
+
+        public float ToSingle(object value)
+        {
+            return GetTokenValue<float>(value);
+        }
+
+        public string ToString(object value)
+        {
+            return GetTokenValue<string>(value);
+        }
+
+        public ushort ToUInt16(object value)
+        {
+            return GetTokenValue<ushort>(value);
+        }
+
+        public uint ToUInt32(object value)
+        {
+            return GetTokenValue<uint>(value);
+        }
+
+        public ulong ToUInt64(object value)
+        {
+            return GetTokenValue<ulong>(value);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonISerializableContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonISerializableContract.cs
new file mode 100644
index 0000000..b863711
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonISerializableContract.cs
@@ -0,0 +1,55 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_BINARY_SERIALIZATION
+using System;
+using System.Runtime.Serialization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonISerializableContract : JsonContainerContract
+    {
+        /// <summary>
+        /// Gets or sets the <see cref="ISerializable"/> object constructor.
+        /// </summary>
+        /// <value>The <see cref="ISerializable"/> object constructor.</value>
+        public ObjectConstructor<object>? ISerializableCreator { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonISerializableContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonISerializableContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.Serializable;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonLinqContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonLinqContract.cs
new file mode 100644
index 0000000..c3f941f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonLinqContract.cs
@@ -0,0 +1,45 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonLinqContract : JsonContract
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonLinqContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonLinqContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.Linq;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonObjectContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonObjectContract.cs
new file mode 100644
index 0000000..50af656
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonObjectContract.cs
@@ -0,0 +1,199 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Security;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="System.Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonObjectContract : JsonContainerContract
+    {
+        /// <summary>
+        /// Gets or sets the object member serialization.
+        /// </summary>
+        /// <value>The member object serialization.</value>
+        public MemberSerialization MemberSerialization { get; set; }
+
+        /// <summary>
+        /// Gets or sets the missing member handling used when deserializing this object.
+        /// </summary>
+        /// <value>The missing member handling.</value>
+        public MissingMemberHandling? MissingMemberHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value that indicates whether the object's properties are required.
+        /// </summary>
+        /// <value>
+        /// 	A value indicating whether the object's properties are required.
+        /// </value>
+        public Required? ItemRequired { get; set; }
+
+        /// <summary>
+        /// Gets or sets how the object's properties with null values are handled during serialization and deserialization.
+        /// </summary>
+        /// <value>How the object's properties with null values are handled during serialization and deserialization.</value>
+        public NullValueHandling? ItemNullValueHandling { get; set; }
+
+        /// <summary>
+        /// Gets the object's properties.
+        /// </summary>
+        /// <value>The object's properties.</value>
+        public JsonPropertyCollection Properties { get; }
+
+        /// <summary>
+        /// Gets a collection of <see cref="JsonProperty"/> instances that define the parameters used with <see cref="JsonObjectContract.OverrideCreator"/>.
+        /// </summary>
+        public JsonPropertyCollection CreatorParameters
+        {
+            get
+            {
+                if (_creatorParameters == null)
+                {
+                    _creatorParameters = new JsonPropertyCollection(UnderlyingType);
+                }
+
+                return _creatorParameters;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the function used to create the object. When set this function will override <see cref="JsonContract.DefaultCreator"/>.
+        /// This function is called with a collection of arguments which are defined by the <see cref="JsonObjectContract.CreatorParameters"/> collection.
+        /// </summary>
+        /// <value>The function used to create the object.</value>
+        public ObjectConstructor<object>? OverrideCreator
+        {
+            get => _overrideCreator;
+            set => _overrideCreator = value;
+        }
+
+        internal ObjectConstructor<object>? ParameterizedCreator
+        {
+            get => _parameterizedCreator;
+            set => _parameterizedCreator = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the extension data setter.
+        /// </summary>
+        public ExtensionDataSetter? ExtensionDataSetter { get; set; }
+
+        /// <summary>
+        /// Gets or sets the extension data getter.
+        /// </summary>
+        public ExtensionDataGetter? ExtensionDataGetter { get; set; }
+
+        /// <summary>
+        /// Gets or sets the extension data value type.
+        /// </summary>
+        public Type? ExtensionDataValueType
+        {
+            get => _extensionDataValueType;
+            set
+            {
+                _extensionDataValueType = value;
+                ExtensionDataIsJToken = (value != null && typeof(JToken).IsAssignableFrom(value));
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the extension data name resolver.
+        /// </summary>
+        /// <value>The extension data name resolver.</value>
+        public Func<string, string>? ExtensionDataNameResolver { get; set; }
+
+        internal bool ExtensionDataIsJToken;
+        private bool? _hasRequiredOrDefaultValueProperties;
+        private ObjectConstructor<object>? _overrideCreator;
+        private ObjectConstructor<object>? _parameterizedCreator;
+        private JsonPropertyCollection? _creatorParameters;
+        private Type? _extensionDataValueType;
+
+        internal bool HasRequiredOrDefaultValueProperties
+        {
+            get
+            {
+                if (_hasRequiredOrDefaultValueProperties == null)
+                {
+                    _hasRequiredOrDefaultValueProperties = false;
+
+                    if (ItemRequired.GetValueOrDefault(Required.Default) != Required.Default)
+                    {
+                        _hasRequiredOrDefaultValueProperties = true;
+                    }
+                    else
+                    {
+                        foreach (JsonProperty property in Properties)
+                        {
+                            if (property.Required != Required.Default || (property.DefaultValueHandling & DefaultValueHandling.Populate) == DefaultValueHandling.Populate)
+                            {
+                                _hasRequiredOrDefaultValueProperties = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                return _hasRequiredOrDefaultValueProperties.GetValueOrDefault();
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonObjectContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonObjectContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.Object;
+
+            Properties = new JsonPropertyCollection(UnderlyingType);
+        }
+
+#if HAVE_BINARY_FORMATTER
+#if HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE
+        [SecuritySafeCritical]
+#endif
+        internal object GetUninitializedObject()
+        {
+            // we should never get here if the environment is not fully trusted, check just in case
+            if (!JsonTypeReflector.FullyTrusted)
+            {
+                throw new JsonException("Insufficient permissions. Creating an uninitialized '{0}' type requires full trust.".FormatWith(CultureInfo.InvariantCulture, NonNullableUnderlyingType));
+            }
+
+            return FormatterServices.GetUninitializedObject(NonNullableUnderlyingType);
+        }
+#endif
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonPrimitiveContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonPrimitiveContract.cs
new file mode 100644
index 0000000..035c74c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonPrimitiveContract.cs
@@ -0,0 +1,75 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonPrimitiveContract : JsonContract
+    {
+        internal PrimitiveTypeCode TypeCode { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPrimitiveContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonPrimitiveContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.Primitive;
+
+            TypeCode = ConvertUtils.GetTypeCode(underlyingType);
+            IsReadOnlyOrFixedSize = true;
+
+            if (ReadTypeMap.TryGetValue(NonNullableUnderlyingType, out ReadType readType))
+            {
+                InternalReadType = readType;
+            }
+        }
+
+        private static readonly Dictionary<Type, ReadType> ReadTypeMap = new Dictionary<Type, ReadType>
+        {
+            [typeof(byte[])] = ReadType.ReadAsBytes,
+            [typeof(byte)] = ReadType.ReadAsInt32,
+            [typeof(short)] = ReadType.ReadAsInt32,
+            [typeof(int)] = ReadType.ReadAsInt32,
+            [typeof(decimal)] = ReadType.ReadAsDecimal,
+            [typeof(bool)] = ReadType.ReadAsBoolean,
+            [typeof(string)] = ReadType.ReadAsString,
+            [typeof(DateTime)] = ReadType.ReadAsDateTime,
+#if HAVE_DATE_TIME_OFFSET
+            [typeof(DateTimeOffset)] = ReadType.ReadAsDateTimeOffset,
+#endif
+            [typeof(float)] = ReadType.ReadAsDouble,
+            [typeof(double)] = ReadType.ReadAsDouble,
+            [typeof(long)] = ReadType.ReadAsInt64
+        };
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonProperty.cs b/Libs/Newtonsoft.Json/Serialization/JsonProperty.cs
new file mode 100644
index 0000000..d1017bc
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonProperty.cs
@@ -0,0 +1,322 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Diagnostics;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Maps a JSON property to a .NET member or constructor parameter.
+    /// </summary>
+    public class JsonProperty
+    {
+        internal Required? _required;
+        internal bool _hasExplicitDefaultValue;
+
+        private object? _defaultValue;
+        private bool _hasGeneratedDefaultValue;
+        private string? _propertyName;
+        internal bool _skipPropertyNameEscape;
+        private Type? _propertyType;
+
+        // use to cache contract during deserialization
+        internal JsonContract? PropertyContract { get; set; }
+
+        /// <summary>
+        /// Gets or sets the name of the property.
+        /// </summary>
+        /// <value>The name of the property.</value>
+        public string? PropertyName
+        {
+            get => _propertyName;
+            set
+            {
+                _propertyName = value;
+                _skipPropertyNameEscape = !JavaScriptUtils.ShouldEscapeJavaScriptString(_propertyName, JavaScriptUtils.HtmlCharEscapeFlags);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the type that declared this property.
+        /// </summary>
+        /// <value>The type that declared this property.</value>
+        public Type? DeclaringType { get; set; }
+
+        /// <summary>
+        /// Gets or sets the order of serialization of a member.
+        /// </summary>
+        /// <value>The numeric order of serialization.</value>
+        public int? Order { get; set; }
+
+        /// <summary>
+        /// Gets or sets the name of the underlying member or parameter.
+        /// </summary>
+        /// <value>The name of the underlying member or parameter.</value>
+        public string? UnderlyingName { get; set; }
+
+        /// <summary>
+        /// Gets the <see cref="IValueProvider"/> that will get and set the <see cref="JsonProperty"/> during serialization.
+        /// </summary>
+        /// <value>The <see cref="IValueProvider"/> that will get and set the <see cref="JsonProperty"/> during serialization.</value>
+        public IValueProvider? ValueProvider { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="IAttributeProvider"/> for this property.
+        /// </summary>
+        /// <value>The <see cref="IAttributeProvider"/> for this property.</value>
+        public IAttributeProvider? AttributeProvider { get; set; }
+
+        /// <summary>
+        /// Gets or sets the type of the property.
+        /// </summary>
+        /// <value>The type of the property.</value>
+        public Type? PropertyType
+        {
+            get => _propertyType;
+            set
+            {
+                if (_propertyType != value)
+                {
+                    _propertyType = value;
+                    _hasGeneratedDefaultValue = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="JsonConverter" /> for the property.
+        /// If set this converter takes precedence over the contract converter for the property type.
+        /// </summary>
+        /// <value>The converter.</value>
+        public JsonConverter? Converter { get; set; }
+
+        /// <summary>
+        /// Gets or sets the member converter.
+        /// </summary>
+        /// <value>The member converter.</value>
+        [Obsolete("MemberConverter is obsolete. Use Converter instead.")]
+        public JsonConverter? MemberConverter
+        {
+            get => Converter;
+            set => Converter = value;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="JsonProperty"/> is ignored.
+        /// </summary>
+        /// <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>
+        public bool Ignored { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="JsonProperty"/> is readable.
+        /// </summary>
+        /// <value><c>true</c> if readable; otherwise, <c>false</c>.</value>
+        public bool Readable { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="JsonProperty"/> is writable.
+        /// </summary>
+        /// <value><c>true</c> if writable; otherwise, <c>false</c>.</value>
+        public bool Writable { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="JsonProperty"/> has a member attribute.
+        /// </summary>
+        /// <value><c>true</c> if has a member attribute; otherwise, <c>false</c>.</value>
+        public bool HasMemberAttribute { get; set; }
+
+        /// <summary>
+        /// Gets the default value.
+        /// </summary>
+        /// <value>The default value.</value>
+        public object? DefaultValue
+        {
+            get
+            {
+                if (!_hasExplicitDefaultValue)
+                {
+                    return null;
+                }
+
+                return _defaultValue;
+            }
+            set
+            {
+                _hasExplicitDefaultValue = true;
+                _defaultValue = value;
+            }
+        }
+
+        internal object? GetResolvedDefaultValue()
+        {
+            if (_propertyType == null)
+            {
+                return null;
+            }
+
+            if (!_hasExplicitDefaultValue && !_hasGeneratedDefaultValue)
+            {
+                _defaultValue = ReflectionUtils.GetDefaultValue(_propertyType);
+                _hasGeneratedDefaultValue = true;
+            }
+
+            return _defaultValue;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="JsonProperty"/> is required.
+        /// </summary>
+        /// <value>A value indicating whether this <see cref="JsonProperty"/> is required.</value>
+        public Required Required
+        {
+            get => _required ?? Required.Default;
+            set => _required = value;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether <see cref="Required"/> has a value specified.
+        /// </summary>
+        public bool IsRequiredSpecified => _required != null;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this property preserves object references.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this instance is reference; otherwise, <c>false</c>.
+        /// </value>
+        public bool? IsReference { get; set; }
+
+        /// <summary>
+        /// Gets or sets the property null value handling.
+        /// </summary>
+        /// <value>The null value handling.</value>
+        public NullValueHandling? NullValueHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets the property default value handling.
+        /// </summary>
+        /// <value>The default value handling.</value>
+        public DefaultValueHandling? DefaultValueHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets the property reference loop handling.
+        /// </summary>
+        /// <value>The reference loop handling.</value>
+        public ReferenceLoopHandling? ReferenceLoopHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets the property object creation handling.
+        /// </summary>
+        /// <value>The object creation handling.</value>
+        public ObjectCreationHandling? ObjectCreationHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets or sets the type name handling.
+        /// </summary>
+        /// <value>The type name handling.</value>
+        public TypeNameHandling? TypeNameHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets a predicate used to determine whether the property should be serialized.
+        /// </summary>
+        /// <value>A predicate used to determine whether the property should be serialized.</value>
+        public Predicate<object>? ShouldSerialize { get; set; }
+
+        /// <summary>
+        /// Gets or sets a predicate used to determine whether the property should be deserialized.
+        /// </summary>
+        /// <value>A predicate used to determine whether the property should be deserialized.</value>
+        public Predicate<object>? ShouldDeserialize { get; set; }
+
+        /// <summary>
+        /// Gets or sets a predicate used to determine whether the property should be serialized.
+        /// </summary>
+        /// <value>A predicate used to determine whether the property should be serialized.</value>
+        public Predicate<object>? GetIsSpecified { get; set; }
+
+        /// <summary>
+        /// Gets or sets an action used to set whether the property has been deserialized.
+        /// </summary>
+        /// <value>An action used to set whether the property has been deserialized.</value>
+        public Action<object, object?>? SetIsSpecified { get; set; }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="String"/> that represents this instance.
+        /// </returns>
+        public override string ToString()
+        {
+            return PropertyName ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Gets or sets the converter used when serializing the property's collection items.
+        /// </summary>
+        /// <value>The collection's items converter.</value>
+        public JsonConverter? ItemConverter { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether this property's collection items are serialized as a reference.
+        /// </summary>
+        /// <value>Whether this property's collection items are serialized as a reference.</value>
+        public bool? ItemIsReference { get; set; }
+
+        /// <summary>
+        /// Gets or sets the type name handling used when serializing the property's collection items.
+        /// </summary>
+        /// <value>The collection's items type name handling.</value>
+        public TypeNameHandling? ItemTypeNameHandling { get; set; }
+
+        /// <summary>
+        /// Gets or sets the reference loop handling used when serializing the property's collection items.
+        /// </summary>
+        /// <value>The collection's items reference loop handling.</value>
+        public ReferenceLoopHandling? ItemReferenceLoopHandling { get; set; }
+
+        internal void WritePropertyName(JsonWriter writer)
+        {
+            string? propertyName = PropertyName;
+            MiscellaneousUtils.Assert(propertyName != null);
+
+            if (_skipPropertyNameEscape)
+            {
+                writer.WritePropertyName(propertyName, false);
+            }
+            else
+            {
+                writer.WritePropertyName(propertyName);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonPropertyCollection.cs b/Libs/Newtonsoft.Json/Serialization/JsonPropertyCollection.cs
new file mode 100644
index 0000000..cc1a55c
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonPropertyCollection.cs
@@ -0,0 +1,190 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Collections.ObjectModel;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// A collection of <see cref="JsonProperty"/> objects.
+    /// </summary>
+    public class JsonPropertyCollection : KeyedCollection<string, JsonProperty>
+    {
+        private readonly Type _type;
+        private readonly List<JsonProperty> _list;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPropertyCollection"/> class.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        public JsonPropertyCollection(Type type)
+            : base(StringComparer.Ordinal)
+        {
+            ValidationUtils.ArgumentNotNull(type, "type");
+            _type = type;
+
+            // foreach over List<T> to avoid boxing the Enumerator
+            _list = (List<JsonProperty>)Items;
+        }
+
+        /// <summary>
+        /// When implemented in a derived class, extracts the key from the specified element.
+        /// </summary>
+        /// <param name="item">The element from which to extract the key.</param>
+        /// <returns>The key for the specified element.</returns>
+        protected override string GetKeyForItem(JsonProperty item)
+        {
+            return item.PropertyName!;
+        }
+
+        /// <summary>
+        /// Adds a <see cref="JsonProperty"/> object.
+        /// </summary>
+        /// <param name="property">The property to add to the collection.</param>
+        public void AddProperty(JsonProperty property)
+        {
+            MiscellaneousUtils.Assert(property.PropertyName != null);
+
+            if (Contains(property.PropertyName))
+            {
+                // don't overwrite existing property with ignored property
+                if (property.Ignored)
+                {
+                    return;
+                }
+
+                JsonProperty existingProperty = this[property.PropertyName];
+                bool duplicateProperty = true;
+
+                if (existingProperty.Ignored)
+                {
+                    // remove ignored property so it can be replaced in collection
+                    Remove(existingProperty);
+                    duplicateProperty = false;
+                }
+                else
+                {
+                    if (property.DeclaringType != null && existingProperty.DeclaringType != null)
+                    {
+                        if (property.DeclaringType.IsSubclassOf(existingProperty.DeclaringType)
+                            || (existingProperty.DeclaringType.IsInterface() && property.DeclaringType.ImplementInterface(existingProperty.DeclaringType)))
+                        {
+                            // current property is on a derived class and hides the existing
+                            Remove(existingProperty);
+                            duplicateProperty = false;
+                        }
+                        if (existingProperty.DeclaringType.IsSubclassOf(property.DeclaringType)
+                            || (property.DeclaringType.IsInterface() && existingProperty.DeclaringType.ImplementInterface(property.DeclaringType)))
+                        {
+                            // current property is hidden by the existing so don't add it
+                            return;
+                        }
+                        
+                        if (_type.ImplementInterface(existingProperty.DeclaringType) && _type.ImplementInterface(property.DeclaringType))
+                        {
+                            // current property was already defined on another interface
+                            return;
+                        }
+                    }
+                }
+
+                if (duplicateProperty)
+                {
+                    throw new JsonSerializationException("A member with the name '{0}' already exists on '{1}'. Use the JsonPropertyAttribute to specify another name.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, _type));
+                }
+            }
+
+            Add(property);
+        }
+
+        /// <summary>
+        /// Gets the closest matching <see cref="JsonProperty"/> object.
+        /// First attempts to get an exact case match of <paramref name="propertyName"/> and then
+        /// a case insensitive match.
+        /// </summary>
+        /// <param name="propertyName">Name of the property.</param>
+        /// <returns>A matching property if found.</returns>
+        public JsonProperty? GetClosestMatchProperty(string propertyName)
+        {
+            JsonProperty? property = GetProperty(propertyName, StringComparison.Ordinal);
+            if (property == null)
+            {
+                property = GetProperty(propertyName, StringComparison.OrdinalIgnoreCase);
+            }
+
+            return property;
+        }
+
+        private bool TryGetValue(string key, [NotNullWhen(true)]out JsonProperty? item)
+        {
+            if (Dictionary == null)
+            {
+                item = default;
+                return false;
+            }
+
+            return Dictionary.TryGetValue(key, out item);
+        }
+
+        /// <summary>
+        /// Gets a property by property name.
+        /// </summary>
+        /// <param name="propertyName">The name of the property to get.</param>
+        /// <param name="comparisonType">Type property name string comparison.</param>
+        /// <returns>A matching property if found.</returns>
+        public JsonProperty? GetProperty(string propertyName, StringComparison comparisonType)
+        {
+            // KeyedCollection has an ordinal comparer
+            if (comparisonType == StringComparison.Ordinal)
+            {
+                if (TryGetValue(propertyName, out JsonProperty? property))
+                {
+                    return property;
+                }
+
+                return null;
+            }
+
+            for (int i = 0; i < _list.Count; i++)
+            {
+                JsonProperty property = _list[i];
+                if (string.Equals(propertyName, property.PropertyName, comparisonType))
+                {
+                    return property;
+                }
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalBase.cs b/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalBase.cs
new file mode 100644
index 0000000..9aa44d2
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalBase.cs
@@ -0,0 +1,159 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal abstract class JsonSerializerInternalBase
+    {
+        private class ReferenceEqualsEqualityComparer : IEqualityComparer<object>
+        {
+            bool IEqualityComparer<object>.Equals(object x, object y)
+            {
+                return ReferenceEquals(x, y);
+            }
+
+            int IEqualityComparer<object>.GetHashCode(object obj)
+            {
+                // put objects in a bucket based on their reference
+                return RuntimeHelpers.GetHashCode(obj);
+            }
+        }
+
+        private ErrorContext? _currentErrorContext;
+        private BidirectionalDictionary<string, object>? _mappings;
+
+        internal readonly JsonSerializer Serializer;
+        internal readonly ITraceWriter? TraceWriter;
+        protected JsonSerializerProxy? InternalSerializer;
+
+        protected JsonSerializerInternalBase(JsonSerializer serializer)
+        {
+            ValidationUtils.ArgumentNotNull(serializer, nameof(serializer));
+
+            Serializer = serializer;
+            TraceWriter = serializer.TraceWriter;
+        }
+
+        internal BidirectionalDictionary<string, object> DefaultReferenceMappings
+        {
+            get
+            {
+                // override equality comparer for object key dictionary
+                // object will be modified as it deserializes and might have mutable hashcode
+                if (_mappings == null)
+                {
+                    _mappings = new BidirectionalDictionary<string, object>(
+                        EqualityComparer<string>.Default,
+                        new ReferenceEqualsEqualityComparer(),
+                        "A different value already has the Id '{0}'.",
+                        "A different Id has already been assigned for value '{0}'. This error may be caused by an object being reused multiple times during deserialization and can be fixed with the setting ObjectCreationHandling.Replace.");
+                }
+
+                return _mappings;
+            }
+        }
+
+        protected NullValueHandling ResolvedNullValueHandling(JsonObjectContract? containerContract, JsonProperty property)
+        {
+            NullValueHandling resolvedNullValueHandling =
+                property.NullValueHandling
+                ?? containerContract?.ItemNullValueHandling
+                ?? Serializer._nullValueHandling;
+
+            return resolvedNullValueHandling;
+        }
+
+        private ErrorContext GetErrorContext(object? currentObject, object? member, string path, Exception error)
+        {
+            if (_currentErrorContext == null)
+            {
+                _currentErrorContext = new ErrorContext(currentObject, member, path, error);
+            }
+
+            if (_currentErrorContext.Error != error)
+            {
+                throw new InvalidOperationException("Current error context error is different to requested error.");
+            }
+
+            return _currentErrorContext;
+        }
+
+        protected void ClearErrorContext()
+        {
+            if (_currentErrorContext == null)
+            {
+                throw new InvalidOperationException("Could not clear error context. Error context is already null.");
+            }
+
+            _currentErrorContext = null;
+        }
+
+        protected bool IsErrorHandled(object? currentObject, JsonContract? contract, object? keyValue, IJsonLineInfo? lineInfo, string path, Exception ex)
+        {
+            ErrorContext errorContext = GetErrorContext(currentObject, keyValue, path, ex);
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Error && !errorContext.Traced)
+            {
+                // only write error once
+                errorContext.Traced = true;
+
+                // kind of a hack but meh. might clean this up later
+                string message = (GetType() == typeof(JsonSerializerInternalWriter)) ? "Error serializing" : "Error deserializing";
+                if (contract != null)
+                {
+                    message += " " + contract.UnderlyingType;
+                }
+                message += ". " + ex.Message;
+
+                // add line information to non-json.net exception message
+                if (!(ex is JsonException))
+                {
+                    message = JsonPosition.FormatMessage(lineInfo, path, message);
+                }
+
+                TraceWriter.Trace(TraceLevel.Error, message, ex);
+            }
+
+            // attribute method is non-static so don't invoke if no object
+            if (contract != null && currentObject != null)
+            {
+                contract.InvokeOnError(currentObject, Serializer.Context, errorContext);
+            }
+
+            if (!errorContext.Handled)
+            {
+                Serializer.OnError(new ErrorEventArgs(currentObject, errorContext));
+            }
+
+            return errorContext.Handled;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs b/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs
new file mode 100644
index 0000000..7f51152
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs
@@ -0,0 +1,2636 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+#if HAVE_DYNAMIC
+using System.ComponentModel;
+using System.Dynamic;
+#endif
+using System.Diagnostics;
+using System.Globalization;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Reflection;
+using System.Runtime.Serialization;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class JsonSerializerInternalReader : JsonSerializerInternalBase
+    {
+        internal enum PropertyPresence
+        {
+            None = 0,
+            Null = 1,
+            Value = 2
+        }
+
+        public JsonSerializerInternalReader(JsonSerializer serializer)
+            : base(serializer)
+        {
+        }
+
+        public void Populate(JsonReader reader, object target)
+        {
+            ValidationUtils.ArgumentNotNull(target, nameof(target));
+
+            Type objectType = target.GetType();
+
+            JsonContract contract = Serializer._contractResolver.ResolveContract(objectType);
+
+            if (!reader.MoveToContent())
+            {
+                throw JsonSerializationException.Create(reader, "No JSON content found.");
+            }
+
+            if (reader.TokenType == JsonToken.StartArray)
+            {
+                if (contract.ContractType == JsonContractType.Array)
+                {
+                    JsonArrayContract arrayContract = (JsonArrayContract)contract;
+
+                    PopulateList((arrayContract.ShouldCreateWrapper) ? arrayContract.CreateWrapper(target) : (IList)target, reader, arrayContract, null, null);
+                }
+                else
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot populate JSON array onto type '{0}'.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+            }
+            else if (reader.TokenType == JsonToken.StartObject)
+            {
+                reader.ReadAndAssert();
+
+                string? id = null;
+                if (Serializer.MetadataPropertyHandling != MetadataPropertyHandling.Ignore
+                    && reader.TokenType == JsonToken.PropertyName
+                    && string.Equals(reader.Value!.ToString(), JsonTypeReflector.IdPropertyName, StringComparison.Ordinal))
+                {
+                    reader.ReadAndAssert();
+                    id = reader.Value?.ToString();
+                    reader.ReadAndAssert();
+                }
+
+                if (contract.ContractType == JsonContractType.Dictionary)
+                {
+                    JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)contract;
+                    PopulateDictionary((dictionaryContract.ShouldCreateWrapper) ? dictionaryContract.CreateWrapper(target) : (IDictionary)target, reader, dictionaryContract, null, id);
+                }
+                else if (contract.ContractType == JsonContractType.Object)
+                {
+                    PopulateObject(target, reader, (JsonObjectContract)contract, null, id);
+                }
+                else
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot populate JSON object onto type '{0}'.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+            }
+            else
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected initial token '{0}' when populating object. Expected JSON object or array.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+        }
+
+        private JsonContract? GetContractSafe(Type? type)
+        {
+            if (type == null)
+            {
+                return null;
+            }
+
+            return GetContract(type);
+        }
+
+        private JsonContract GetContract(Type type)
+        {
+            return Serializer._contractResolver.ResolveContract(type);
+        }
+
+        public object? Deserialize(JsonReader reader, Type? objectType, bool checkAdditionalContent)
+        {
+            if (reader == null)
+            {
+                throw new ArgumentNullException(nameof(reader));
+            }
+
+            JsonContract? contract = GetContractSafe(objectType);
+
+            try
+            {
+                JsonConverter? converter = GetConverter(contract, null, null, null);
+
+                if (reader.TokenType == JsonToken.None && !reader.ReadForType(contract, converter != null))
+                {
+                    if (contract != null && !contract.IsNullable)
+                    {
+                        throw JsonSerializationException.Create(reader, "No JSON content found and type '{0}' is not nullable.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                    }
+
+                    return null;
+                }
+
+                object? deserializedValue;
+
+                if (converter != null && converter.CanRead)
+                {
+                    deserializedValue = DeserializeConvertable(converter, reader, objectType!, null);
+                }
+                else
+                {
+                    deserializedValue = CreateValueInternal(reader, objectType, contract, null, null, null, null);
+                }
+
+                if (checkAdditionalContent)
+                {
+                    while (reader.Read())
+                    {
+                        if (reader.TokenType != JsonToken.Comment)
+                        {
+                            throw JsonSerializationException.Create(reader, "Additional text found in JSON string after finishing deserializing object.");
+                        }
+                    }
+                }
+
+                return deserializedValue;
+            }
+            catch (Exception ex)
+            {
+                if (IsErrorHandled(null, contract, null, reader as IJsonLineInfo, reader.Path, ex))
+                {
+                    HandleError(reader, false, 0);
+                    return null;
+                }
+                else
+                {
+                    // clear context in case serializer is being used inside a converter
+                    // if the converter wraps the error then not clearing the context will cause this error:
+                    // "Current error context error is different to requested error."
+                    ClearErrorContext();
+                    throw;
+                }
+            }
+        }
+
+        private JsonSerializerProxy GetInternalSerializer()
+        {
+            if (InternalSerializer == null)
+            {
+                InternalSerializer = new JsonSerializerProxy(this);
+            }
+
+            return InternalSerializer;
+        }
+
+        private JToken? CreateJToken(JsonReader reader, JsonContract? contract)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            if (contract != null)
+            {
+                if (contract.UnderlyingType == typeof(JRaw))
+                {
+                    return JRaw.Create(reader);
+                }
+                if (reader.TokenType == JsonToken.Null
+                    && !(contract.UnderlyingType == typeof(JValue) || contract.UnderlyingType == typeof(JToken)))
+                {
+                    return null;
+                }
+            }
+
+            JToken? token;
+            using (JTokenWriter writer = new JTokenWriter())
+            {
+                writer.WriteToken(reader);
+                token = writer.Token;
+            }
+
+            if (contract != null && token != null)
+            {
+                if (!contract.UnderlyingType.IsAssignableFrom(token.GetType()))
+                {
+                    throw JsonSerializationException.Create(reader, "Deserialized JSON type '{0}' is not compatible with expected type '{1}'."
+                        .FormatWith(CultureInfo.InvariantCulture, token.GetType().FullName, contract.UnderlyingType.FullName));
+                }
+            }
+
+            return token;
+        }
+
+        private JToken CreateJObject(JsonReader reader)
+        {
+            ValidationUtils.ArgumentNotNull(reader, nameof(reader));
+
+            // this is needed because we've already read inside the object, looking for metadata properties
+            using (JTokenWriter writer = new JTokenWriter())
+            {
+                writer.WriteStartObject();
+
+                do
+                {
+                    if (reader.TokenType == JsonToken.PropertyName)
+                    {
+                        string propertyName = (string)reader.Value!;
+                        if (!reader.ReadAndMoveToContent())
+                        {
+                            break;
+                        }
+
+                        if (CheckPropertyName(reader, propertyName))
+                        {
+                            continue;
+                        }
+
+                        writer.WritePropertyName(propertyName);
+                        writer.WriteToken(reader, true, true, false);
+                    }
+                    else if (reader.TokenType == JsonToken.Comment)
+                    {
+                        // eat
+                    }
+                    else
+                    {
+                        writer.WriteEndObject();
+                        return writer.Token!;
+                    }
+                } while (reader.Read());
+
+                throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
+            }
+        }
+
+        private object? CreateValueInternal(JsonReader reader, Type? objectType, JsonContract? contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerMember, object? existingValue)
+        {
+            if (contract != null && contract.ContractType == JsonContractType.Linq)
+            {
+                return CreateJToken(reader, contract);
+            }
+
+            do
+            {
+                switch (reader.TokenType)
+                {
+                    // populate a typed object or generic dictionary/array
+                    // depending upon whether an objectType was supplied
+                    case JsonToken.StartObject:
+                        return CreateObject(reader, objectType, contract, member, containerContract, containerMember, existingValue);
+                    case JsonToken.StartArray:
+                        return CreateList(reader, objectType, contract, member, existingValue, null);
+                    case JsonToken.Integer:
+                    case JsonToken.Float:
+                    case JsonToken.Boolean:
+                    case JsonToken.Date:
+                    case JsonToken.Bytes:
+                        return EnsureType(reader, reader.Value, CultureInfo.InvariantCulture, contract, objectType);
+                    case JsonToken.String:
+                        string s = (string)reader.Value!;
+
+                        // string that needs to be returned as a byte array should be base 64 decoded
+                        if (objectType == typeof(byte[]))
+                        {
+                            return Convert.FromBase64String(s);
+                        }
+
+                        // convert empty string to null automatically for nullable types
+                        if (CoerceEmptyStringToNull(objectType, contract, s))
+                        {
+                            return null;
+                        }
+
+                        return EnsureType(reader, s, CultureInfo.InvariantCulture, contract, objectType);
+                    case JsonToken.StartConstructor:
+                        string constructorName = reader.Value!.ToString();
+
+                        return EnsureType(reader, constructorName, CultureInfo.InvariantCulture, contract, objectType);
+                    case JsonToken.Null:
+                    case JsonToken.Undefined:
+#if HAVE_ADO_NET
+                        if (objectType == typeof(DBNull))
+                        {
+                            return DBNull.Value;
+                        }
+#endif
+
+                        return EnsureType(reader, reader.Value, CultureInfo.InvariantCulture, contract, objectType);
+                    case JsonToken.Raw:
+                        return new JRaw((string?)reader.Value);
+                    case JsonToken.Comment:
+                        // ignore
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token while deserializing object: " + reader.TokenType);
+                }
+            } while (reader.Read());
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
+        }
+
+        private static bool CoerceEmptyStringToNull(Type? objectType, JsonContract? contract, string s)
+        {
+            return StringUtils.IsNullOrEmpty(s) && objectType != null && objectType != typeof(string) && objectType != typeof(object) && contract != null && contract.IsNullable;
+        }
+
+        internal string GetExpectedDescription(JsonContract contract)
+        {
+            switch (contract.ContractType)
+            {
+                case JsonContractType.Object:
+                case JsonContractType.Dictionary:
+#if HAVE_BINARY_SERIALIZATION
+                case JsonContractType.Serializable:
+#endif
+#if HAVE_DYNAMIC
+                case JsonContractType.Dynamic:
+#endif
+                    return @"JSON object (e.g. {""name"":""value""})";
+                case JsonContractType.Array:
+                    return @"JSON array (e.g. [1,2,3])";
+                case JsonContractType.Primitive:
+                    return @"JSON primitive value (e.g. string, number, boolean, null)";
+                case JsonContractType.String:
+                    return @"JSON string value";
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        private JsonConverter? GetConverter(JsonContract? contract, JsonConverter? memberConverter, JsonContainerContract? containerContract, JsonProperty? containerProperty)
+        {
+            JsonConverter? converter = null;
+            if (memberConverter != null)
+            {
+                // member attribute converter
+                converter = memberConverter;
+            }
+            else if (containerProperty?.ItemConverter != null)
+            {
+                converter = containerProperty.ItemConverter;
+            }
+            else if (containerContract?.ItemConverter != null)
+            {
+                converter = containerContract.ItemConverter;
+            }
+            else if (contract != null)
+            {
+                if (contract.Converter != null)
+                {
+                    // class attribute converter
+                    converter = contract.Converter;
+                }
+                else if (Serializer.GetMatchingConverter(contract.UnderlyingType) is JsonConverter matchingConverter)
+                {
+                    // passed in converters
+                    converter = matchingConverter;
+                }
+                else if (contract.InternalConverter != null)
+                {
+                    // internally specified converter
+                    converter = contract.InternalConverter;
+                }
+            }
+            return converter;
+        }
+
+        private object? CreateObject(JsonReader reader, Type? objectType, JsonContract? contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerMember, object? existingValue)
+        {
+            string? id;
+            Type? resolvedObjectType = objectType;
+
+            if (Serializer.MetadataPropertyHandling == MetadataPropertyHandling.Ignore)
+            {
+                // don't look for metadata properties
+                reader.ReadAndAssert();
+                id = null;
+            }
+            else if (Serializer.MetadataPropertyHandling == MetadataPropertyHandling.ReadAhead)
+            {
+                if (!(reader is JTokenReader tokenReader))
+                {
+                    JToken t = JToken.ReadFrom(reader);
+                    tokenReader = (JTokenReader)t.CreateReader();
+                    tokenReader.Culture = reader.Culture;
+                    tokenReader.DateFormatString = reader.DateFormatString;
+                    tokenReader.DateParseHandling = reader.DateParseHandling;
+                    tokenReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
+                    tokenReader.FloatParseHandling = reader.FloatParseHandling;
+                    tokenReader.SupportMultipleContent = reader.SupportMultipleContent;
+
+                    // start
+                    tokenReader.ReadAndAssert();
+
+                    reader = tokenReader;
+                }
+
+                if (ReadMetadataPropertiesToken(tokenReader, ref resolvedObjectType, ref contract, member, containerContract, containerMember, existingValue, out object? newValue, out id))
+                {
+                    return newValue;
+                }
+            }
+            else
+            {
+                reader.ReadAndAssert();
+                if (ReadMetadataProperties(reader, ref resolvedObjectType, ref contract, member, containerContract, containerMember, existingValue, out object? newValue, out id))
+                {
+                    return newValue;
+                }
+            }
+
+            if (HasNoDefinedType(contract))
+            {
+                return CreateJObject(reader);
+            }
+
+            MiscellaneousUtils.Assert(resolvedObjectType != null);
+            MiscellaneousUtils.Assert(contract != null);
+
+            switch (contract.ContractType)
+            {
+                case JsonContractType.Object:
+                {
+                    bool createdFromNonDefaultCreator = false;
+                    JsonObjectContract objectContract = (JsonObjectContract)contract;
+                    object targetObject;
+                    // check that if type name handling is being used that the existing value is compatible with the specified type
+                    if (existingValue != null && (resolvedObjectType == objectType || resolvedObjectType.IsAssignableFrom(existingValue.GetType())))
+                    {
+                        targetObject = existingValue;
+                    }
+                    else
+                    {
+                        targetObject = CreateNewObject(reader, objectContract, member, containerMember, id, out createdFromNonDefaultCreator);
+                    }
+
+                    // don't populate if read from non-default creator because the object has already been read
+                    if (createdFromNonDefaultCreator)
+                    {
+                        return targetObject;
+                    }
+
+                    return PopulateObject(targetObject, reader, objectContract, member, id);
+                }
+                case JsonContractType.Primitive:
+                {
+                    JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract)contract;
+                    // if the content is inside $value then read past it
+                    if (Serializer.MetadataPropertyHandling != MetadataPropertyHandling.Ignore
+                        && reader.TokenType == JsonToken.PropertyName
+                        && string.Equals(reader.Value!.ToString(), JsonTypeReflector.ValuePropertyName, StringComparison.Ordinal))
+                    {
+                        reader.ReadAndAssert();
+
+                        // the token should not be an object because the $type value could have been included in the object
+                        // without needing the $value property
+                        if (reader.TokenType == JsonToken.StartObject)
+                        {
+                            throw JsonSerializationException.Create(reader, "Unexpected token when deserializing primitive value: " + reader.TokenType);
+                        }
+
+                        object? value = CreateValueInternal(reader, resolvedObjectType, primitiveContract, member, null, null, existingValue);
+
+                        reader.ReadAndAssert();
+                        return value;
+                    }
+                    break;
+                }
+                case JsonContractType.Dictionary:
+                {
+                    JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)contract;
+                    object targetDictionary;
+
+                    if (existingValue == null)
+                    {
+                        IDictionary dictionary = CreateNewDictionary(reader, dictionaryContract, out bool createdFromNonDefaultCreator);
+
+                        if (createdFromNonDefaultCreator)
+                        {
+                            if (id != null)
+                            {
+                                throw JsonSerializationException.Create(reader, "Cannot preserve reference to readonly dictionary, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                            }
+
+                            if (contract.OnSerializingCallbacks.Count > 0)
+                            {
+                                throw JsonSerializationException.Create(reader, "Cannot call OnSerializing on readonly dictionary, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                            }
+
+                            if (contract.OnErrorCallbacks.Count > 0)
+                            {
+                                throw JsonSerializationException.Create(reader, "Cannot call OnError on readonly list, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                            }
+
+                            if (!dictionaryContract.HasParameterizedCreatorInternal)
+                            {
+                                throw JsonSerializationException.Create(reader, "Cannot deserialize readonly or fixed size dictionary: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                            }
+                        }
+
+                        PopulateDictionary(dictionary, reader, dictionaryContract, member, id);
+
+                        if (createdFromNonDefaultCreator)
+                        {
+                            ObjectConstructor<object> creator = (dictionaryContract.OverrideCreator ?? dictionaryContract.ParameterizedCreator)!;
+
+                            return creator(dictionary);
+                        }
+                        else if (dictionary is IWrappedDictionary wrappedDictionary)
+                        {
+                            return wrappedDictionary.UnderlyingDictionary;
+                        }
+
+                            targetDictionary = dictionary;
+                        }
+                    else
+                    {
+                        targetDictionary = PopulateDictionary(dictionaryContract.ShouldCreateWrapper || !(existingValue is IDictionary) ? dictionaryContract.CreateWrapper(existingValue) : (IDictionary)existingValue, reader, dictionaryContract, member, id);
+                    }
+
+                    return targetDictionary;
+                }
+#if HAVE_DYNAMIC
+                case JsonContractType.Dynamic:
+                    JsonDynamicContract dynamicContract = (JsonDynamicContract)contract;
+                    return CreateDynamic(reader, dynamicContract, member, id);
+#endif
+#if HAVE_BINARY_SERIALIZATION
+                case JsonContractType.Serializable:
+                    JsonISerializableContract serializableContract = (JsonISerializableContract)contract;
+                    return CreateISerializable(reader, serializableContract, member, id);
+#endif
+            }
+
+            string message = @"Cannot deserialize the current JSON object (e.g. {{""name"":""value""}}) into type '{0}' because the type requires a {1} to deserialize correctly." + Environment.NewLine +
+                             @"To fix this error either change the JSON to a {1} or change the deserialized type so that it is a normal .NET type (e.g. not a primitive type like integer, not a collection type like an array or List<T>) that can be deserialized from a JSON object. JsonObjectAttribute can also be added to the type to force it to deserialize from a JSON object." + Environment.NewLine;
+            message = message.FormatWith(CultureInfo.InvariantCulture, resolvedObjectType, GetExpectedDescription(contract));
+
+            throw JsonSerializationException.Create(reader, message);
+        }
+
+        private bool ReadMetadataPropertiesToken(JTokenReader reader, ref Type? objectType, ref JsonContract? contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerMember, object? existingValue, out object? newValue, out string? id)
+        {
+            id = null;
+            newValue = null;
+
+            if (reader.TokenType == JsonToken.StartObject)
+            {
+                JObject current = (JObject)reader.CurrentToken!;
+
+                JProperty? refProperty = current.Property(JsonTypeReflector.RefPropertyName, StringComparison.Ordinal);
+                if (refProperty != null)
+                {
+                    JToken refToken = refProperty.Value;
+                    if (refToken.Type != JTokenType.String && refToken.Type != JTokenType.Null)
+                    {
+                        throw JsonSerializationException.Create(refToken, refToken.Path, "JSON reference {0} property must have a string or null value.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName), null);
+                    }
+
+                    string? reference = (string?)refProperty;
+
+                    if (reference != null)
+                    {
+                        JToken? additionalContent = refProperty.Next ?? refProperty.Previous;
+                        if (additionalContent != null)
+                        {
+                            throw JsonSerializationException.Create(additionalContent, additionalContent.Path, "Additional content found in JSON reference object. A JSON reference object should only have a {0} property.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName), null);
+                        }
+
+                        newValue = Serializer.GetReferenceResolver().ResolveReference(this, reference);
+
+                        if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+                        {
+                            TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader, reader.Path, "Resolved object reference '{0}' to {1}.".FormatWith(CultureInfo.InvariantCulture, reference, newValue.GetType())), null);
+                        }
+
+                        reader.Skip();
+                        return true;
+                    }
+                }
+                JToken? typeToken = current[JsonTypeReflector.TypePropertyName];
+                if (typeToken != null)
+                {
+                    string? qualifiedTypeName = (string?)typeToken;
+                    JsonReader typeTokenReader = typeToken.CreateReader();
+                    typeTokenReader.ReadAndAssert();
+                    ResolveTypeName(typeTokenReader, ref objectType, ref contract, member, containerContract, containerMember, qualifiedTypeName!);
+
+                    JToken? valueToken = current[JsonTypeReflector.ValuePropertyName];
+                    if (valueToken != null)
+                    {
+                        while (true)
+                        {
+                            reader.ReadAndAssert();
+                            if (reader.TokenType == JsonToken.PropertyName)
+                            {
+                                if ((string)reader.Value! == JsonTypeReflector.ValuePropertyName)
+                                {
+                                    return false;
+                                }
+                            }
+
+                            reader.ReadAndAssert();
+                            reader.Skip();
+                        }
+                    }
+                }
+                JToken? idToken = current[JsonTypeReflector.IdPropertyName];
+                if (idToken != null)
+                {
+                    id = (string?)idToken;
+                }
+                JToken? valuesToken = current[JsonTypeReflector.ArrayValuesPropertyName];
+                if (valuesToken != null)
+                {
+                    JsonReader listReader = valuesToken.CreateReader();
+                    listReader.ReadAndAssert();
+                    newValue = CreateList(listReader, objectType, contract, member, existingValue, id);
+
+                    reader.Skip();
+                    return true;
+                }
+            }
+
+            reader.ReadAndAssert();
+            return false;
+        }
+
+        private bool ReadMetadataProperties(JsonReader reader, ref Type? objectType, ref JsonContract? contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerMember, object? existingValue, out object? newValue, out string? id)
+        {
+            id = null;
+            newValue = null;
+
+            if (reader.TokenType == JsonToken.PropertyName)
+            {
+                string propertyName = reader.Value!.ToString();
+
+                if (propertyName.Length > 0 && propertyName[0] == '$')
+                {
+                    // read metadata properties
+                    // $type, $id, $ref, etc
+                    bool metadataProperty;
+
+                    do
+                    {
+                        propertyName = reader.Value!.ToString();
+
+                        if (string.Equals(propertyName, JsonTypeReflector.RefPropertyName, StringComparison.Ordinal))
+                        {
+                            reader.ReadAndAssert();
+                            if (reader.TokenType != JsonToken.String && reader.TokenType != JsonToken.Null)
+                            {
+                                throw JsonSerializationException.Create(reader, "JSON reference {0} property must have a string or null value.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName));
+                            }
+
+                            string? reference = reader.Value?.ToString();
+
+                            reader.ReadAndAssert();
+
+                            if (reference != null)
+                            {
+                                if (reader.TokenType == JsonToken.PropertyName)
+                                {
+                                    throw JsonSerializationException.Create(reader, "Additional content found in JSON reference object. A JSON reference object should only have a {0} property.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName));
+                                }
+
+                                newValue = Serializer.GetReferenceResolver().ResolveReference(this, reference);
+
+                                if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+                                {
+                                    TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Resolved object reference '{0}' to {1}.".FormatWith(CultureInfo.InvariantCulture, reference, newValue!.GetType())), null);
+                                }
+
+                                return true;
+                            }
+                            else
+                            {
+                                metadataProperty = true;
+                            }
+                        }
+                        else if (string.Equals(propertyName, JsonTypeReflector.TypePropertyName, StringComparison.Ordinal))
+                        {
+                            reader.ReadAndAssert();
+                            string qualifiedTypeName = reader.Value!.ToString();
+
+                            ResolveTypeName(reader, ref objectType, ref contract, member, containerContract, containerMember, qualifiedTypeName);
+
+                            reader.ReadAndAssert();
+
+                            metadataProperty = true;
+                        }
+                        else if (string.Equals(propertyName, JsonTypeReflector.IdPropertyName, StringComparison.Ordinal))
+                        {
+                            reader.ReadAndAssert();
+
+                            id = reader.Value?.ToString();
+
+                            reader.ReadAndAssert();
+                            metadataProperty = true;
+                        }
+                        else if (string.Equals(propertyName, JsonTypeReflector.ArrayValuesPropertyName, StringComparison.Ordinal))
+                        {
+                            reader.ReadAndAssert();
+                            object? list = CreateList(reader, objectType, contract, member, existingValue, id);
+                            reader.ReadAndAssert();
+                            newValue = list;
+                            return true;
+                        }
+                        else
+                        {
+                            metadataProperty = false;
+                        }
+                    } while (metadataProperty && reader.TokenType == JsonToken.PropertyName);
+                }
+            }
+            return false;
+        }
+
+        private void ResolveTypeName(JsonReader reader, ref Type? objectType, ref JsonContract? contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerMember, string qualifiedTypeName)
+        {
+            TypeNameHandling resolvedTypeNameHandling =
+                member?.TypeNameHandling
+                ?? containerContract?.ItemTypeNameHandling
+                ?? containerMember?.ItemTypeNameHandling
+                ?? Serializer._typeNameHandling;
+
+            if (resolvedTypeNameHandling != TypeNameHandling.None)
+            {
+                StructMultiKey<string?, string> typeNameKey = ReflectionUtils.SplitFullyQualifiedTypeName(qualifiedTypeName);
+
+                Type specifiedType;
+                try
+                {
+                    specifiedType = Serializer._serializationBinder.BindToType(typeNameKey.Value1, typeNameKey.Value2);
+                }
+                catch (Exception ex)
+                {
+                    throw JsonSerializationException.Create(reader, "Error resolving type specified in JSON '{0}'.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName), ex);
+                }
+
+                if (specifiedType == null)
+                {
+                    throw JsonSerializationException.Create(reader, "Type specified in JSON '{0}' was not resolved.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName));
+                }
+
+                if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                {
+                    TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Resolved type '{0}' to {1}.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName, specifiedType)), null);
+                }
+
+                if (objectType != null
+#if HAVE_DYNAMIC
+                    && objectType != typeof(IDynamicMetaObjectProvider)
+#endif
+                    && !objectType.IsAssignableFrom(specifiedType))
+                {
+                    throw JsonSerializationException.Create(reader, "Type specified in JSON '{0}' is not compatible with '{1}'.".FormatWith(CultureInfo.InvariantCulture, specifiedType.AssemblyQualifiedName, objectType.AssemblyQualifiedName));
+                }
+
+                objectType = specifiedType;
+                contract = GetContract(specifiedType);
+            }
+        }
+
+        private JsonArrayContract EnsureArrayContract(JsonReader reader, Type objectType, JsonContract contract)
+        {
+            if (contract == null)
+            {
+                throw JsonSerializationException.Create(reader, "Could not resolve type '{0}' to a JsonContract.".FormatWith(CultureInfo.InvariantCulture, objectType));
+            }
+
+            if (!(contract is JsonArrayContract arrayContract))
+            {
+                string message = @"Cannot deserialize the current JSON array (e.g. [1,2,3]) into type '{0}' because the type requires a {1} to deserialize correctly." + Environment.NewLine +
+                                 @"To fix this error either change the JSON to a {1} or change the deserialized type to an array or a type that implements a collection interface (e.g. ICollection, IList) like List<T> that can be deserialized from a JSON array. JsonArrayAttribute can also be added to the type to force it to deserialize from a JSON array." + Environment.NewLine;
+                message = message.FormatWith(CultureInfo.InvariantCulture, objectType, GetExpectedDescription(contract));
+
+                throw JsonSerializationException.Create(reader, message);
+            }
+
+            return arrayContract;
+        }
+
+        private object? CreateList(JsonReader reader, Type? objectType, JsonContract? contract, JsonProperty? member, object? existingValue, string? id)
+        {
+            object? value;
+
+            if (HasNoDefinedType(contract))
+            {
+                return CreateJToken(reader, contract);
+            }
+
+            MiscellaneousUtils.Assert(objectType != null);
+            MiscellaneousUtils.Assert(contract != null);
+
+            JsonArrayContract arrayContract = EnsureArrayContract(reader, objectType, contract);
+
+            if (existingValue == null)
+            {
+                IList list = CreateNewList(reader, arrayContract, out bool createdFromNonDefaultCreator);
+
+                if (createdFromNonDefaultCreator)
+                {
+                    if (id != null)
+                    {
+                        throw JsonSerializationException.Create(reader, "Cannot preserve reference to array or readonly list, or list created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                    }
+
+                    if (contract.OnSerializingCallbacks.Count > 0)
+                    {
+                        throw JsonSerializationException.Create(reader, "Cannot call OnSerializing on an array or readonly list, or list created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                    }
+
+                    if (contract.OnErrorCallbacks.Count > 0)
+                    {
+                        throw JsonSerializationException.Create(reader, "Cannot call OnError on an array or readonly list, or list created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                    }
+
+                    if (!arrayContract.HasParameterizedCreatorInternal && !arrayContract.IsArray)
+                    {
+                        throw JsonSerializationException.Create(reader, "Cannot deserialize readonly or fixed size list: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                    }
+                }
+
+                if (!arrayContract.IsMultidimensionalArray)
+                {
+                    PopulateList(list, reader, arrayContract, member, id);
+                }
+                else
+                {
+                    PopulateMultidimensionalArray(list, reader, arrayContract, member, id);
+                }
+
+                if (createdFromNonDefaultCreator)
+                {
+                    if (arrayContract.IsMultidimensionalArray)
+                    {
+                        list = CollectionUtils.ToMultidimensionalArray(list, arrayContract.CollectionItemType!, contract.CreatedType.GetArrayRank());
+                    }
+                    else if (arrayContract.IsArray)
+                    {
+                        Array a = Array.CreateInstance(arrayContract.CollectionItemType, list.Count);
+                        list.CopyTo(a, 0);
+                        list = a;
+                    }
+                    else
+                    {
+                        ObjectConstructor<object> creator = (arrayContract.OverrideCreator ?? arrayContract.ParameterizedCreator)!;
+
+                        return creator(list);
+                    }
+                }
+                else if (list is IWrappedCollection wrappedCollection)
+                {
+                    return wrappedCollection.UnderlyingCollection;
+                }
+
+                value = list;
+            }
+            else
+            {
+                if (!arrayContract.CanDeserialize)
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.CreatedType));
+                }
+
+                value = PopulateList((arrayContract.ShouldCreateWrapper || !(existingValue is IList list)) ? arrayContract.CreateWrapper(existingValue) : list, reader, arrayContract, member, id);
+            }
+
+            return value;
+        }
+
+        private bool HasNoDefinedType(JsonContract? contract)
+        {
+            return (contract == null || contract.UnderlyingType == typeof(object) || contract.ContractType == JsonContractType.Linq
+#if HAVE_DYNAMIC
+                    || contract.UnderlyingType == typeof(IDynamicMetaObjectProvider)
+#endif
+                );
+        }
+
+        private object? EnsureType(JsonReader reader, object? value, CultureInfo culture, JsonContract? contract, Type? targetType)
+        {
+            if (targetType == null)
+            {
+                return value;
+            }
+
+            MiscellaneousUtils.Assert(contract != null);
+            Type? valueType = ReflectionUtils.GetObjectType(value);
+
+            // type of value and type of target don't match
+            // attempt to convert value's type to target's type
+            if (valueType != targetType)
+            {
+                if (value == null && contract.IsNullable)
+                {
+                    return null;
+                }
+
+                try
+                {
+                    if (contract.IsConvertable)
+                    {
+                        JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract)contract;
+
+                        if (contract.IsEnum)
+                        {
+                            if (value is string s)
+                            {
+                                return EnumUtils.ParseEnum(
+                                    contract.NonNullableUnderlyingType,
+                                    null,
+                                    s,
+                                    false);
+                            }
+                            if (ConvertUtils.IsInteger(primitiveContract.TypeCode))
+                            {
+                                return Enum.ToObject(contract.NonNullableUnderlyingType, value);
+                            }
+                        }
+                        else if (contract.NonNullableUnderlyingType == typeof(DateTime))
+                        {
+                            // use DateTimeUtils because Convert.ChangeType does not set DateTime.Kind correctly
+                            if (value is string s && DateTimeUtils.TryParseDateTime(s, reader.DateTimeZoneHandling, reader.DateFormatString, reader.Culture, out DateTime dt))
+                            {
+                                return DateTimeUtils.EnsureDateTime(dt, reader.DateTimeZoneHandling);
+                            }
+                        }
+
+#if HAVE_BIG_INTEGER
+                        if (value is BigInteger integer)
+                        {
+                            return ConvertUtils.FromBigInteger(integer, contract.NonNullableUnderlyingType);
+                        }
+#endif
+
+                        // this won't work when converting to a custom IConvertible
+                        return Convert.ChangeType(value, contract.NonNullableUnderlyingType, culture);
+                    }
+
+                    return ConvertUtils.ConvertOrCast(value, culture, contract.NonNullableUnderlyingType);
+                }
+                catch (Exception ex)
+                {
+                    throw JsonSerializationException.Create(reader, "Error converting value {0} to type '{1}'.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(value), targetType), ex);
+                }
+            }
+
+            return value;
+        }
+
+        private bool SetPropertyValue(JsonProperty property, JsonConverter? propertyConverter, JsonContainerContract? containerContract, JsonProperty? containerProperty, JsonReader reader, object target)
+        {
+            bool skipSettingProperty = CalculatePropertyDetails(
+                property,
+                ref propertyConverter,
+                containerContract,
+                containerProperty,
+                reader,
+                target,
+                out bool useExistingValue,
+                out object? currentValue,
+                out JsonContract? propertyContract,
+                out bool gottenCurrentValue,
+                out bool ignoredValue);
+
+            if (skipSettingProperty)
+            {
+                // Don't set extension data if the value was ignored
+                // e.g. a null with NullValueHandling should not go in ExtensionData
+                if (ignoredValue)
+                {
+                    return true;
+                }
+
+                return false;
+            }
+
+            object? value;
+
+            if (propertyConverter != null && propertyConverter.CanRead)
+            {
+                if (!gottenCurrentValue && property.Readable)
+                {
+                    currentValue = property.ValueProvider!.GetValue(target);
+                }
+
+                value = DeserializeConvertable(propertyConverter, reader, property.PropertyType!, currentValue);
+            }
+            else
+            {
+                value = CreateValueInternal(reader, property.PropertyType, propertyContract, property, containerContract, containerProperty, (useExistingValue) ? currentValue : null);
+            }
+
+            // always set the value if useExistingValue is false,
+            // otherwise also set it if CreateValue returns a new value compared to the currentValue
+            // this could happen because of a JsonConverter against the type
+            if ((!useExistingValue || value != currentValue)
+                && ShouldSetPropertyValue(property, containerContract as JsonObjectContract, value))
+            {
+                property.ValueProvider!.SetValue(target, value);
+
+                if (property.SetIsSpecified != null)
+                {
+                    if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                    {
+                        TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "IsSpecified for property '{0}' on {1} set to true.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType)), null);
+                    }
+
+                    property.SetIsSpecified(target, true);
+                }
+
+                return true;
+            }
+
+            // the value wasn't set be JSON was populated onto the existing value
+            return useExistingValue;
+        }
+
+        private bool CalculatePropertyDetails(
+            JsonProperty property,
+            ref JsonConverter? propertyConverter,
+            JsonContainerContract? containerContract,
+            JsonProperty? containerProperty,
+            JsonReader reader,
+            object target,
+            out bool useExistingValue,
+            out object? currentValue,
+            out JsonContract? propertyContract,
+            out bool gottenCurrentValue,
+            out bool ignoredValue)
+        {
+            currentValue = null;
+            useExistingValue = false;
+            propertyContract = null;
+            gottenCurrentValue = false;
+            ignoredValue = false;
+
+            if (property.Ignored)
+            {
+                return true;
+            }
+
+            JsonToken tokenType = reader.TokenType;
+
+            if (property.PropertyContract == null)
+            {
+                property.PropertyContract = GetContractSafe(property.PropertyType);
+            }
+
+            ObjectCreationHandling objectCreationHandling =
+                property.ObjectCreationHandling.GetValueOrDefault(Serializer._objectCreationHandling);
+
+            if ((objectCreationHandling != ObjectCreationHandling.Replace)
+                && (tokenType == JsonToken.StartArray || tokenType == JsonToken.StartObject || propertyConverter != null)
+                && property.Readable)
+            {
+                currentValue = property.ValueProvider!.GetValue(target);
+                gottenCurrentValue = true;
+
+                if (currentValue != null)
+                {
+                    propertyContract = GetContract(currentValue.GetType());
+
+                    useExistingValue = (!propertyContract.IsReadOnlyOrFixedSize && !propertyContract.UnderlyingType.IsValueType());
+                }
+            }
+
+            if (!property.Writable && !useExistingValue)
+            {
+                if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+                {
+                    TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Unable to deserialize value to non-writable property '{0}' on {1}.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType)), null);
+                }
+
+                return true;
+            }
+
+            // test tokenType here because null might not be convertible to some types, e.g. ignoring null when applied to DateTime
+            if (tokenType == JsonToken.Null && ResolvedNullValueHandling(containerContract as JsonObjectContract, property) == NullValueHandling.Ignore)
+            {
+                ignoredValue = true;
+                return true;
+            }
+
+            // test tokenType here because default value might not be convertible to actual type, e.g. default of "" for DateTime
+            if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Ignore)
+                && !HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Populate)
+                && JsonTokenUtils.IsPrimitiveToken(tokenType)
+                && MiscellaneousUtils.ValueEquals(reader.Value, property.GetResolvedDefaultValue()))
+            {
+                ignoredValue = true;
+                return true;
+            }
+
+            if (currentValue == null)
+            {
+                propertyContract = property.PropertyContract;
+            }
+            else
+            {
+                propertyContract = GetContract(currentValue.GetType());
+
+                if (propertyContract != property.PropertyContract)
+                {
+                    propertyConverter = GetConverter(propertyContract, property.Converter, containerContract, containerProperty);
+                }
+            }
+
+            return false;
+        }
+
+        private void AddReference(JsonReader reader, string id, object value)
+        {
+            try
+            {
+                if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                {
+                    TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Read object reference Id '{0}' for {1}.".FormatWith(CultureInfo.InvariantCulture, id, value.GetType())), null);
+                }
+
+                Serializer.GetReferenceResolver().AddReference(this, id, value);
+            }
+            catch (Exception ex)
+            {
+                throw JsonSerializationException.Create(reader, "Error reading object reference '{0}'.".FormatWith(CultureInfo.InvariantCulture, id), ex);
+            }
+        }
+
+        private bool HasFlag(DefaultValueHandling value, DefaultValueHandling flag)
+        {
+            return ((value & flag) == flag);
+        }
+
+        private bool ShouldSetPropertyValue(JsonProperty property, JsonObjectContract? contract, object? value)
+        {
+            if (value == null && ResolvedNullValueHandling(contract, property) == NullValueHandling.Ignore)
+            {
+                return false;
+            }
+
+            if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Ignore)
+                && !HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Populate)
+                && MiscellaneousUtils.ValueEquals(value, property.GetResolvedDefaultValue()))
+            {
+                return false;
+            }
+
+            if (!property.Writable)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private IList CreateNewList(JsonReader reader, JsonArrayContract contract, out bool createdFromNonDefaultCreator)
+        {
+            // some types like non-generic IEnumerable can be serialized but not deserialized
+            if (!contract.CanDeserialize)
+            {
+                throw JsonSerializationException.Create(reader, "Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.CreatedType));
+            }
+
+            if (contract.OverrideCreator != null)
+            {
+                if (contract.HasParameterizedCreator)
+                {
+                    createdFromNonDefaultCreator = true;
+                    return contract.CreateTemporaryCollection();
+                }
+                else
+                {
+                    object list = contract.OverrideCreator();
+
+                    if (contract.ShouldCreateWrapper)
+                    {
+                        list = contract.CreateWrapper(list);
+                    }
+
+                    createdFromNonDefaultCreator = false;
+                    return (IList)list;
+                }
+            }
+            else if (contract.IsReadOnlyOrFixedSize)
+            {
+                createdFromNonDefaultCreator = true;
+                IList list = contract.CreateTemporaryCollection();
+
+                if (contract.ShouldCreateWrapper)
+                {
+                    list = contract.CreateWrapper(list);
+                }
+
+                return list;
+            }
+            else if (contract.DefaultCreator != null && (!contract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
+            {
+                object list = contract.DefaultCreator();
+
+                if (contract.ShouldCreateWrapper)
+                {
+                    list = contract.CreateWrapper(list);
+                }
+
+                createdFromNonDefaultCreator = false;
+                return (IList)list;
+            }
+            else if (contract.HasParameterizedCreatorInternal)
+            {
+                createdFromNonDefaultCreator = true;
+                return contract.CreateTemporaryCollection();
+            }
+            else
+            {
+                if (!contract.IsInstantiable)
+                {
+                    throw JsonSerializationException.Create(reader, "Could not create an instance of type {0}. Type is an interface or abstract class and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                }
+
+                throw JsonSerializationException.Create(reader, "Unable to find a constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+            }
+        }
+
+        private IDictionary CreateNewDictionary(JsonReader reader, JsonDictionaryContract contract, out bool createdFromNonDefaultCreator)
+        {
+            if (contract.OverrideCreator != null)
+            {
+                if (contract.HasParameterizedCreator)
+                {
+                    createdFromNonDefaultCreator = true;
+                    return contract.CreateTemporaryDictionary();
+                }
+                else
+                {
+                    createdFromNonDefaultCreator = false;
+                    return (IDictionary)contract.OverrideCreator();
+                }
+            }
+            else if (contract.IsReadOnlyOrFixedSize)
+            {
+                createdFromNonDefaultCreator = true;
+                return contract.CreateTemporaryDictionary();
+            }
+            else if (contract.DefaultCreator != null && (!contract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
+            {
+                object dictionary = contract.DefaultCreator();
+
+                if (contract.ShouldCreateWrapper)
+                {
+                    dictionary = contract.CreateWrapper(dictionary);
+                }
+
+                createdFromNonDefaultCreator = false;
+                return (IDictionary)dictionary;
+            }
+            else if (contract.HasParameterizedCreatorInternal)
+            {
+                createdFromNonDefaultCreator = true;
+                return contract.CreateTemporaryDictionary();
+            }
+            else
+            {
+                if (!contract.IsInstantiable)
+                {
+                    throw JsonSerializationException.Create(reader, "Could not create an instance of type {0}. Type is an interface or abstract class and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+                }
+
+                throw JsonSerializationException.Create(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+            }
+        }
+
+        private void OnDeserializing(JsonReader reader, JsonContract contract, object value)
+        {
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Started deserializing {0}".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)), null);
+            }
+
+            contract.InvokeOnDeserializing(value, Serializer._context);
+        }
+
+        private void OnDeserialized(JsonReader reader, JsonContract contract, object value)
+        {
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Finished deserializing {0}".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)), null);
+            }
+
+            contract.InvokeOnDeserialized(value, Serializer._context);
+        }
+
+        private object PopulateDictionary(IDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, JsonProperty? containerProperty, string? id)
+        {
+            object underlyingDictionary = dictionary is IWrappedDictionary wrappedDictionary ? wrappedDictionary.UnderlyingDictionary : dictionary;
+
+            if (id != null)
+            {
+                AddReference(reader, id, underlyingDictionary);
+            }
+
+            OnDeserializing(reader, contract, underlyingDictionary);
+
+            int initialDepth = reader.Depth;
+
+            if (contract.KeyContract == null)
+            {
+                contract.KeyContract = GetContractSafe(contract.DictionaryKeyType);
+            }
+
+            if (contract.ItemContract == null)
+            {
+                contract.ItemContract = GetContractSafe(contract.DictionaryValueType);
+            }
+
+            JsonConverter? dictionaryValueConverter = contract.ItemConverter ?? GetConverter(contract.ItemContract, null, contract, containerProperty);
+            PrimitiveTypeCode keyTypeCode = (contract.KeyContract is JsonPrimitiveContract keyContract) ? keyContract.TypeCode : PrimitiveTypeCode.Empty;
+
+            bool finished = false;
+            do
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        object keyValue = reader.Value!;
+                        if (CheckPropertyName(reader, keyValue.ToString()))
+                        {
+                            continue;
+                        }
+
+                        try
+                        {
+                            try
+                            {
+                                // this is for correctly reading ISO and MS formatted dictionary keys
+                                switch (keyTypeCode)
+                                {
+                                    case PrimitiveTypeCode.DateTime:
+                                    case PrimitiveTypeCode.DateTimeNullable:
+                                    {
+                                        keyValue = DateTimeUtils.TryParseDateTime(keyValue.ToString(), reader.DateTimeZoneHandling, reader.DateFormatString, reader.Culture, out DateTime dt)
+                                            ? dt
+                                            : EnsureType(reader, keyValue, CultureInfo.InvariantCulture, contract.KeyContract, contract.DictionaryKeyType)!;
+                                        break;
+                                    }
+#if HAVE_DATE_TIME_OFFSET
+                                    case PrimitiveTypeCode.DateTimeOffset:
+                                    case PrimitiveTypeCode.DateTimeOffsetNullable:
+                                    {
+                                        keyValue = DateTimeUtils.TryParseDateTimeOffset(keyValue.ToString(), reader.DateFormatString, reader.Culture, out DateTimeOffset dt)
+                                            ? dt
+                                            : EnsureType(reader, keyValue, CultureInfo.InvariantCulture, contract.KeyContract, contract.DictionaryKeyType)!;
+                                        break;
+                                    }
+#endif
+                                    default:
+                                        keyValue = contract.KeyContract != null && contract.KeyContract.IsEnum
+                                            ? EnumUtils.ParseEnum(contract.KeyContract.NonNullableUnderlyingType, (Serializer._contractResolver as DefaultContractResolver)?.NamingStrategy, keyValue.ToString(), false)
+                                            : EnsureType(reader, keyValue, CultureInfo.InvariantCulture, contract.KeyContract, contract.DictionaryKeyType)!;
+                                        break;
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                throw JsonSerializationException.Create(reader, "Could not convert string '{0}' to dictionary key type '{1}'. Create a TypeConverter to convert from the string to the key type object.".FormatWith(CultureInfo.InvariantCulture, reader.Value, contract.DictionaryKeyType), ex);
+                            }
+
+                            if (!reader.ReadForType(contract.ItemContract, dictionaryValueConverter != null))
+                            {
+                                throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
+                            }
+
+                            object? itemValue;
+                            if (dictionaryValueConverter != null && dictionaryValueConverter.CanRead)
+                            {
+                                itemValue = DeserializeConvertable(dictionaryValueConverter, reader, contract.DictionaryValueType!, null);
+                            }
+                            else
+                            {
+                                itemValue = CreateValueInternal(reader, contract.DictionaryValueType, contract.ItemContract, null, contract, containerProperty, null);
+                            }
+
+                            dictionary[keyValue] = itemValue;
+                        }
+                        catch (Exception ex)
+                        {
+                            if (IsErrorHandled(underlyingDictionary, contract, keyValue, reader as IJsonLineInfo, reader.Path, ex))
+                            {
+                                HandleError(reader, true, initialDepth);
+                            }
+                            else
+                            {
+                                throw;
+                            }
+                        }
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        finished = true;
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
+                }
+            } while (!finished && reader.Read());
+
+            if (!finished)
+            {
+                ThrowUnexpectedEndException(reader, contract, underlyingDictionary, "Unexpected end when deserializing object.");
+            }
+
+            OnDeserialized(reader, contract, underlyingDictionary);
+            return underlyingDictionary;
+        }
+
+        private object PopulateMultidimensionalArray(IList list, JsonReader reader, JsonArrayContract contract, JsonProperty? containerProperty, string? id)
+        {
+            int rank = contract.UnderlyingType.GetArrayRank();
+
+            if (id != null)
+            {
+                AddReference(reader, id, list);
+            }
+
+            OnDeserializing(reader, contract, list);
+
+            JsonContract? collectionItemContract = GetContractSafe(contract.CollectionItemType);
+            JsonConverter? collectionItemConverter = GetConverter(collectionItemContract, null, contract, containerProperty);
+
+            int? previousErrorIndex = null;
+            Stack<IList> listStack = new Stack<IList>();
+            listStack.Push(list);
+            IList currentList = list;
+
+            bool finished = false;
+            do
+            {
+                int initialDepth = reader.Depth;
+
+                if (listStack.Count == rank)
+                {
+                    try
+                    {
+                        if (reader.ReadForType(collectionItemContract, collectionItemConverter != null))
+                        {
+                            switch (reader.TokenType)
+                            {
+                                case JsonToken.EndArray:
+                                    listStack.Pop();
+                                    currentList = listStack.Peek();
+                                    previousErrorIndex = null;
+                                    break;
+                                case JsonToken.Comment:
+                                    break;
+                                default:
+                                    object? value;
+
+                                    if (collectionItemConverter != null && collectionItemConverter.CanRead)
+                                    {
+                                        value = DeserializeConvertable(collectionItemConverter, reader, contract.CollectionItemType!, null);
+                                    }
+                                    else
+                                    {
+                                        value = CreateValueInternal(reader, contract.CollectionItemType, collectionItemContract, null, contract, containerProperty, null);
+                                    }
+
+                                    currentList.Add(value);
+                                    break;
+                            }
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        JsonPosition errorPosition = reader.GetPosition(initialDepth);
+
+                        if (IsErrorHandled(list, contract, errorPosition.Position, reader as IJsonLineInfo, reader.Path, ex))
+                        {
+                            HandleError(reader, true, initialDepth + 1);
+
+                            if (previousErrorIndex != null && previousErrorIndex == errorPosition.Position)
+                            {
+                                // reader index has not moved since previous error handling
+                                // break out of reading array to prevent infinite loop
+                                throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
+                            }
+                            else
+                            {
+                                previousErrorIndex = errorPosition.Position;
+                            }
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+                else
+                {
+                    if (reader.Read())
+                    {
+                        switch (reader.TokenType)
+                        {
+                            case JsonToken.StartArray:
+                                IList newList = new List<object>();
+                                currentList.Add(newList);
+                                listStack.Push(newList);
+                                currentList = newList;
+                                break;
+                            case JsonToken.EndArray:
+                                listStack.Pop();
+
+                                if (listStack.Count > 0)
+                                {
+                                    currentList = listStack.Peek();
+                                }
+                                else
+                                {
+                                    finished = true;
+                                }
+                                break;
+                            case JsonToken.Comment:
+                                break;
+                            default:
+                                throw JsonSerializationException.Create(reader, "Unexpected token when deserializing multidimensional array: " + reader.TokenType);
+                        }
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            } while (!finished);
+
+            if (!finished)
+            {
+                ThrowUnexpectedEndException(reader, contract, list, "Unexpected end when deserializing array.");
+            }
+
+            OnDeserialized(reader, contract, list);
+            return list;
+        }
+
+        private void ThrowUnexpectedEndException(JsonReader reader, JsonContract contract, object? currentObject, string message)
+        {
+            try
+            {
+                throw JsonSerializationException.Create(reader, message);
+            }
+            catch (Exception ex)
+            {
+                if (IsErrorHandled(currentObject, contract, null, reader as IJsonLineInfo, reader.Path, ex))
+                {
+                    HandleError(reader, false, 0);
+                }
+                else
+                {
+                    throw;
+                }
+            }
+        }
+
+        private object PopulateList(IList list, JsonReader reader, JsonArrayContract contract, JsonProperty? containerProperty, string? id)
+        {
+#pragma warning disable CS8600, CS8602, CS8603, CS8604
+            object underlyingList = list is IWrappedCollection wrappedCollection ? wrappedCollection.UnderlyingCollection : list;
+
+            if (id != null)
+            {
+                AddReference(reader, id, underlyingList);
+            }
+
+            // can't populate an existing array
+            if (list.IsFixedSize)
+            {
+                reader.Skip();
+                return underlyingList;
+            }
+
+            OnDeserializing(reader, contract, underlyingList);
+
+            int initialDepth = reader.Depth;
+
+            if (contract.ItemContract == null)
+            {
+                contract.ItemContract = GetContractSafe(contract.CollectionItemType);
+            }
+
+            JsonConverter? collectionItemConverter = GetConverter(contract.ItemContract, null, contract, containerProperty);
+
+            int? previousErrorIndex = null;
+
+            bool finished = false;
+            do
+            {
+                try
+                {
+                    if (reader.ReadForType(contract.ItemContract, collectionItemConverter != null))
+                    {
+                        switch (reader.TokenType)
+                        {
+                            case JsonToken.EndArray:
+                                finished = true;
+                                break;
+                            case JsonToken.Comment:
+                                break;
+                            default:
+                                object? value;
+
+                                if (collectionItemConverter != null && collectionItemConverter.CanRead)
+                                {
+                                    value = DeserializeConvertable(collectionItemConverter, reader, contract.CollectionItemType, null);
+                                }
+                                else
+                                {
+                                    value = CreateValueInternal(reader, contract.CollectionItemType, contract.ItemContract, null, contract, containerProperty, null);
+                                }
+
+                                list.Add(value);
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    JsonPosition errorPosition = reader.GetPosition(initialDepth);
+
+                    if (IsErrorHandled(underlyingList, contract, errorPosition.Position, reader as IJsonLineInfo, reader.Path, ex))
+                    {
+                        HandleError(reader, true, initialDepth + 1);
+
+                        if (previousErrorIndex != null && previousErrorIndex == errorPosition.Position)
+                        {
+                            // reader index has not moved since previous error handling
+                            // break out of reading array to prevent infinite loop
+                            throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
+                        }
+                        else
+                        {
+                            previousErrorIndex = errorPosition.Position;
+                        }
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            } while (!finished);
+
+            if (!finished)
+            {
+                ThrowUnexpectedEndException(reader, contract, underlyingList, "Unexpected end when deserializing array.");
+            }
+
+            OnDeserialized(reader, contract, underlyingList);
+            return underlyingList;
+#pragma warning restore CS8600, CS8602, CS8603, CS8604
+        }
+
+#if HAVE_BINARY_SERIALIZATION
+        private object CreateISerializable(JsonReader reader, JsonISerializableContract contract, JsonProperty? member, string? id)
+        {
+            Type objectType = contract.UnderlyingType;
+
+            if (!JsonTypeReflector.FullyTrusted)
+            {
+                string message = @"Type '{0}' implements ISerializable but cannot be deserialized using the ISerializable interface because the current application is not fully trusted and ISerializable can expose secure data." + Environment.NewLine +
+                                 @"To fix this error either change the environment to be fully trusted, change the application to not deserialize the type, add JsonObjectAttribute to the type or change the JsonSerializer setting ContractResolver to use a new DefaultContractResolver with IgnoreSerializableInterface set to true." + Environment.NewLine;
+                message = message.FormatWith(CultureInfo.InvariantCulture, objectType);
+
+                throw JsonSerializationException.Create(reader, message);
+            }
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Deserializing {0} using ISerializable constructor.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)), null);
+            }
+
+            SerializationInfo serializationInfo = new SerializationInfo(contract.UnderlyingType, new JsonFormatterConverter(this, contract, member));
+
+            bool finished = false;
+            do
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string memberName = reader.Value!.ToString();
+                        if (!reader.Read())
+                        {
+                            throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
+                        }
+                        serializationInfo.AddValue(memberName, JToken.ReadFrom(reader));
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        finished = true;
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
+                }
+            } while (!finished && reader.Read());
+
+            if (!finished)
+            {
+                ThrowUnexpectedEndException(reader, contract, serializationInfo, "Unexpected end when deserializing object.");
+            }
+
+            if (!contract.IsInstantiable)
+            {
+                throw JsonSerializationException.Create(reader, "Could not create an instance of type {0}. Type is an interface or abstract class and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+            }
+
+            if (contract.ISerializableCreator == null)
+            {
+                throw JsonSerializationException.Create(reader, "ISerializable type '{0}' does not have a valid constructor. To correctly implement ISerializable a constructor that takes SerializationInfo and StreamingContext parameters should be present.".FormatWith(CultureInfo.InvariantCulture, objectType));
+            }
+
+            object createdObject = contract.ISerializableCreator(serializationInfo, Serializer._context);
+
+            if (id != null)
+            {
+                AddReference(reader, id, createdObject);
+            }
+
+            // these are together because OnDeserializing takes an object but for an ISerializable the object is fully created in the constructor
+            OnDeserializing(reader, contract, createdObject);
+            OnDeserialized(reader, contract, createdObject);
+
+            return createdObject;
+        }
+
+        internal object? CreateISerializableItem(JToken token, Type type, JsonISerializableContract contract, JsonProperty? member)
+        {
+            JsonContract? itemContract = GetContractSafe(type);
+            JsonConverter? itemConverter = GetConverter(itemContract, null, contract, member);
+
+            JsonReader tokenReader = token.CreateReader();
+            tokenReader.ReadAndAssert(); // Move to first token
+
+            object? result;
+            if (itemConverter != null && itemConverter.CanRead)
+            {
+                result = DeserializeConvertable(itemConverter, tokenReader, type, null);
+            }
+            else
+            {
+                result = CreateValueInternal(tokenReader, type, itemContract, null, contract, member, null);
+            }
+
+            return result;
+        }
+#endif
+
+#if HAVE_DYNAMIC
+        private object CreateDynamic(JsonReader reader, JsonDynamicContract contract, JsonProperty? member, string? id)
+        {
+            IDynamicMetaObjectProvider newObject;
+
+            if (!contract.IsInstantiable)
+            {
+                throw JsonSerializationException.Create(reader, "Could not create an instance of type {0}. Type is an interface or abstract class and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+            }
+
+            if (contract.DefaultCreator != null &&
+                (!contract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
+            {
+                newObject = (IDynamicMetaObjectProvider)contract.DefaultCreator();
+            }
+            else
+            {
+                throw JsonSerializationException.Create(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
+            }
+
+            if (id != null)
+            {
+                AddReference(reader, id, newObject);
+            }
+
+            OnDeserializing(reader, contract, newObject);
+
+            int initialDepth = reader.Depth;
+
+            bool finished = false;
+            do
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string memberName = reader.Value!.ToString();
+
+                        try
+                        {
+                            if (!reader.Read())
+                            {
+                                throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
+                            }
+
+                            // first attempt to find a settable property, otherwise fall back to a dynamic set without type
+                            JsonProperty? property = contract.Properties.GetClosestMatchProperty(memberName);
+
+                            if (property != null && property.Writable && !property.Ignored)
+                            {
+                                if (property.PropertyContract == null)
+                                {
+                                    property.PropertyContract = GetContractSafe(property.PropertyType);
+                                }
+
+                                JsonConverter? propertyConverter = GetConverter(property.PropertyContract, property.Converter, null, null);
+
+                                if (!SetPropertyValue(property, propertyConverter, null, member, reader, newObject))
+                                {
+                                    reader.Skip();
+                                }
+                            }
+                            else
+                            {
+                                Type t = (JsonTokenUtils.IsPrimitiveToken(reader.TokenType)) ? reader.ValueType! : typeof(IDynamicMetaObjectProvider);
+
+                                JsonContract? dynamicMemberContract = GetContractSafe(t);
+                                JsonConverter? dynamicMemberConverter = GetConverter(dynamicMemberContract, null, null, member);
+
+                                object? value;
+                                if (dynamicMemberConverter != null && dynamicMemberConverter.CanRead)
+                                {
+                                    value = DeserializeConvertable(dynamicMemberConverter!, reader, t, null);
+                                }
+                                else
+                                {
+                                    value = CreateValueInternal(reader, t, dynamicMemberContract, null, null, member, null);
+                                }
+
+                                contract.TrySetMember(newObject, memberName, value);
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            if (IsErrorHandled(newObject, contract, memberName, reader as IJsonLineInfo, reader.Path, ex))
+                            {
+                                HandleError(reader, true, initialDepth);
+                            }
+                            else
+                            {
+                                throw;
+                            }
+                        }
+                        break;
+                    case JsonToken.EndObject:
+                        finished = true;
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
+                }
+            } while (!finished && reader.Read());
+
+            if (!finished)
+            {
+                ThrowUnexpectedEndException(reader, contract, newObject, "Unexpected end when deserializing object.");
+            }
+
+            OnDeserialized(reader, contract, newObject);
+
+            return newObject;
+        }
+#endif
+
+        internal class CreatorPropertyContext
+        {
+            public readonly string Name;
+            public JsonProperty? Property;
+            public JsonProperty? ConstructorProperty;
+            public PropertyPresence? Presence;
+            public object? Value;
+            public bool Used;
+
+            public CreatorPropertyContext(string name)
+            {
+                Name = name;
+            }
+        }
+
+        private object CreateObjectUsingCreatorWithParameters(JsonReader reader, JsonObjectContract contract, JsonProperty? containerProperty, ObjectConstructor<object> creator, string? id)
+        {
+            ValidationUtils.ArgumentNotNull(creator, nameof(creator));
+
+            // only need to keep a track of properties' presence if they are required or a value should be defaulted if missing
+            bool trackPresence = (contract.HasRequiredOrDefaultValueProperties || HasFlag(Serializer._defaultValueHandling, DefaultValueHandling.Populate));
+
+            Type objectType = contract.UnderlyingType;
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                string parameters = string.Join(", ", contract.CreatorParameters.Select(p => p.PropertyName)
+#if !HAVE_STRING_JOIN_WITH_ENUMERABLE
+                    .ToArray()
+#endif
+                    );
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Deserializing {0} using creator with parameters: {1}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType, parameters)), null);
+            }
+
+            List<CreatorPropertyContext> propertyContexts = ResolvePropertyAndCreatorValues(contract, containerProperty, reader, objectType);
+            if (trackPresence)
+            {
+                foreach (JsonProperty property in contract.Properties)
+                {
+                    if (!property.Ignored)
+                    {
+                        if (propertyContexts.All(p => p.Property != property))
+                        {
+                            propertyContexts.Add(new CreatorPropertyContext(property.PropertyName!)
+                            {
+                                Property = property,
+                                Presence = PropertyPresence.None
+                            });
+                        }
+                    }
+                }
+            }
+
+            object?[] creatorParameterValues = new object?[contract.CreatorParameters.Count];
+
+            foreach (CreatorPropertyContext context in propertyContexts)
+            {
+                // set presence of read values
+                if (trackPresence)
+                {
+                    if (context.Property != null && context.Presence == null)
+                    {
+                        object? v = context.Value;
+                        PropertyPresence propertyPresence;
+                        if (v == null)
+                        {
+                            propertyPresence = PropertyPresence.Null;
+                        }
+                        else if (v is string s)
+                        {
+                            propertyPresence = CoerceEmptyStringToNull(context.Property.PropertyType, context.Property.PropertyContract, s)
+                                ? PropertyPresence.Null
+                                : PropertyPresence.Value;
+                        }
+                        else
+                        {
+                            propertyPresence = PropertyPresence.Value;
+                        }
+
+                        context.Presence = propertyPresence;
+                    }
+                }
+
+                JsonProperty? constructorProperty = context.ConstructorProperty;
+                if (constructorProperty == null && context.Property != null)
+                {
+                    constructorProperty = contract.CreatorParameters.ForgivingCaseSensitiveFind(p => p.PropertyName!, context.Property.UnderlyingName!);
+                }
+
+                if (constructorProperty != null && !constructorProperty.Ignored)
+                {
+                    // handle giving default values to creator parameters
+                    // this needs to happen before the call to creator
+                    if (trackPresence)
+                    {
+                        if (context.Presence == PropertyPresence.None || context.Presence == PropertyPresence.Null)
+                        {
+                            if (constructorProperty.PropertyContract == null)
+                            {
+                                constructorProperty.PropertyContract = GetContractSafe(constructorProperty.PropertyType);
+                            }
+
+                            if (HasFlag(constructorProperty.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Populate))
+                            {
+                                context.Value = EnsureType(
+                                    reader,
+                                    constructorProperty.GetResolvedDefaultValue(),
+                                    CultureInfo.InvariantCulture,
+                                    constructorProperty.PropertyContract!,
+                                    constructorProperty.PropertyType);
+                            }
+                        }
+                    }
+
+                    int i = contract.CreatorParameters.IndexOf(constructorProperty);
+                    creatorParameterValues[i] = context.Value;
+
+                    context.Used = true;
+                }
+            }
+
+            object createdObject = creator(creatorParameterValues);
+
+            if (id != null)
+            {
+                AddReference(reader, id, createdObject);
+            }
+
+            OnDeserializing(reader, contract, createdObject);
+
+            // go through unused values and set the newly created object's properties
+            foreach (CreatorPropertyContext context in propertyContexts)
+            {
+                if (context.Used ||
+                    context.Property == null ||
+                    context.Property.Ignored ||
+                    context.Presence == PropertyPresence.None)
+                {
+                    continue;
+                }
+
+                JsonProperty property = context.Property;
+                object? value = context.Value;
+
+                if (ShouldSetPropertyValue(property, contract, value))
+                {
+                    property.ValueProvider!.SetValue(createdObject, value);
+                    context.Used = true;
+                }
+                else if (!property.Writable && value != null)
+                {
+                    // handle readonly collection/dictionary properties
+                    JsonContract propertyContract = Serializer._contractResolver.ResolveContract(property.PropertyType!);
+
+                    if (propertyContract.ContractType == JsonContractType.Array)
+                    {
+                        JsonArrayContract propertyArrayContract = (JsonArrayContract)propertyContract;
+
+                        if (propertyArrayContract.CanDeserialize && !propertyArrayContract.IsReadOnlyOrFixedSize)
+                        {
+                            object? createdObjectCollection = property.ValueProvider!.GetValue(createdObject);
+                            if (createdObjectCollection != null)
+                            {
+                                propertyArrayContract = (JsonArrayContract)GetContract(createdObjectCollection.GetType());
+
+                                IList createdObjectCollectionWrapper = (propertyArrayContract.ShouldCreateWrapper) ? propertyArrayContract.CreateWrapper(createdObjectCollection) : (IList)createdObjectCollection;
+
+                                // Don't attempt to populate array/read-only list
+                                if (!createdObjectCollectionWrapper.IsFixedSize)
+                                {
+                                    IList newValues = (propertyArrayContract.ShouldCreateWrapper) ? propertyArrayContract.CreateWrapper(value) : (IList)value;
+
+                                    foreach (object newValue in newValues)
+                                    {
+                                        createdObjectCollectionWrapper.Add(newValue);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else if (propertyContract.ContractType == JsonContractType.Dictionary)
+                    {
+                        JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)propertyContract;
+
+                        if (!dictionaryContract.IsReadOnlyOrFixedSize)
+                        {
+                            object? createdObjectDictionary = property.ValueProvider!.GetValue(createdObject);
+                            if (createdObjectDictionary != null)
+                            {
+                                IDictionary targetDictionary = (dictionaryContract.ShouldCreateWrapper) ? dictionaryContract.CreateWrapper(createdObjectDictionary) : (IDictionary)createdObjectDictionary;
+                                IDictionary newValues = (dictionaryContract.ShouldCreateWrapper) ? dictionaryContract.CreateWrapper(value) : (IDictionary)value;
+
+                                // Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
+                                IDictionaryEnumerator e = newValues.GetEnumerator();
+                                try
+                                {
+                                    while (e.MoveNext())
+                                    {
+                                        DictionaryEntry entry = e.Entry;
+                                        targetDictionary[entry.Key] = entry.Value;
+                                    }
+                                }
+                                finally
+                                {
+                                    (e as IDisposable)?.Dispose();
+                                }
+                            }
+                        }
+                    }
+
+                    context.Used = true;
+                }
+            }
+
+            if (contract.ExtensionDataSetter != null)
+            {
+                foreach (CreatorPropertyContext propertyValue in propertyContexts)
+                {
+                    if (!propertyValue.Used && propertyValue.Presence != PropertyPresence.None)
+                    {
+                        contract.ExtensionDataSetter(createdObject, propertyValue.Name, propertyValue.Value);
+                    }
+                }
+            }
+
+            if (trackPresence)
+            {
+                foreach (CreatorPropertyContext context in propertyContexts)
+                {
+                    if (context.Property == null)
+                    {
+                        continue;
+                    }
+
+                    EndProcessProperty(
+                        createdObject,
+                        reader,
+                        contract,
+                        reader.Depth,
+                        context.Property,
+                        context.Presence.GetValueOrDefault(),
+                        !context.Used);
+                }
+            }
+
+            OnDeserialized(reader, contract, createdObject);
+            return createdObject;
+        }
+
+        private object? DeserializeConvertable(JsonConverter converter, JsonReader reader, Type objectType, object? existingValue)
+        {
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Started deserializing {0} with converter {1}.".FormatWith(CultureInfo.InvariantCulture, objectType, converter.GetType())), null);
+            }
+
+            object? value = converter.ReadJson(reader, objectType, existingValue, GetInternalSerializer());
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Finished deserializing {0} with converter {1}.".FormatWith(CultureInfo.InvariantCulture, objectType, converter.GetType())), null);
+            }
+
+            return value;
+        }
+
+        private List<CreatorPropertyContext> ResolvePropertyAndCreatorValues(JsonObjectContract contract, JsonProperty? containerProperty, JsonReader reader, Type objectType)
+        {
+            List<CreatorPropertyContext> propertyValues = new List<CreatorPropertyContext>();
+            bool exit = false;
+            do
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string memberName = reader.Value!.ToString();
+
+                        CreatorPropertyContext creatorPropertyContext = new CreatorPropertyContext(memberName)
+                        {
+                            ConstructorProperty = contract.CreatorParameters.GetClosestMatchProperty(memberName),
+                            Property = contract.Properties.GetClosestMatchProperty(memberName)
+                        };
+                        propertyValues.Add(creatorPropertyContext);
+
+                        JsonProperty? property = creatorPropertyContext.ConstructorProperty ?? creatorPropertyContext.Property;
+                        if (property != null)
+                        {
+                            if (!property.Ignored)
+                            {
+                                if (property.PropertyContract == null)
+                                {
+                                    property.PropertyContract = GetContractSafe(property.PropertyType);
+                                }
+
+                                JsonConverter? propertyConverter = GetConverter(property.PropertyContract, property.Converter, contract, containerProperty);
+
+                                if (!reader.ReadForType(property.PropertyContract, propertyConverter != null))
+                                {
+                                    throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
+                                }
+
+                                if (propertyConverter != null && propertyConverter.CanRead)
+                                {
+                                    creatorPropertyContext.Value = DeserializeConvertable(propertyConverter, reader, property.PropertyType!, null);
+                                }
+                                else
+                                {
+                                    creatorPropertyContext.Value = CreateValueInternal(reader, property.PropertyType, property.PropertyContract, property, contract, containerProperty, null);
+                                }
+                                
+                                continue;
+                            }
+                        }
+                        else
+                        {
+                            if (!reader.Read())
+                            {
+                                throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
+                            }
+
+                            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                            {
+                                TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Could not find member '{0}' on {1}.".FormatWith(CultureInfo.InvariantCulture, memberName, contract.UnderlyingType)), null);
+                            }
+
+                            if ((contract.MissingMemberHandling ?? Serializer._missingMemberHandling) == MissingMemberHandling.Error)
+                            {
+                                throw JsonSerializationException.Create(reader, "Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, objectType.Name));
+                            }
+                        }
+
+                        if (contract.ExtensionDataSetter != null)
+                        {
+                            creatorPropertyContext.Value = ReadExtensionDataValue(contract, containerProperty, reader);
+                        }
+                        else
+                        {
+                            reader.Skip();
+                        }
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        exit = true;
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
+                }
+            } while (!exit && reader.Read());
+
+            if (!exit)
+            {
+                ThrowUnexpectedEndException(reader, contract, null, "Unexpected end when deserializing object.");
+            }
+
+            return propertyValues;
+        }
+
+        public object CreateNewObject(JsonReader reader, JsonObjectContract objectContract, JsonProperty? containerMember, JsonProperty? containerProperty, string? id, out bool createdFromNonDefaultCreator)
+        {
+            object? newObject = null;
+
+            if (objectContract.OverrideCreator != null)
+            {
+                if (objectContract.CreatorParameters.Count > 0)
+                {
+                    createdFromNonDefaultCreator = true;
+                    return CreateObjectUsingCreatorWithParameters(reader, objectContract, containerMember, objectContract.OverrideCreator, id);
+                }
+
+                newObject = objectContract.OverrideCreator(CollectionUtils.ArrayEmpty<object>());
+            }
+            else if (objectContract.DefaultCreator != null &&
+                     (!objectContract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor || objectContract.ParameterizedCreator == null))
+            {
+                // use the default constructor if it is...
+                // public
+                // non-public and the user has change constructor handling settings
+                // non-public and there is no other creator
+                newObject = objectContract.DefaultCreator();
+            }
+            else if (objectContract.ParameterizedCreator != null)
+            {
+                createdFromNonDefaultCreator = true;
+                return CreateObjectUsingCreatorWithParameters(reader, objectContract, containerMember, objectContract.ParameterizedCreator, id);
+            }
+
+            if (newObject == null)
+            {
+                if (!objectContract.IsInstantiable)
+                {
+                    throw JsonSerializationException.Create(reader, "Could not create an instance of type {0}. Type is an interface or abstract class and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, objectContract.UnderlyingType));
+                }
+
+                throw JsonSerializationException.Create(reader, "Unable to find a constructor to use for type {0}. A class should either have a default constructor, one constructor with arguments or a constructor marked with the JsonConstructor attribute.".FormatWith(CultureInfo.InvariantCulture, objectContract.UnderlyingType));
+            }
+
+            createdFromNonDefaultCreator = false;
+            return newObject;
+        }
+
+        private object PopulateObject(object newObject, JsonReader reader, JsonObjectContract contract, JsonProperty? member, string? id)
+        {
+            OnDeserializing(reader, contract, newObject);
+
+            // only need to keep a track of properties' presence if they are required or a value should be defaulted if missing
+            Dictionary<JsonProperty, PropertyPresence>? propertiesPresence = (contract.HasRequiredOrDefaultValueProperties || HasFlag(Serializer._defaultValueHandling, DefaultValueHandling.Populate))
+                ? contract.Properties.ToDictionary(m => m, m => PropertyPresence.None)
+                : null;
+
+            if (id != null)
+            {
+                AddReference(reader, id, newObject);
+            }
+
+            int initialDepth = reader.Depth;
+
+            bool finished = false;
+            do
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                    {
+                        string propertyName = reader.Value!.ToString();
+
+                        if (CheckPropertyName(reader, propertyName))
+                        {
+                            continue;
+                        }
+
+                        try
+                        {
+                            // attempt exact case match first
+                            // then try match ignoring case
+                            JsonProperty? property = contract.Properties.GetClosestMatchProperty(propertyName);
+
+                            if (property == null)
+                            {
+                                if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                                {
+                                    TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Could not find member '{0}' on {1}".FormatWith(CultureInfo.InvariantCulture, propertyName, contract.UnderlyingType)), null);
+                                }
+
+                                if ((contract.MissingMemberHandling ?? Serializer._missingMemberHandling) == MissingMemberHandling.Error)
+                                {
+                                    throw JsonSerializationException.Create(reader, "Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, propertyName, contract.UnderlyingType.Name));
+                                }
+
+                                if (!reader.Read())
+                                {
+                                    break;
+                                }
+
+                                SetExtensionData(contract, member, reader, propertyName, newObject);
+                                continue;
+                            }
+
+                            if (property.Ignored || !ShouldDeserialize(reader, property, newObject))
+                            {
+                                if (!reader.Read())
+                                {
+                                    break;
+                                }
+
+                                SetPropertyPresence(reader, property, propertiesPresence);
+                                SetExtensionData(contract, member, reader, propertyName, newObject);
+                            }
+                            else
+                            {
+                                if (property.PropertyContract == null)
+                                {
+                                    property.PropertyContract = GetContractSafe(property.PropertyType);
+                                }
+
+                                JsonConverter? propertyConverter = GetConverter(property.PropertyContract, property.Converter, contract, member);
+
+                                if (!reader.ReadForType(property.PropertyContract, propertyConverter != null))
+                                {
+                                    throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, propertyName));
+                                }
+
+                                SetPropertyPresence(reader, property, propertiesPresence);
+
+                                // set extension data if property is ignored or readonly
+                                if (!SetPropertyValue(property, propertyConverter, contract, member, reader, newObject))
+                                {
+                                    SetExtensionData(contract, member, reader, propertyName, newObject);
+                                }
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            if (IsErrorHandled(newObject, contract, propertyName, reader as IJsonLineInfo, reader.Path, ex))
+                            {
+                                HandleError(reader, true, initialDepth);
+                            }
+                            else
+                            {
+                                throw;
+                            }
+                        }
+                        break;
+                    }
+                    case JsonToken.EndObject:
+                        finished = true;
+                        break;
+                    case JsonToken.Comment:
+                        // ignore
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
+                }
+            } while (!finished && reader.Read());
+
+            if (!finished)
+            {
+                ThrowUnexpectedEndException(reader, contract, newObject, "Unexpected end when deserializing object.");
+            }
+
+            if (propertiesPresence != null)
+            {
+                foreach (KeyValuePair<JsonProperty, PropertyPresence> propertyPresence in propertiesPresence)
+                {
+                    JsonProperty property = propertyPresence.Key;
+                    PropertyPresence presence = propertyPresence.Value;
+
+                    EndProcessProperty(newObject, reader, contract, initialDepth, property, presence, true);
+                }
+            }
+
+            OnDeserialized(reader, contract, newObject);
+            return newObject;
+        }
+
+        private bool ShouldDeserialize(JsonReader reader, JsonProperty property, object target)
+        {
+            if (property.ShouldDeserialize == null)
+            {
+                return true;
+            }
+
+            bool shouldDeserialize = property.ShouldDeserialize(target);
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+            {
+                TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(null, reader.Path, "ShouldDeserialize result for property '{0}' on {1}: {2}".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType, shouldDeserialize)), null);
+            }
+
+            return shouldDeserialize;
+        }
+
+        private bool CheckPropertyName(JsonReader reader, string memberName)
+        {
+            if (Serializer.MetadataPropertyHandling == MetadataPropertyHandling.ReadAhead)
+            {
+                switch (memberName)
+                {
+                    case JsonTypeReflector.IdPropertyName:
+                    case JsonTypeReflector.RefPropertyName:
+                    case JsonTypeReflector.TypePropertyName:
+                    case JsonTypeReflector.ArrayValuesPropertyName:
+                        reader.Skip();
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        private void SetExtensionData(JsonObjectContract contract, JsonProperty? member, JsonReader reader, string memberName, object o)
+        {
+            if (contract.ExtensionDataSetter != null)
+            {
+                try
+                {
+                    object? value = ReadExtensionDataValue(contract, member, reader);
+
+                    contract.ExtensionDataSetter(o, memberName, value);
+                }
+                catch (Exception ex)
+                {
+                    throw JsonSerializationException.Create(reader, "Error setting value in extension data for type '{0}'.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType), ex);
+                }
+            }
+            else
+            {
+                reader.Skip();
+            }
+        }
+
+        private object? ReadExtensionDataValue(JsonObjectContract contract, JsonProperty? member, JsonReader reader)
+        {
+            object? value;
+            if (contract.ExtensionDataIsJToken)
+            {
+                value = JToken.ReadFrom(reader);
+            }
+            else
+            {
+                value = CreateValueInternal(reader, null, null, null, contract, member, null);
+            }
+            return value;
+        }
+
+        private void EndProcessProperty(object newObject, JsonReader reader, JsonObjectContract contract, int initialDepth, JsonProperty property, PropertyPresence presence, bool setDefaultValue)
+        {
+            if (presence == PropertyPresence.None || presence == PropertyPresence.Null)
+            {
+                try
+                {
+                    Required resolvedRequired = property.Ignored ? Required.Default : property._required ?? contract.ItemRequired ?? Required.Default;
+
+                    switch (presence)
+                    {
+                        case PropertyPresence.None:
+                            if (resolvedRequired == Required.AllowNull || resolvedRequired == Required.Always)
+                            {
+                                throw JsonSerializationException.Create(reader, "Required property '{0}' not found in JSON.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName));
+                            }
+
+                            if (setDefaultValue && !property.Ignored)
+                            {
+                                if (property.PropertyContract == null)
+                                {
+                                    property.PropertyContract = GetContractSafe(property.PropertyType);
+                                }
+
+                                if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Populate) && property.Writable)
+                                {
+                                    property.ValueProvider!.SetValue(newObject, EnsureType(reader, property.GetResolvedDefaultValue(), CultureInfo.InvariantCulture, property.PropertyContract!, property.PropertyType));
+                                }
+                            }
+                            break;
+                        case PropertyPresence.Null:
+                            if (resolvedRequired == Required.Always)
+                            {
+                                throw JsonSerializationException.Create(reader, "Required property '{0}' expects a value but got null.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName));
+                            }
+                            if (resolvedRequired == Required.DisallowNull)
+                            {
+                                throw JsonSerializationException.Create(reader, "Required property '{0}' expects a non-null value.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName));
+                            }
+                            break;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (IsErrorHandled(newObject, contract, property.PropertyName, reader as IJsonLineInfo, reader.Path, ex))
+                    {
+                        HandleError(reader, true, initialDepth);
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+        }
+
+        private void SetPropertyPresence(JsonReader reader, JsonProperty property, Dictionary<JsonProperty, PropertyPresence>? requiredProperties)
+        {
+            if (property != null && requiredProperties != null)
+            {
+                PropertyPresence propertyPresence;
+                switch (reader.TokenType)
+                {
+                    case JsonToken.String:
+                        propertyPresence = (CoerceEmptyStringToNull(property.PropertyType, property.PropertyContract, (string)reader.Value!))
+                            ? PropertyPresence.Null
+                            : PropertyPresence.Value;
+                        break;
+                    case JsonToken.Null:
+                    case JsonToken.Undefined:
+                        propertyPresence = PropertyPresence.Null;
+                        break;
+                    default:
+                        propertyPresence = PropertyPresence.Value;
+                        break;
+                }
+
+                requiredProperties[property] = propertyPresence;
+            }
+        }
+
+        private void HandleError(JsonReader reader, bool readPastError, int initialDepth)
+        {
+            ClearErrorContext();
+
+            if (readPastError)
+            {
+                reader.Skip();
+
+                while (reader.Depth > initialDepth)
+                {
+                    if (!reader.Read())
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs b/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs
new file mode 100644
index 0000000..3711477
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs
@@ -0,0 +1,1244 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+#if HAVE_DYNAMIC
+using System.Dynamic;
+#endif
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Security;
+using LC.Newtonsoft.Json.Linq;
+using LC.Newtonsoft.Json.Utilities;
+using System.Runtime.Serialization;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class JsonSerializerInternalWriter : JsonSerializerInternalBase
+    {
+        private Type? _rootType;
+        private int _rootLevel;
+        private readonly List<object> _serializeStack = new List<object>();
+
+        public JsonSerializerInternalWriter(JsonSerializer serializer)
+            : base(serializer)
+        {
+        }
+
+        public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
+        {
+            if (jsonWriter == null)
+            {
+                throw new ArgumentNullException(nameof(jsonWriter));
+            }
+
+            _rootType = objectType;
+            _rootLevel = _serializeStack.Count + 1;
+
+            JsonContract? contract = GetContractSafe(value);
+
+            try
+            {
+                if (ShouldWriteReference(value, null, contract, null, null))
+                {
+                    WriteReference(jsonWriter, value!);
+                }
+                else
+                {
+                    SerializeValue(jsonWriter, value, contract, null, null, null);
+                }
+            }
+            catch (Exception ex)
+            {
+                if (IsErrorHandled(null, contract, null, null, jsonWriter.Path, ex))
+                {
+                    HandleError(jsonWriter, 0);
+                }
+                else
+                {
+                    // clear context in case serializer is being used inside a converter
+                    // if the converter wraps the error then not clearing the context will cause this error:
+                    // "Current error context error is different to requested error."
+                    ClearErrorContext();
+                    throw;
+                }
+            }
+            finally
+            {
+                // clear root contract to ensure that if level was > 1 then it won't
+                // accidentally be used for non root values
+                _rootType = null;
+            }
+        }
+
+        private JsonSerializerProxy GetInternalSerializer()
+        {
+            if (InternalSerializer == null)
+            {
+                InternalSerializer = new JsonSerializerProxy(this);
+            }
+
+            return InternalSerializer;
+        }
+
+        private JsonContract? GetContractSafe(object? value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            return GetContract(value);
+        }
+
+        private JsonContract GetContract(object value)
+        {
+            return Serializer._contractResolver.ResolveContract(value.GetType());
+        }
+
+        private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerProperty)
+        {
+            if (contract.TypeCode == PrimitiveTypeCode.Bytes)
+            {
+                // if type name handling is enabled then wrap the base64 byte string in an object with the type name
+                bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
+                if (includeTypeDetails)
+                {
+                    writer.WriteStartObject();
+                    WriteTypeProperty(writer, contract.CreatedType);
+                    writer.WritePropertyName(JsonTypeReflector.ValuePropertyName, false);
+
+                    JsonWriter.WriteValue(writer, contract.TypeCode, value);
+
+                    writer.WriteEndObject();
+                    return;
+                }
+            }
+
+            JsonWriter.WriteValue(writer, contract.TypeCode, value);
+        }
+
+        private void SerializeValue(JsonWriter writer, object? value, JsonContract? valueContract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerProperty)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            MiscellaneousUtils.Assert(valueContract != null);
+
+            JsonConverter? converter =
+                member?.Converter ??
+                containerProperty?.ItemConverter ??
+                containerContract?.ItemConverter ??
+                valueContract.Converter ??
+                Serializer.GetMatchingConverter(valueContract.UnderlyingType) ??
+                valueContract.InternalConverter;
+
+            if (converter != null && converter.CanWrite)
+            {
+                SerializeConvertable(writer, converter, value, valueContract, containerContract, containerProperty);
+                return;
+            }
+
+            switch (valueContract.ContractType)
+            {
+                case JsonContractType.Object:
+                    SerializeObject(writer, value, (JsonObjectContract)valueContract, member, containerContract, containerProperty);
+                    break;
+                case JsonContractType.Array:
+                    JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
+                    if (!arrayContract.IsMultidimensionalArray)
+                    {
+                        SerializeList(writer, (IEnumerable)value, arrayContract, member, containerContract, containerProperty);
+                    }
+                    else
+                    {
+                        SerializeMultidimensionalArray(writer, (Array)value, arrayContract, member, containerContract, containerProperty);
+                    }
+                    break;
+                case JsonContractType.Primitive:
+                    SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, containerContract, containerProperty);
+                    break;
+                case JsonContractType.String:
+                    SerializeString(writer, value, (JsonStringContract)valueContract);
+                    break;
+                case JsonContractType.Dictionary:
+                    JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
+                    SerializeDictionary(writer, (value is IDictionary dictionary) ? dictionary : dictionaryContract.CreateWrapper(value), dictionaryContract, member, containerContract, containerProperty);
+                    break;
+#if HAVE_DYNAMIC
+                case JsonContractType.Dynamic:
+                    SerializeDynamic(writer, (IDynamicMetaObjectProvider)value, (JsonDynamicContract)valueContract, member, containerContract, containerProperty);
+                    break;
+#endif
+#if HAVE_BINARY_SERIALIZATION
+                case JsonContractType.Serializable:
+                    SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, containerContract, containerProperty);
+                    break;
+#endif
+                case JsonContractType.Linq:
+                    ((JToken)value).WriteTo(writer, Serializer.Converters.ToArray());
+                    break;
+            }
+        }
+
+        private bool? ResolveIsReference(JsonContract contract, JsonProperty? property, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            bool? isReference = null;
+
+            // value could be coming from a dictionary or array and not have a property
+            if (property != null)
+            {
+                isReference = property.IsReference;
+            }
+
+            if (isReference == null && containerProperty != null)
+            {
+                isReference = containerProperty.ItemIsReference;
+            }
+
+            if (isReference == null && collectionContract != null)
+            {
+                isReference = collectionContract.ItemIsReference;
+            }
+
+            if (isReference == null)
+            {
+                isReference = contract.IsReference;
+            }
+
+            return isReference;
+        }
+
+        private bool ShouldWriteReference(object? value, JsonProperty? property, JsonContract? valueContract, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            if (value == null)
+            {
+                return false;
+            }
+
+            MiscellaneousUtils.Assert(valueContract != null);
+
+            if (valueContract.ContractType == JsonContractType.Primitive || valueContract.ContractType == JsonContractType.String)
+            {
+                return false;
+            }
+
+            bool? isReference = ResolveIsReference(valueContract, property, collectionContract, containerProperty);
+
+            if (isReference == null)
+            {
+                if (valueContract.ContractType == JsonContractType.Array)
+                {
+                    isReference = HasFlag(Serializer._preserveReferencesHandling, PreserveReferencesHandling.Arrays);
+                }
+                else
+                {
+                    isReference = HasFlag(Serializer._preserveReferencesHandling, PreserveReferencesHandling.Objects);
+                }
+            }
+
+            if (!isReference.GetValueOrDefault())
+            {
+                return false;
+            }
+
+            return Serializer.GetReferenceResolver().IsReferenced(this, value);
+        }
+
+        private bool ShouldWriteProperty(object? memberValue, JsonObjectContract? containerContract, JsonProperty property)
+        {
+            if (memberValue == null && ResolvedNullValueHandling(containerContract, property) == NullValueHandling.Ignore)
+            {
+                return false;
+            }
+
+            if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Ignore)
+                && MiscellaneousUtils.ValueEquals(memberValue, property.GetResolvedDefaultValue()))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool CheckForCircularReference(JsonWriter writer, object? value, JsonProperty? property, JsonContract? contract, JsonContainerContract? containerContract, JsonProperty? containerProperty)
+        {
+            if (value == null)
+            {
+                return true;
+            }
+
+            MiscellaneousUtils.Assert(contract != null);
+
+            if (contract.ContractType == JsonContractType.Primitive || contract.ContractType == JsonContractType.String)
+            {
+                return true;
+            }
+
+            ReferenceLoopHandling? referenceLoopHandling = null;
+
+            if (property != null)
+            {
+                referenceLoopHandling = property.ReferenceLoopHandling;
+            }
+
+            if (referenceLoopHandling == null && containerProperty != null)
+            {
+                referenceLoopHandling = containerProperty.ItemReferenceLoopHandling;
+            }
+
+            if (referenceLoopHandling == null && containerContract != null)
+            {
+                referenceLoopHandling = containerContract.ItemReferenceLoopHandling;
+            }
+
+            bool exists = (Serializer._equalityComparer != null)
+                ? _serializeStack.Contains(value, Serializer._equalityComparer)
+                : _serializeStack.Contains(value);
+
+            if (exists)
+            {
+                string message = "Self referencing loop detected";
+                if (property != null)
+                {
+                    message += " for property '{0}'".FormatWith(CultureInfo.InvariantCulture, property.PropertyName);
+                }
+                message += " with type '{0}'.".FormatWith(CultureInfo.InvariantCulture, value.GetType());
+
+                switch (referenceLoopHandling.GetValueOrDefault(Serializer._referenceLoopHandling))
+                {
+                    case ReferenceLoopHandling.Error:
+                        throw JsonSerializationException.Create(null, writer.ContainerPath, message, null);
+                    case ReferenceLoopHandling.Ignore:
+                        if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                        {
+                            TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(null, writer.Path, message + ". Skipping serializing self referenced value."), null);
+                        }
+
+                        return false;
+                    case ReferenceLoopHandling.Serialize:
+                        if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+                        {
+                            TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(null, writer.Path, message + ". Serializing self referenced value."), null);
+                        }
+
+                        return true;
+                }
+            }
+
+            return true;
+        }
+
+        private void WriteReference(JsonWriter writer, object value)
+        {
+            string reference = GetReference(writer, value);
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(null, writer.Path, "Writing object reference to Id '{0}' for {1}.".FormatWith(CultureInfo.InvariantCulture, reference, value.GetType())), null);
+            }
+
+            writer.WriteStartObject();
+            writer.WritePropertyName(JsonTypeReflector.RefPropertyName, false);
+            writer.WriteValue(reference);
+            writer.WriteEndObject();
+        }
+
+        private string GetReference(JsonWriter writer, object value)
+        {
+            try
+            {
+                string reference = Serializer.GetReferenceResolver().GetReference(this, value);
+
+                return reference;
+            }
+            catch (Exception ex)
+            {
+                throw JsonSerializationException.Create(null, writer.ContainerPath, "Error writing object reference for '{0}'.".FormatWith(CultureInfo.InvariantCulture, value.GetType()), ex);
+            }
+        }
+
+        internal static bool TryConvertToString(object value, Type type, [NotNullWhen(true)]out string? s)
+        {
+#if HAVE_TYPE_DESCRIPTOR
+            if (JsonTypeReflector.CanTypeDescriptorConvertString(type, out TypeConverter converter))
+            {
+                s = converter.ConvertToInvariantString(value);
+                return true;
+            }
+#endif
+
+#if (DOTNET || PORTABLE)
+            if (value is Guid || value is Uri || value is TimeSpan)
+            {
+                s = value.ToString();
+                return true;
+            }
+#endif
+
+            if (value is Type t)
+            {
+                s = t.AssemblyQualifiedName;
+                return true;
+            }
+
+            s = null;
+            return false;
+        }
+
+        private void SerializeString(JsonWriter writer, object value, JsonStringContract contract)
+        {
+            OnSerializing(writer, contract, value);
+
+            TryConvertToString(value, contract.UnderlyingType, out string? s);
+            writer.WriteValue(s);
+
+            OnSerialized(writer, contract, value);
+        }
+
+        private void OnSerializing(JsonWriter writer, JsonContract contract, object value)
+        {
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(null, writer.Path, "Started serializing {0}".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)), null);
+            }
+
+            contract.InvokeOnSerializing(value, Serializer._context);
+        }
+
+        private void OnSerialized(JsonWriter writer, JsonContract contract, object value)
+        {
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+            {
+                TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(null, writer.Path, "Finished serializing {0}".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)), null);
+            }
+
+            contract.InvokeOnSerialized(value, Serializer._context);
+        }
+
+        private void SerializeObject(JsonWriter writer, object value, JsonObjectContract contract, JsonProperty? member, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            OnSerializing(writer, contract, value);
+
+            _serializeStack.Add(value);
+
+            WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
+
+            int initialDepth = writer.Top;
+
+            for (int index = 0; index < contract.Properties.Count; index++)
+            {
+                JsonProperty property = contract.Properties[index];
+                try
+                {
+                    if (!CalculatePropertyValues(writer, value, contract, member, property, out JsonContract? memberContract, out object? memberValue))
+                    {
+                        continue;
+                    }
+
+                    property.WritePropertyName(writer);
+                    SerializeValue(writer, memberValue, memberContract, property, contract, member);
+                }
+                catch (Exception ex)
+                {
+                    if (IsErrorHandled(value, contract, property.PropertyName, null, writer.ContainerPath, ex))
+                    {
+                        HandleError(writer, initialDepth);
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+
+            IEnumerable<KeyValuePair<object, object>>? extensionData = contract.ExtensionDataGetter?.Invoke(value);
+            if (extensionData != null)
+            {
+                foreach (KeyValuePair<object, object> e in extensionData)
+                {
+                    JsonContract keyContract = GetContract(e.Key);
+                    JsonContract? valueContract = GetContractSafe(e.Value);
+
+                    string propertyName = GetPropertyName(writer, e.Key, keyContract, out _);
+
+                    propertyName = (contract.ExtensionDataNameResolver != null)
+                        ? contract.ExtensionDataNameResolver(propertyName)
+                        : propertyName;
+
+                    if (ShouldWriteReference(e.Value, null, valueContract, contract, member))
+                    {
+                        writer.WritePropertyName(propertyName);
+                        WriteReference(writer, e.Value!);
+                    }
+                    else
+                    {
+                        if (!CheckForCircularReference(writer, e.Value, null, valueContract, contract, member))
+                        {
+                            continue;
+                        }
+
+                        writer.WritePropertyName(propertyName);
+
+                        SerializeValue(writer, e.Value, valueContract, null, contract, member);
+                    }
+                }
+            }
+
+            writer.WriteEndObject();
+
+            _serializeStack.RemoveAt(_serializeStack.Count - 1);
+
+            OnSerialized(writer, contract, value);
+        }
+
+        private bool CalculatePropertyValues(JsonWriter writer, object value, JsonContainerContract contract, JsonProperty? member, JsonProperty property, [NotNullWhen(true)]out JsonContract? memberContract, out object? memberValue)
+        {
+            if (!property.Ignored && property.Readable && ShouldSerialize(writer, property, value) && IsSpecified(writer, property, value))
+            {
+                if (property.PropertyContract == null)
+                {
+                    property.PropertyContract = Serializer._contractResolver.ResolveContract(property.PropertyType!);
+                }
+
+                memberValue = property.ValueProvider!.GetValue(value);
+                memberContract = (property.PropertyContract.IsSealed) ? property.PropertyContract : GetContractSafe(memberValue);
+
+                if (ShouldWriteProperty(memberValue, contract as JsonObjectContract, property))
+                {
+                    if (ShouldWriteReference(memberValue, property, memberContract, contract, member))
+                    {
+                        property.WritePropertyName(writer);
+                        WriteReference(writer, memberValue!);
+                        return false;
+                    }
+
+                    if (!CheckForCircularReference(writer, memberValue, property, memberContract, contract, member))
+                    {
+                        return false;
+                    }
+
+                    if (memberValue == null)
+                    {
+                        JsonObjectContract? objectContract = contract as JsonObjectContract;
+                        Required resolvedRequired = property._required ?? objectContract?.ItemRequired ?? Required.Default;
+                        if (resolvedRequired == Required.Always)
+                        {
+                            throw JsonSerializationException.Create(null, writer.ContainerPath, "Cannot write a null value for property '{0}'. Property requires a value.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName), null);
+                        }
+                        if (resolvedRequired == Required.DisallowNull)
+                        {
+                            throw JsonSerializationException.Create(null, writer.ContainerPath, "Cannot write a null value for property '{0}'. Property requires a non-null value.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName), null);
+                        }
+                    }
+
+#pragma warning disable CS8762 // Parameter must have a non-null value when exiting in some condition.
+                    return true;
+#pragma warning restore CS8762 // Parameter must have a non-null value when exiting in some condition.
+                }
+            }
+
+            memberContract = null;
+            memberValue = null;
+            return false;
+        }
+
+        private void WriteObjectStart(JsonWriter writer, object value, JsonContract contract, JsonProperty? member, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            writer.WriteStartObject();
+
+            bool isReference = ResolveIsReference(contract, member, collectionContract, containerProperty) ?? HasFlag(Serializer._preserveReferencesHandling, PreserveReferencesHandling.Objects);
+            // don't make readonly fields that aren't creator parameters the referenced value because they can't be deserialized to
+            if (isReference && (member == null || member.Writable || HasCreatorParameter(collectionContract, member)))
+            {
+                WriteReferenceIdProperty(writer, contract.UnderlyingType, value);
+            }
+            if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionContract, containerProperty))
+            {
+                WriteTypeProperty(writer, contract.UnderlyingType);
+            }
+        }
+
+        private bool HasCreatorParameter(JsonContainerContract? contract, JsonProperty property)
+        {
+            if (!(contract is JsonObjectContract objectContract))
+            {
+                return false;
+            }
+
+            return objectContract.CreatorParameters.Contains(property.PropertyName!);
+        }
+
+        private void WriteReferenceIdProperty(JsonWriter writer, Type type, object value)
+        {
+            string reference = GetReference(writer, value);
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+            {
+                TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(null, writer.Path, "Writing object reference Id '{0}' for {1}.".FormatWith(CultureInfo.InvariantCulture, reference, type)), null);
+            }
+
+            writer.WritePropertyName(JsonTypeReflector.IdPropertyName, false);
+            writer.WriteValue(reference);
+        }
+
+        private void WriteTypeProperty(JsonWriter writer, Type type)
+        {
+            string typeName = ReflectionUtils.GetTypeName(type, Serializer._typeNameAssemblyFormatHandling, Serializer._serializationBinder);
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+            {
+                TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(null, writer.Path, "Writing type name '{0}' for {1}.".FormatWith(CultureInfo.InvariantCulture, typeName, type)), null);
+            }
+
+            writer.WritePropertyName(JsonTypeReflector.TypePropertyName, false);
+            writer.WriteValue(typeName);
+        }
+
+        private bool HasFlag(DefaultValueHandling value, DefaultValueHandling flag)
+        {
+            return ((value & flag) == flag);
+        }
+
+        private bool HasFlag(PreserveReferencesHandling value, PreserveReferencesHandling flag)
+        {
+            return ((value & flag) == flag);
+        }
+
+        private bool HasFlag(TypeNameHandling value, TypeNameHandling flag)
+        {
+            return ((value & flag) == flag);
+        }
+
+        private void SerializeConvertable(JsonWriter writer, JsonConverter converter, object value, JsonContract contract, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            if (ShouldWriteReference(value, null, contract, collectionContract, containerProperty))
+            {
+                WriteReference(writer, value);
+            }
+            else
+            {
+                if (!CheckForCircularReference(writer, value, null, contract, collectionContract, containerProperty))
+                {
+                    return;
+                }
+
+                _serializeStack.Add(value);
+
+                if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+                {
+                    TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(null, writer.Path, "Started serializing {0} with converter {1}.".FormatWith(CultureInfo.InvariantCulture, value.GetType(), converter.GetType())), null);
+                }
+
+                converter.WriteJson(writer, value, GetInternalSerializer());
+
+                if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
+                {
+                    TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(null, writer.Path, "Finished serializing {0} with converter {1}.".FormatWith(CultureInfo.InvariantCulture, value.GetType(), converter.GetType())), null);
+                }
+
+                _serializeStack.RemoveAt(_serializeStack.Count - 1);
+            }
+        }
+
+        private void SerializeList(JsonWriter writer, IEnumerable values, JsonArrayContract contract, JsonProperty? member, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            object underlyingList = values is IWrappedCollection wrappedCollection ? wrappedCollection.UnderlyingCollection : values;
+
+            OnSerializing(writer, contract, underlyingList);
+
+            _serializeStack.Add(underlyingList);
+
+            bool hasWrittenMetadataObject = WriteStartArray(writer, underlyingList, contract, member, collectionContract, containerProperty);
+
+            writer.WriteStartArray();
+
+            int initialDepth = writer.Top;
+
+            int index = 0;
+            // note that an error in the IEnumerable won't be caught
+            foreach (object value in values)
+            {
+                try
+                {
+                    JsonContract? valueContract = contract.FinalItemContract ?? GetContractSafe(value);
+
+                    if (ShouldWriteReference(value, null, valueContract, contract, member))
+                    {
+                        WriteReference(writer, value);
+                    }
+                    else
+                    {
+                        if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
+                        {
+                            SerializeValue(writer, value, valueContract, null, contract, member);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (IsErrorHandled(underlyingList, contract, index, null, writer.ContainerPath, ex))
+                    {
+                        HandleError(writer, initialDepth);
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                finally
+                {
+                    index++;
+                }
+            }
+
+            writer.WriteEndArray();
+
+            if (hasWrittenMetadataObject)
+            {
+                writer.WriteEndObject();
+            }
+
+            _serializeStack.RemoveAt(_serializeStack.Count - 1);
+
+            OnSerialized(writer, contract, underlyingList);
+        }
+
+        private void SerializeMultidimensionalArray(JsonWriter writer, Array values, JsonArrayContract contract, JsonProperty? member, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            OnSerializing(writer, contract, values);
+
+            _serializeStack.Add(values);
+
+            bool hasWrittenMetadataObject = WriteStartArray(writer, values, contract, member, collectionContract, containerProperty);
+
+            SerializeMultidimensionalArray(writer, values, contract, member, writer.Top, CollectionUtils.ArrayEmpty<int>());
+
+            if (hasWrittenMetadataObject)
+            {
+                writer.WriteEndObject();
+            }
+
+            _serializeStack.RemoveAt(_serializeStack.Count - 1);
+
+            OnSerialized(writer, contract, values);
+        }
+
+        private void SerializeMultidimensionalArray(JsonWriter writer, Array values, JsonArrayContract contract, JsonProperty? member, int initialDepth, int[] indices)
+        {
+            int dimension = indices.Length;
+            int[] newIndices = new int[dimension + 1];
+            for (int i = 0; i < dimension; i++)
+            {
+                newIndices[i] = indices[i];
+            }
+
+            writer.WriteStartArray();
+
+            for (int i = values.GetLowerBound(dimension); i <= values.GetUpperBound(dimension); i++)
+            {
+                newIndices[dimension] = i;
+                bool isTopLevel = (newIndices.Length == values.Rank);
+
+                if (isTopLevel)
+                {
+                    object value = values.GetValue(newIndices);
+
+                    try
+                    {
+                        JsonContract? valueContract = contract.FinalItemContract ?? GetContractSafe(value);
+
+                        if (ShouldWriteReference(value, null, valueContract, contract, member))
+                        {
+                            WriteReference(writer, value);
+                        }
+                        else
+                        {
+                            if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
+                            {
+                                SerializeValue(writer, value, valueContract, null, contract, member);
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        if (IsErrorHandled(values, contract, i, null, writer.ContainerPath, ex))
+                        {
+                            HandleError(writer, initialDepth + 1);
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+                else
+                {
+                    SerializeMultidimensionalArray(writer, values, contract, member, initialDepth + 1, newIndices);
+                }
+            }
+
+            writer.WriteEndArray();
+        }
+
+        private bool WriteStartArray(JsonWriter writer, object values, JsonArrayContract contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerProperty)
+        {
+            bool isReference = ResolveIsReference(contract, member, containerContract, containerProperty) ?? HasFlag(Serializer._preserveReferencesHandling, PreserveReferencesHandling.Arrays);
+            // don't make readonly fields that aren't creator parameters the referenced value because they can't be deserialized to
+            isReference = (isReference && (member == null || member.Writable || HasCreatorParameter(containerContract, member)));
+
+            bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, containerContract, containerProperty);
+            bool writeMetadataObject = isReference || includeTypeDetails;
+
+            if (writeMetadataObject)
+            {
+                writer.WriteStartObject();
+
+                if (isReference)
+                {
+                    WriteReferenceIdProperty(writer, contract.UnderlyingType, values);
+                }
+                if (includeTypeDetails)
+                {
+                    WriteTypeProperty(writer, values.GetType());
+                }
+                writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName, false);
+            }
+
+            if (contract.ItemContract == null)
+            {
+                contract.ItemContract = Serializer._contractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));
+            }
+
+            return writeMetadataObject;
+        }
+
+#if HAVE_BINARY_SERIALIZATION
+#if HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE
+        [SecuritySafeCritical]
+#endif
+        private void SerializeISerializable(JsonWriter writer, ISerializable value, JsonISerializableContract contract, JsonProperty? member, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            if (!JsonTypeReflector.FullyTrusted)
+            {
+                string message = @"Type '{0}' implements ISerializable but cannot be serialized using the ISerializable interface because the current application is not fully trusted and ISerializable can expose secure data." + Environment.NewLine +
+                                 @"To fix this error either change the environment to be fully trusted, change the application to not deserialize the type, add JsonObjectAttribute to the type or change the JsonSerializer setting ContractResolver to use a new DefaultContractResolver with IgnoreSerializableInterface set to true." + Environment.NewLine;
+                message = message.FormatWith(CultureInfo.InvariantCulture, value.GetType());
+
+                throw JsonSerializationException.Create(null, writer.ContainerPath, message, null);
+            }
+
+            OnSerializing(writer, contract, value);
+            _serializeStack.Add(value);
+
+            WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
+
+            SerializationInfo serializationInfo = new SerializationInfo(contract.UnderlyingType, new FormatterConverter());
+            value.GetObjectData(serializationInfo, Serializer._context);
+
+            foreach (SerializationEntry serializationEntry in serializationInfo)
+            {
+                JsonContract? valueContract = GetContractSafe(serializationEntry.Value);
+
+                if (ShouldWriteReference(serializationEntry.Value, null, valueContract, contract, member))
+                {
+                    writer.WritePropertyName(serializationEntry.Name);
+                    WriteReference(writer, serializationEntry.Value);
+                }
+                else if (CheckForCircularReference(writer, serializationEntry.Value, null, valueContract, contract, member))
+                {
+                    writer.WritePropertyName(serializationEntry.Name);
+                    SerializeValue(writer, serializationEntry.Value, valueContract, null, contract, member);
+                }
+            }
+
+            writer.WriteEndObject();
+
+            _serializeStack.RemoveAt(_serializeStack.Count - 1);
+            OnSerialized(writer, contract, value);
+        }
+#endif
+
+#if HAVE_DYNAMIC
+        private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract, JsonProperty? member, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+            OnSerializing(writer, contract, value);
+            _serializeStack.Add(value);
+
+            WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
+
+            int initialDepth = writer.Top;
+
+            for (int index = 0; index < contract.Properties.Count; index++)
+            {
+                JsonProperty property = contract.Properties[index];
+
+                // only write non-dynamic properties that have an explicit attribute
+                if (property.HasMemberAttribute)
+                {
+                    try
+                    {
+                        if (!CalculatePropertyValues(writer, value, contract, member, property, out JsonContract? memberContract, out object? memberValue))
+                        {
+                            continue;
+                        }
+
+                        property.WritePropertyName(writer);
+                        SerializeValue(writer, memberValue, memberContract, property, contract, member);
+                    }
+                    catch (Exception ex)
+                    {
+                        if (IsErrorHandled(value, contract, property.PropertyName, null, writer.ContainerPath, ex))
+                        {
+                            HandleError(writer, initialDepth);
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+            }
+
+            foreach (string memberName in value.GetDynamicMemberNames())
+            {
+                if (contract.TryGetMember(value, memberName, out object? memberValue))
+                {
+                    try
+                    {
+                        JsonContract? valueContract = GetContractSafe(memberValue);
+
+                        if (!ShouldWriteDynamicProperty(memberValue))
+                        {
+                            continue;
+                        }
+
+                        if (CheckForCircularReference(writer, memberValue, null, valueContract, contract, member))
+                        {
+                            string resolvedPropertyName = (contract.PropertyNameResolver != null)
+                                ? contract.PropertyNameResolver(memberName)
+                                : memberName;
+
+                            writer.WritePropertyName(resolvedPropertyName);
+                            SerializeValue(writer, memberValue, valueContract, null, contract, member);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        if (IsErrorHandled(value, contract, memberName, null, writer.ContainerPath, ex))
+                        {
+                            HandleError(writer, initialDepth);
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+            }
+
+            writer.WriteEndObject();
+
+            _serializeStack.RemoveAt(_serializeStack.Count - 1);
+            OnSerialized(writer, contract, value);
+        }
+#endif
+
+        private bool ShouldWriteDynamicProperty(object? memberValue)
+        {
+            if (Serializer._nullValueHandling == NullValueHandling.Ignore && memberValue == null)
+            {
+                return false;
+            }
+
+            if (HasFlag(Serializer._defaultValueHandling, DefaultValueHandling.Ignore) &&
+                (memberValue == null || MiscellaneousUtils.ValueEquals(memberValue, ReflectionUtils.GetDefaultValue(memberValue.GetType()))))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty? member, JsonContainerContract? containerContract, JsonProperty? containerProperty)
+        {
+            TypeNameHandling resolvedTypeNameHandling =
+                member?.TypeNameHandling
+                ?? containerProperty?.ItemTypeNameHandling
+                ?? containerContract?.ItemTypeNameHandling
+                ?? Serializer._typeNameHandling;
+
+            if (HasFlag(resolvedTypeNameHandling, typeNameHandlingFlag))
+            {
+                return true;
+            }
+
+            // instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
+            if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Auto))
+            {
+                if (member != null)
+                {
+                    if (contract.NonNullableUnderlyingType != member.PropertyContract!.CreatedType)
+                    {
+                        return true;
+                    }
+                }
+                else if (containerContract != null)
+                {
+                    if (containerContract.ItemContract == null || contract.NonNullableUnderlyingType != containerContract.ItemContract.CreatedType)
+                    {
+                        return true;
+                    }
+                }
+                else if (_rootType != null && _serializeStack.Count == _rootLevel)
+                {
+                    JsonContract rootContract = Serializer._contractResolver.ResolveContract(_rootType);
+
+                    if (contract.NonNullableUnderlyingType != rootContract.CreatedType)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty? member, JsonContainerContract? collectionContract, JsonProperty? containerProperty)
+        {
+#pragma warning disable CS8600, CS8602, CS8604
+            object underlyingDictionary = values is IWrappedDictionary wrappedDictionary ? wrappedDictionary.UnderlyingDictionary : values;
+
+            OnSerializing(writer, contract, underlyingDictionary);
+            _serializeStack.Add(underlyingDictionary);
+
+            WriteObjectStart(writer, underlyingDictionary, contract, member, collectionContract, containerProperty);
+
+            if (contract.ItemContract == null)
+            {
+                contract.ItemContract = Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
+            }
+
+            if (contract.KeyContract == null)
+            {
+                contract.KeyContract = Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
+            }
+
+            int initialDepth = writer.Top;
+
+            // Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
+            IDictionaryEnumerator e = values.GetEnumerator();
+            try
+            {
+                while (e.MoveNext())
+                {
+                    DictionaryEntry entry = e.Entry;
+
+                    string propertyName = GetPropertyName(writer, entry.Key, contract.KeyContract, out bool escape);
+
+                    propertyName = (contract.DictionaryKeyResolver != null)
+                        ? contract.DictionaryKeyResolver(propertyName)
+                        : propertyName;
+
+                    try
+                    {
+                        object value = entry.Value;
+                        JsonContract? valueContract = contract.FinalItemContract ?? GetContractSafe(value);
+
+                        if (ShouldWriteReference(value, null, valueContract, contract, member))
+                        {
+                            writer.WritePropertyName(propertyName, escape);
+                            WriteReference(writer, value);
+                        }
+                        else
+                        {
+                            if (!CheckForCircularReference(writer, value, null, valueContract, contract, member))
+                            {
+                                continue;
+                            }
+
+                            writer.WritePropertyName(propertyName, escape);
+
+                            SerializeValue(writer, value, valueContract, null, contract, member);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        if (IsErrorHandled(underlyingDictionary, contract, propertyName, null, writer.ContainerPath, ex))
+                        {
+                            HandleError(writer, initialDepth);
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                (e as IDisposable)?.Dispose();
+            }
+
+            writer.WriteEndObject();
+
+            _serializeStack.RemoveAt(_serializeStack.Count - 1);
+
+            OnSerialized(writer, contract, underlyingDictionary);
+#pragma warning restore CS8600, CS8602, CS8604
+        }
+
+        private string GetPropertyName(JsonWriter writer, object name, JsonContract contract, out bool escape)
+        {
+            if (contract.ContractType == JsonContractType.Primitive)
+            {
+                JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract)contract;
+                switch (primitiveContract.TypeCode)
+                {
+                    case PrimitiveTypeCode.DateTime:
+                    case PrimitiveTypeCode.DateTimeNullable:
+                    {
+                        DateTime dt = DateTimeUtils.EnsureDateTime((DateTime)name, writer.DateTimeZoneHandling);
+
+                        escape = false;
+                        StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
+                        DateTimeUtils.WriteDateTimeString(sw, dt, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
+                        return sw.ToString();
+                    }
+#if HAVE_DATE_TIME_OFFSET
+                    case PrimitiveTypeCode.DateTimeOffset:
+                    case PrimitiveTypeCode.DateTimeOffsetNullable:
+                    {
+                        escape = false;
+                        StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
+                        DateTimeUtils.WriteDateTimeOffsetString(sw, (DateTimeOffset)name, writer.DateFormatHandling, writer.DateFormatString, writer.Culture);
+                        return sw.ToString();
+                    }
+#endif
+                    case PrimitiveTypeCode.Double:
+                    case PrimitiveTypeCode.DoubleNullable:
+                    {
+                        double d = (double)name;
+
+                        escape = false;
+                        return d.ToString("R", CultureInfo.InvariantCulture);
+                    }
+                    case PrimitiveTypeCode.Single:
+                    case PrimitiveTypeCode.SingleNullable:
+                    {
+                        float f = (float)name;
+
+                        escape = false;
+                        return f.ToString("R", CultureInfo.InvariantCulture);
+                    }
+                    default:
+                    {
+                        escape = true;
+
+                        if (primitiveContract.IsEnum && EnumUtils.TryToString(primitiveContract.NonNullableUnderlyingType, name, null, out string? enumName))
+                        {
+                            return enumName;
+                        }
+
+                        return Convert.ToString(name, CultureInfo.InvariantCulture);
+                    }
+                }
+            }
+            else if (TryConvertToString(name, name.GetType(), out string? propertyName))
+            {
+                escape = true;
+                return propertyName;
+            }
+            else
+            {
+                escape = true;
+                return name.ToString();
+            }
+        }
+
+        private void HandleError(JsonWriter writer, int initialDepth)
+        {
+            ClearErrorContext();
+
+            if (writer.WriteState == WriteState.Property)
+            {
+                writer.WriteNull();
+            }
+
+            while (writer.Top > initialDepth)
+            {
+                writer.WriteEnd();
+            }
+        }
+
+        private bool ShouldSerialize(JsonWriter writer, JsonProperty property, object target)
+        {
+            if (property.ShouldSerialize == null)
+            {
+                return true;
+            }
+
+            bool shouldSerialize = property.ShouldSerialize(target);
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+            {
+                TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(null, writer.Path, "ShouldSerialize result for property '{0}' on {1}: {2}".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType, shouldSerialize)), null);
+            }
+
+            return shouldSerialize;
+        }
+
+        private bool IsSpecified(JsonWriter writer, JsonProperty property, object target)
+        {
+            if (property.GetIsSpecified == null)
+            {
+                return true;
+            }
+
+            bool isSpecified = property.GetIsSpecified(target);
+
+            if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
+            {
+                TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(null, writer.Path, "IsSpecified result for property '{0}' on {1}: {2}".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType, isSpecified)), null);
+            }
+
+            return isSpecified;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonSerializerProxy.cs b/Libs/Newtonsoft.Json/Serialization/JsonSerializerProxy.cs
new file mode 100644
index 0000000..a0aab19
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonSerializerProxy.cs
@@ -0,0 +1,289 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Globalization;
+using System.Runtime.Serialization.Formatters;
+using LC.Newtonsoft.Json.Utilities;
+using System.Runtime.Serialization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class JsonSerializerProxy : JsonSerializer
+    {
+        private readonly JsonSerializerInternalReader? _serializerReader;
+        private readonly JsonSerializerInternalWriter? _serializerWriter;
+        private readonly JsonSerializer _serializer;
+
+        public override event EventHandler<ErrorEventArgs>? Error
+        {
+            add => _serializer.Error += value;
+            remove => _serializer.Error -= value;
+        }
+
+        public override IReferenceResolver? ReferenceResolver
+        {
+            get => _serializer.ReferenceResolver;
+            set => _serializer.ReferenceResolver = value;
+        }
+
+        public override ITraceWriter? TraceWriter
+        {
+            get => _serializer.TraceWriter;
+            set => _serializer.TraceWriter = value;
+        }
+
+        public override IEqualityComparer? EqualityComparer
+        {
+            get => _serializer.EqualityComparer;
+            set => _serializer.EqualityComparer = value;
+        }
+
+        public override JsonConverterCollection Converters => _serializer.Converters;
+
+        public override DefaultValueHandling DefaultValueHandling
+        {
+            get => _serializer.DefaultValueHandling;
+            set => _serializer.DefaultValueHandling = value;
+        }
+
+        public override IContractResolver ContractResolver
+        {
+            get => _serializer.ContractResolver;
+            set => _serializer.ContractResolver = value;
+        }
+
+        public override MissingMemberHandling MissingMemberHandling
+        {
+            get => _serializer.MissingMemberHandling;
+            set => _serializer.MissingMemberHandling = value;
+        }
+
+        public override NullValueHandling NullValueHandling
+        {
+            get => _serializer.NullValueHandling;
+            set => _serializer.NullValueHandling = value;
+        }
+
+        public override ObjectCreationHandling ObjectCreationHandling
+        {
+            get => _serializer.ObjectCreationHandling;
+            set => _serializer.ObjectCreationHandling = value;
+        }
+
+        public override ReferenceLoopHandling ReferenceLoopHandling
+        {
+            get => _serializer.ReferenceLoopHandling;
+            set => _serializer.ReferenceLoopHandling = value;
+        }
+
+        public override PreserveReferencesHandling PreserveReferencesHandling
+        {
+            get => _serializer.PreserveReferencesHandling;
+            set => _serializer.PreserveReferencesHandling = value;
+        }
+
+        public override TypeNameHandling TypeNameHandling
+        {
+            get => _serializer.TypeNameHandling;
+            set => _serializer.TypeNameHandling = value;
+        }
+
+        public override MetadataPropertyHandling MetadataPropertyHandling
+        {
+            get => _serializer.MetadataPropertyHandling;
+            set => _serializer.MetadataPropertyHandling = value;
+        }
+
+        [Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
+        public override FormatterAssemblyStyle TypeNameAssemblyFormat
+        {
+            get => _serializer.TypeNameAssemblyFormat;
+            set => _serializer.TypeNameAssemblyFormat = value;
+        }
+
+        public override TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
+        {
+            get => _serializer.TypeNameAssemblyFormatHandling;
+            set => _serializer.TypeNameAssemblyFormatHandling = value;
+        }
+
+        public override ConstructorHandling ConstructorHandling
+        {
+            get => _serializer.ConstructorHandling;
+            set => _serializer.ConstructorHandling = value;
+        }
+
+        [Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
+        public override SerializationBinder Binder
+        {
+            get => _serializer.Binder;
+            set => _serializer.Binder = value;
+        }
+
+        public override ISerializationBinder SerializationBinder
+        {
+            get => _serializer.SerializationBinder;
+            set => _serializer.SerializationBinder = value;
+        }
+
+        public override StreamingContext Context
+        {
+            get => _serializer.Context;
+            set => _serializer.Context = value;
+        }
+
+        public override Formatting Formatting
+        {
+            get => _serializer.Formatting;
+            set => _serializer.Formatting = value;
+        }
+
+        public override DateFormatHandling DateFormatHandling
+        {
+            get => _serializer.DateFormatHandling;
+            set => _serializer.DateFormatHandling = value;
+        }
+
+        public override DateTimeZoneHandling DateTimeZoneHandling
+        {
+            get => _serializer.DateTimeZoneHandling;
+            set => _serializer.DateTimeZoneHandling = value;
+        }
+
+        public override DateParseHandling DateParseHandling
+        {
+            get => _serializer.DateParseHandling;
+            set => _serializer.DateParseHandling = value;
+        }
+
+        public override FloatFormatHandling FloatFormatHandling
+        {
+            get => _serializer.FloatFormatHandling;
+            set => _serializer.FloatFormatHandling = value;
+        }
+
+        public override FloatParseHandling FloatParseHandling
+        {
+            get => _serializer.FloatParseHandling;
+            set => _serializer.FloatParseHandling = value;
+        }
+
+        public override StringEscapeHandling StringEscapeHandling
+        {
+            get => _serializer.StringEscapeHandling;
+            set => _serializer.StringEscapeHandling = value;
+        }
+
+        public override string DateFormatString
+        {
+            get => _serializer.DateFormatString;
+            set => _serializer.DateFormatString = value;
+        }
+
+        public override CultureInfo Culture
+        {
+            get => _serializer.Culture;
+            set => _serializer.Culture = value;
+        }
+
+        public override int? MaxDepth
+        {
+            get => _serializer.MaxDepth;
+            set => _serializer.MaxDepth = value;
+        }
+
+        public override bool CheckAdditionalContent
+        {
+            get => _serializer.CheckAdditionalContent;
+            set => _serializer.CheckAdditionalContent = value;
+        }
+
+        internal JsonSerializerInternalBase GetInternalSerializer()
+        {
+            if (_serializerReader != null)
+            {
+                return _serializerReader;
+            }
+            else
+            {
+                return _serializerWriter!;
+            }
+        }
+
+        public JsonSerializerProxy(JsonSerializerInternalReader serializerReader)
+        {
+            ValidationUtils.ArgumentNotNull(serializerReader, nameof(serializerReader));
+
+            _serializerReader = serializerReader;
+            _serializer = serializerReader.Serializer;
+        }
+
+        public JsonSerializerProxy(JsonSerializerInternalWriter serializerWriter)
+        {
+            ValidationUtils.ArgumentNotNull(serializerWriter, nameof(serializerWriter));
+
+            _serializerWriter = serializerWriter;
+            _serializer = serializerWriter.Serializer;
+        }
+
+        internal override object? DeserializeInternal(JsonReader reader, Type? objectType)
+        {
+            if (_serializerReader != null)
+            {
+                return _serializerReader.Deserialize(reader, objectType, false);
+            }
+            else
+            {
+                return _serializer.Deserialize(reader, objectType);
+            }
+        }
+
+        internal override void PopulateInternal(JsonReader reader, object target)
+        {
+            if (_serializerReader != null)
+            {
+                _serializerReader.Populate(reader, target);
+            }
+            else
+            {
+                _serializer.Populate(reader, target);
+            }
+        }
+
+        internal override void SerializeInternal(JsonWriter jsonWriter, object? value, Type? rootType)
+        {
+            if (_serializerWriter != null)
+            {
+                _serializerWriter.Serialize(jsonWriter, value, rootType);
+            }
+            else
+            {
+                _serializer.Serialize(jsonWriter, value);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonStringContract.cs b/Libs/Newtonsoft.Json/Serialization/JsonStringContract.cs
new file mode 100644
index 0000000..bfa4d43
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonStringContract.cs
@@ -0,0 +1,45 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Contract details for a <see cref="Type"/> used by the <see cref="JsonSerializer"/>.
+    /// </summary>
+    public class JsonStringContract : JsonPrimitiveContract
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonStringContract"/> class.
+        /// </summary>
+        /// <param name="underlyingType">The underlying type for the contract.</param>
+        public JsonStringContract(Type underlyingType)
+            : base(underlyingType)
+        {
+            ContractType = JsonContractType.String;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/JsonTypeReflector.cs b/Libs/Newtonsoft.Json/Serialization/JsonTypeReflector.cs
new file mode 100644
index 0000000..1995d86
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/JsonTypeReflector.cs
@@ -0,0 +1,531 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+using System.Security;
+#if HAVE_CAS
+using System.Security.Permissions;
+#endif
+using LC.Newtonsoft.Json.Utilities;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Runtime.Serialization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal static class JsonTypeReflector
+    {
+        private static bool? _dynamicCodeGeneration;
+        private static bool? _fullyTrusted;
+
+        public const string IdPropertyName = "$id";
+        public const string RefPropertyName = "$ref";
+        public const string TypePropertyName = "$type";
+        public const string ValuePropertyName = "$value";
+        public const string ArrayValuesPropertyName = "$values";
+
+        public const string ShouldSerializePrefix = "ShouldSerialize";
+        public const string SpecifiedPostfix = "Specified";
+
+        public const string ConcurrentDictionaryTypeName = "System.Collections.Concurrent.ConcurrentDictionary`2";
+
+        private static readonly ThreadSafeStore<Type, Func<object[]?, object>> CreatorCache = 
+            new ThreadSafeStore<Type, Func<object[]?, object>>(GetCreator);
+
+#if !(NET20 || DOTNET)
+        private static readonly ThreadSafeStore<Type, Type?> AssociatedMetadataTypesCache = new ThreadSafeStore<Type, Type?>(GetAssociateMetadataTypeFromAttribute);
+        private static ReflectionObject? _metadataTypeAttributeReflectionObject;
+#endif
+
+        public static T? GetCachedAttribute<T>(object attributeProvider) where T : Attribute
+        {
+            return CachedAttributeGetter<T>.GetAttribute(attributeProvider);
+        }
+
+#if HAVE_TYPE_DESCRIPTOR
+        public static bool CanTypeDescriptorConvertString(Type type, out TypeConverter typeConverter)
+        {
+            typeConverter = TypeDescriptor.GetConverter(type);
+
+            // use the objectType's TypeConverter if it has one and can convert to a string
+            if (typeConverter != null)
+            {
+                Type converterType = typeConverter.GetType();
+
+                if (!string.Equals(converterType.FullName, "System.ComponentModel.ComponentConverter", StringComparison.Ordinal)
+                    && !string.Equals(converterType.FullName, "System.ComponentModel.ReferenceConverter", StringComparison.Ordinal)
+                    && !string.Equals(converterType.FullName, "System.Windows.Forms.Design.DataSourceConverter", StringComparison.Ordinal)
+                    && converterType != typeof(TypeConverter))
+                {
+                    return typeConverter.CanConvertTo(typeof(string));
+                }
+
+            }
+
+            return false;
+        }
+#endif
+
+#if HAVE_DATA_CONTRACTS
+        public static DataContractAttribute? GetDataContractAttribute(Type type)
+        {
+            // DataContractAttribute does not have inheritance
+            Type currentType = type;
+
+            while (currentType != null)
+            {
+                DataContractAttribute? result = CachedAttributeGetter<DataContractAttribute>.GetAttribute(currentType);
+                if (result != null)
+                {
+                    return result;
+                }
+
+                currentType = currentType.BaseType();
+            }
+
+            return null;
+        }
+
+        public static DataMemberAttribute? GetDataMemberAttribute(MemberInfo memberInfo)
+        {
+            // DataMemberAttribute does not have inheritance
+
+            // can't override a field
+            if (memberInfo.MemberType() == MemberTypes.Field)
+            {
+                return CachedAttributeGetter<DataMemberAttribute>.GetAttribute(memberInfo);
+            }
+
+            // search property and then search base properties if nothing is returned and the property is virtual
+            PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
+            DataMemberAttribute? result = CachedAttributeGetter<DataMemberAttribute>.GetAttribute(propertyInfo);
+            if (result == null)
+            {
+                if (propertyInfo.IsVirtual())
+                {
+                    Type currentType = propertyInfo.DeclaringType;
+
+                    while (result == null && currentType != null)
+                    {
+                        PropertyInfo baseProperty = (PropertyInfo)ReflectionUtils.GetMemberInfoFromType(currentType, propertyInfo);
+                        if (baseProperty != null && baseProperty.IsVirtual())
+                        {
+                            result = CachedAttributeGetter<DataMemberAttribute>.GetAttribute(baseProperty);
+                        }
+
+                        currentType = currentType.BaseType();
+                    }
+                }
+            }
+
+            return result;
+        }
+#endif
+
+        public static MemberSerialization GetObjectMemberSerialization(Type objectType, bool ignoreSerializableAttribute)
+        {
+            JsonObjectAttribute? objectAttribute = GetCachedAttribute<JsonObjectAttribute>(objectType);
+            if (objectAttribute != null)
+            {
+                return objectAttribute.MemberSerialization;
+            }
+
+#if HAVE_DATA_CONTRACTS
+            DataContractAttribute? dataContractAttribute = GetDataContractAttribute(objectType);
+            if (dataContractAttribute != null)
+            {
+                return MemberSerialization.OptIn;
+            }
+#endif
+
+#if HAVE_BINARY_SERIALIZATION
+            if (!ignoreSerializableAttribute && IsSerializable(objectType))
+            {
+                return MemberSerialization.Fields;
+            }
+#endif
+
+            // the default
+            return MemberSerialization.OptOut;
+        }
+
+        public static JsonConverter? GetJsonConverter(object attributeProvider)
+        {
+            JsonConverterAttribute? converterAttribute = GetCachedAttribute<JsonConverterAttribute>(attributeProvider);
+
+            if (converterAttribute != null)
+            {
+                Func<object[]?, object> creator = CreatorCache.Get(converterAttribute.ConverterType);
+                if (creator != null)
+                {
+                    return (JsonConverter)creator(converterAttribute.ConverterParameters);
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Lookup and create an instance of the <see cref="JsonConverter"/> type described by the argument.
+        /// </summary>
+        /// <param name="converterType">The <see cref="JsonConverter"/> type to create.</param>
+        /// <param name="args">Optional arguments to pass to an initializing constructor of the JsonConverter.
+        /// If <c>null</c>, the default constructor is used.</param>
+        public static JsonConverter CreateJsonConverterInstance(Type converterType, object[]? args)
+        {
+            Func<object[]?, object> converterCreator = CreatorCache.Get(converterType);
+            return (JsonConverter)converterCreator(args);
+        }
+
+        public static NamingStrategy CreateNamingStrategyInstance(Type namingStrategyType, object[]? args)
+        {
+            Func<object[]?, object> converterCreator = CreatorCache.Get(namingStrategyType);
+            return (NamingStrategy)converterCreator(args);
+        }
+
+        public static NamingStrategy? GetContainerNamingStrategy(JsonContainerAttribute containerAttribute)
+        {
+            if (containerAttribute.NamingStrategyInstance == null)
+            {
+                if (containerAttribute.NamingStrategyType == null)
+                {
+                    return null;
+                }
+
+                containerAttribute.NamingStrategyInstance = CreateNamingStrategyInstance(containerAttribute.NamingStrategyType, containerAttribute.NamingStrategyParameters);
+            }
+
+            return containerAttribute.NamingStrategyInstance;
+        }
+
+        private static Func<object[]?, object> GetCreator(Type type)
+        {
+            Func<object>? defaultConstructor = (ReflectionUtils.HasDefaultConstructor(type, false))
+                ? ReflectionDelegateFactory.CreateDefaultConstructor<object>(type)
+                : null;
+
+            return (parameters) =>
+            {
+                try
+                {
+                    if (parameters != null)
+                    {
+                        Type[] paramTypes = parameters.Select(param =>
+                        {
+                            if (param == null)
+                            {
+                                throw new InvalidOperationException("Cannot pass a null parameter to the constructor.");
+                            }
+
+                            return param.GetType();
+                        }).ToArray();
+                        ConstructorInfo parameterizedConstructorInfo = type.GetConstructor(paramTypes);
+
+                        if (parameterizedConstructorInfo != null)
+                        {
+                            ObjectConstructor<object> parameterizedConstructor = ReflectionDelegateFactory.CreateParameterizedConstructor(parameterizedConstructorInfo);
+                            return parameterizedConstructor(parameters);
+                        }
+                        else
+                        {
+                            throw new JsonException("No matching parameterized constructor found for '{0}'.".FormatWith(CultureInfo.InvariantCulture, type));
+                        }
+                    }
+
+                    if (defaultConstructor == null)
+                    {
+                        throw new JsonException("No parameterless constructor defined for '{0}'.".FormatWith(CultureInfo.InvariantCulture, type));
+                    }
+
+                    return defaultConstructor();
+                }
+                catch (Exception ex)
+                {
+                    throw new JsonException("Error creating '{0}'.".FormatWith(CultureInfo.InvariantCulture, type), ex);
+                }
+            };
+        }
+
+#if !(NET20 || DOTNET)
+        private static Type? GetAssociatedMetadataType(Type type)
+        {
+            return AssociatedMetadataTypesCache.Get(type);
+        }
+
+        private static Type? GetAssociateMetadataTypeFromAttribute(Type type)
+        {
+            Attribute[] customAttributes = ReflectionUtils.GetAttributes(type, null, true);
+
+            foreach (Attribute attribute in customAttributes)
+            {
+                Type attributeType = attribute.GetType();
+
+                // only test on attribute type name
+                // attribute assembly could change because of type forwarding, etc
+                if (string.Equals(attributeType.FullName, "System.ComponentModel.DataAnnotations.MetadataTypeAttribute", StringComparison.Ordinal))
+                {
+                    const string metadataClassTypeName = "MetadataClassType";
+
+                    if (_metadataTypeAttributeReflectionObject == null)
+                    {
+                        _metadataTypeAttributeReflectionObject = ReflectionObject.Create(attributeType, metadataClassTypeName);
+                    }
+
+                    return (Type?)_metadataTypeAttributeReflectionObject.GetValue(attribute, metadataClassTypeName);
+                }
+            }
+
+            return null;
+        }
+#endif
+
+        private static T? GetAttribute<T>(Type type) where T : Attribute
+        {
+            T? attribute;
+
+#if !(NET20 || DOTNET)
+            Type? metadataType = GetAssociatedMetadataType(type);
+            if (metadataType != null)
+            {
+                attribute = ReflectionUtils.GetAttribute<T>(metadataType, true);
+                if (attribute != null)
+                {
+                    return attribute;
+                }
+            }
+#endif
+
+            attribute = ReflectionUtils.GetAttribute<T>(type, true);
+            if (attribute != null)
+            {
+                return attribute;
+            }
+
+            foreach (Type typeInterface in type.GetInterfaces())
+            {
+                attribute = ReflectionUtils.GetAttribute<T>(typeInterface, true);
+                if (attribute != null)
+                {
+                    return attribute;
+                }
+            }
+
+            return null;
+        }
+
+        private static T? GetAttribute<T>(MemberInfo memberInfo) where T : Attribute
+        {
+            T? attribute;
+
+#if !(NET20 || DOTNET)
+            Type? metadataType = GetAssociatedMetadataType(memberInfo.DeclaringType);
+            if (metadataType != null)
+            {
+                MemberInfo metadataTypeMemberInfo = ReflectionUtils.GetMemberInfoFromType(metadataType, memberInfo);
+
+                if (metadataTypeMemberInfo != null)
+                {
+                    attribute = ReflectionUtils.GetAttribute<T>(metadataTypeMemberInfo, true);
+                    if (attribute != null)
+                    {
+                        return attribute;
+                    }
+                }
+            }
+#endif
+
+            attribute = ReflectionUtils.GetAttribute<T>(memberInfo, true);
+            if (attribute != null)
+            {
+                return attribute;
+            }
+
+            if (memberInfo.DeclaringType != null)
+            {
+                foreach (Type typeInterface in memberInfo.DeclaringType.GetInterfaces())
+                {
+                    MemberInfo interfaceTypeMemberInfo = ReflectionUtils.GetMemberInfoFromType(typeInterface, memberInfo);
+
+                    if (interfaceTypeMemberInfo != null)
+                    {
+                        attribute = ReflectionUtils.GetAttribute<T>(interfaceTypeMemberInfo, true);
+                        if (attribute != null)
+                        {
+                            return attribute;
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
+#if HAVE_NON_SERIALIZED_ATTRIBUTE
+        public static bool IsNonSerializable(object provider)
+        {
+#if HAVE_FULL_REFLECTION
+            // no inheritance
+            return (ReflectionUtils.GetAttribute<NonSerializedAttribute>(provider, false) != null);
+#else
+            if (provider is FieldInfo fieldInfo && (fieldInfo.Attributes & FieldAttributes.NotSerialized) == FieldAttributes.NotSerialized)
+            {
+                return true;
+            }
+
+            return false;
+#endif
+        }
+#endif
+
+#if HAVE_BINARY_SERIALIZATION
+        public static bool IsSerializable(object provider)
+        {
+#if HAVE_FULL_REFLECTION
+            // no inheritance
+            return (ReflectionUtils.GetAttribute<SerializableAttribute>(provider, false) != null);
+#else
+            if (provider is Type type && (type.GetTypeInfo().Attributes & TypeAttributes.Serializable) == TypeAttributes.Serializable)
+            {
+                return true;
+            }
+
+            return false;
+#endif
+        }
+#endif
+
+        public static T? GetAttribute<T>(object provider) where T : Attribute
+        {
+            if (provider is Type type)
+            {
+                return GetAttribute<T>(type);
+            }
+
+            if (provider is MemberInfo memberInfo)
+            {
+                return GetAttribute<T>(memberInfo);
+            }
+
+            return ReflectionUtils.GetAttribute<T>(provider, true);
+        }
+
+#if DEBUG
+        internal static void SetFullyTrusted(bool? fullyTrusted)
+        {
+            _fullyTrusted = fullyTrusted;
+        }
+
+        internal static void SetDynamicCodeGeneration(bool dynamicCodeGeneration)
+        {
+            _dynamicCodeGeneration = dynamicCodeGeneration;
+        }
+#endif
+
+        public static bool DynamicCodeGeneration
+        {
+#if HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE
+            [SecuritySafeCritical]
+#endif
+            get
+            {
+                if (_dynamicCodeGeneration == null)
+                {
+#if HAVE_CAS
+                    try
+                    {
+                        new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
+                        new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess).Demand();
+                        new SecurityPermission(SecurityPermissionFlag.SkipVerification).Demand();
+                        new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
+                        new SecurityPermission(PermissionState.Unrestricted).Demand();
+                        _dynamicCodeGeneration = true;
+                    }
+                    catch (Exception)
+                    {
+                        _dynamicCodeGeneration = false;
+                    }
+#else
+                    _dynamicCodeGeneration = false;
+#endif
+                }
+
+                return _dynamicCodeGeneration.GetValueOrDefault();
+            }
+        }
+
+        public static bool FullyTrusted
+        {
+            get
+            {
+                if (_fullyTrusted == null)
+                {
+#if (DOTNET || PORTABLE || PORTABLE40)
+                    _fullyTrusted = true;
+#elif !(NET20 || NET35 || PORTABLE40)
+                    AppDomain appDomain = AppDomain.CurrentDomain;
+
+                    _fullyTrusted = appDomain.IsHomogenous && appDomain.IsFullyTrusted;
+#else
+                    try
+                    {
+                        new SecurityPermission(PermissionState.Unrestricted).Demand();
+                        _fullyTrusted = true;
+                    }
+                    catch (Exception)
+                    {
+                        _fullyTrusted = false;
+                    }
+#endif
+                }
+
+                return _fullyTrusted.GetValueOrDefault();
+            }
+        }
+
+        public static ReflectionDelegateFactory ReflectionDelegateFactory
+        {
+            get
+            {
+#if !(PORTABLE40 || PORTABLE || DOTNET || NETSTANDARD2_0)
+                if (DynamicCodeGeneration)
+                {
+                    return DynamicReflectionDelegateFactory.Instance;
+                }
+
+                return LateBoundReflectionDelegateFactory.Instance;
+#else
+                return ExpressionReflectionDelegateFactory.Instance;
+#endif
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/KebabCaseNamingStrategy.cs b/Libs/Newtonsoft.Json/Serialization/KebabCaseNamingStrategy.cs
new file mode 100644
index 0000000..0d98fa3
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/KebabCaseNamingStrategy.cs
@@ -0,0 +1,84 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// A kebab case naming strategy.
+    /// </summary>
+    public class KebabCaseNamingStrategy : NamingStrategy
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KebabCaseNamingStrategy"/> class.
+        /// </summary>
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
+        /// </param>
+        /// <param name="overrideSpecifiedNames">
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
+        /// </param>
+        public KebabCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames)
+        {
+            ProcessDictionaryKeys = processDictionaryKeys;
+            OverrideSpecifiedNames = overrideSpecifiedNames;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KebabCaseNamingStrategy"/> class.
+        /// </summary>
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
+        /// </param>
+        /// <param name="overrideSpecifiedNames">
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
+        /// </param>
+        /// <param name="processExtensionDataNames">
+        /// A flag indicating whether extension data names should be processed.
+        /// </param>
+        public KebabCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames, bool processExtensionDataNames)
+            : this(processDictionaryKeys, overrideSpecifiedNames)
+        {
+            ProcessExtensionDataNames = processExtensionDataNames;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KebabCaseNamingStrategy"/> class.
+        /// </summary>
+        public KebabCaseNamingStrategy()
+        {
+        }
+
+        /// <summary>
+        /// Resolves the specified property name.
+        /// </summary>
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected override string ResolvePropertyName(string name) => StringUtils.ToKebabCase(name);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/MemoryTraceWriter.cs b/Libs/Newtonsoft.Json/Serialization/MemoryTraceWriter.cs
new file mode 100644
index 0000000..ea6f4fa
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/MemoryTraceWriter.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Text;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Represents a trace writer that writes to memory. When the trace message limit is
+    /// reached then old trace messages will be removed as new messages are added.
+    /// </summary>
+    public class MemoryTraceWriter : ITraceWriter
+    {
+        private readonly Queue<string> _traceMessages;
+        private readonly object _lock;
+
+        /// <summary>
+        /// Gets the <see cref="TraceLevel"/> that will be used to filter the trace messages passed to the writer.
+        /// For example a filter level of <see cref="TraceLevel.Info"/> will exclude <see cref="TraceLevel.Verbose"/> messages and include <see cref="TraceLevel.Info"/>,
+        /// <see cref="TraceLevel.Warning"/> and <see cref="TraceLevel.Error"/> messages.
+        /// </summary>
+        /// <value>
+        /// The <see cref="TraceLevel"/> that will be used to filter the trace messages passed to the writer.
+        /// </value>
+        public TraceLevel LevelFilter { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MemoryTraceWriter"/> class.
+        /// </summary>
+        public MemoryTraceWriter()
+        {
+            LevelFilter = TraceLevel.Verbose;
+            _traceMessages = new Queue<string>();
+            _lock = new object();
+        }
+
+        /// <summary>
+        /// Writes the specified trace level, message and optional exception.
+        /// </summary>
+        /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param>
+        /// <param name="message">The trace message.</param>
+        /// <param name="ex">The trace exception. This parameter is optional.</param>
+        public void Trace(TraceLevel level, string message, Exception? ex)
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.Append(DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff", CultureInfo.InvariantCulture));
+            sb.Append(" ");
+            sb.Append(level.ToString("g"));
+            sb.Append(" ");
+            sb.Append(message);
+
+            string s = sb.ToString();
+
+            lock (_lock)
+            {
+                if (_traceMessages.Count >= 1000)
+                {
+                    _traceMessages.Dequeue();
+                }
+
+                _traceMessages.Enqueue(s);
+            }
+        }
+
+        /// <summary>
+        /// Returns an enumeration of the most recent trace messages.
+        /// </summary>
+        /// <returns>An enumeration of the most recent trace messages.</returns>
+        public IEnumerable<string> GetTraceMessages()
+        {
+            return _traceMessages;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> of the most recent trace messages.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="String"/> of the most recent trace messages.
+        /// </returns>
+        public override string ToString()
+        {
+            lock (_lock)
+            {
+                StringBuilder sb = new StringBuilder();
+                foreach (string traceMessage in _traceMessages)
+                {
+                    if (sb.Length > 0)
+                    {
+                        sb.AppendLine();
+                    }
+
+                    sb.Append(traceMessage);
+                }
+
+                return sb.ToString();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/NamingStrategy.cs b/Libs/Newtonsoft.Json/Serialization/NamingStrategy.cs
new file mode 100644
index 0000000..d0aa684
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/NamingStrategy.cs
@@ -0,0 +1,146 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// A base class for resolving how property names and dictionary keys are serialized.
+    /// </summary>
+    public abstract class NamingStrategy
+    {
+        /// <summary>
+        /// A flag indicating whether dictionary keys should be processed.
+        /// Defaults to <c>false</c>.
+        /// </summary>
+        public bool ProcessDictionaryKeys { get; set; }
+
+        /// <summary>
+        /// A flag indicating whether extension data names should be processed.
+        /// Defaults to <c>false</c>.
+        /// </summary>
+        public bool ProcessExtensionDataNames { get; set; }
+
+        /// <summary>
+        /// A flag indicating whether explicitly specified property names,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>, should be processed.
+        /// Defaults to <c>false</c>.
+        /// </summary>
+        public bool OverrideSpecifiedNames { get; set; }
+
+        /// <summary>
+        /// Gets the serialized name for a given property name.
+        /// </summary>
+        /// <param name="name">The initial property name.</param>
+        /// <param name="hasSpecifiedName">A flag indicating whether the property has had a name explicitly specified.</param>
+        /// <returns>The serialized property name.</returns>
+        public virtual string GetPropertyName(string name, bool hasSpecifiedName)
+        {
+            if (hasSpecifiedName && !OverrideSpecifiedNames)
+            {
+                return name;
+            }
+
+            return ResolvePropertyName(name);
+        }
+
+        /// <summary>
+        /// Gets the serialized name for a given extension data name.
+        /// </summary>
+        /// <param name="name">The initial extension data name.</param>
+        /// <returns>The serialized extension data name.</returns>
+        public virtual string GetExtensionDataName(string name)
+        {
+            if (!ProcessExtensionDataNames)
+            {
+                return name;
+            }
+
+            return ResolvePropertyName(name);
+        }
+
+        /// <summary>
+        /// Gets the serialized key for a given dictionary key.
+        /// </summary>
+        /// <param name="key">The initial dictionary key.</param>
+        /// <returns>The serialized dictionary key.</returns>
+        public virtual string GetDictionaryKey(string key)
+        {
+            if (!ProcessDictionaryKeys)
+            {
+                return key;
+            }
+
+            return ResolvePropertyName(key);
+        }
+
+        /// <summary>
+        /// Resolves the specified property name.
+        /// </summary>
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected abstract string ResolvePropertyName(string name);
+
+        /// <summary>
+        /// Hash code calculation
+        /// </summary>
+        /// <returns></returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = GetType().GetHashCode();     // make sure different types do not result in equal values
+                hashCode = (hashCode * 397) ^ ProcessDictionaryKeys.GetHashCode();
+                hashCode = (hashCode * 397) ^ ProcessExtensionDataNames.GetHashCode();
+                hashCode = (hashCode * 397) ^ OverrideSpecifiedNames.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// Object equality implementation
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public override bool Equals(object obj) => Equals(obj as NamingStrategy);
+
+        /// <summary>
+        /// Compare to another NamingStrategy
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        protected bool Equals(NamingStrategy? other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return GetType() == other.GetType() &&
+                ProcessDictionaryKeys == other.ProcessDictionaryKeys &&
+                ProcessExtensionDataNames == other.ProcessExtensionDataNames &&
+                OverrideSpecifiedNames == other.OverrideSpecifiedNames;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ObjectConstructor.cs b/Libs/Newtonsoft.Json/Serialization/ObjectConstructor.cs
new file mode 100644
index 0000000..27508bb
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ObjectConstructor.cs
@@ -0,0 +1,33 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Represents a method that constructs an object.
+    /// </summary>
+    /// <typeparam name="T">The object type to create.</typeparam>
+    public delegate object ObjectConstructor<T>(params object?[] args);
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/OnErrorAttribute.cs b/Libs/Newtonsoft.Json/Serialization/OnErrorAttribute.cs
new file mode 100644
index 0000000..c965148
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/OnErrorAttribute.cs
@@ -0,0 +1,37 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// When applied to a method, specifies that the method is called when an error occurs serializing an object.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
+    public sealed class OnErrorAttribute : Attribute
+    {
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ReflectionAttributeProvider.cs b/Libs/Newtonsoft.Json/Serialization/ReflectionAttributeProvider.cs
new file mode 100644
index 0000000..418e2b1
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ReflectionAttributeProvider.cs
@@ -0,0 +1,71 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Provides methods to get attributes from a <see cref="System.Type"/>, <see cref="MemberInfo"/>, <see cref="ParameterInfo"/> or <see cref="Assembly"/>.
+    /// </summary>
+    public class ReflectionAttributeProvider : IAttributeProvider
+    {
+        private readonly object _attributeProvider;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReflectionAttributeProvider"/> class.
+        /// </summary>
+        /// <param name="attributeProvider">The instance to get attributes for. This parameter should be a <see cref="System.Type"/>, <see cref="MemberInfo"/>, <see cref="ParameterInfo"/> or <see cref="Assembly"/>.</param>
+        public ReflectionAttributeProvider(object attributeProvider)
+        {
+            ValidationUtils.ArgumentNotNull(attributeProvider, nameof(attributeProvider));
+            _attributeProvider = attributeProvider;
+        }
+
+        /// <summary>
+        /// Returns a collection of all of the attributes, or an empty collection if there are no attributes.
+        /// </summary>
+        /// <param name="inherit">When <c>true</c>, look up the hierarchy chain for the inherited custom attribute.</param>
+        /// <returns>A collection of <see cref="Attribute"/>s, or an empty collection.</returns>
+        public IList<Attribute> GetAttributes(bool inherit)
+        {
+            return ReflectionUtils.GetAttributes(_attributeProvider, null, inherit);
+        }
+
+        /// <summary>
+        /// Returns a collection of attributes, identified by type, or an empty collection if there are no attributes.
+        /// </summary>
+        /// <param name="attributeType">The type of the attributes.</param>
+        /// <param name="inherit">When <c>true</c>, look up the hierarchy chain for the inherited custom attribute.</param>
+        /// <returns>A collection of <see cref="Attribute"/>s, or an empty collection.</returns>
+        public IList<Attribute> GetAttributes(Type attributeType, bool inherit)
+        {
+            return ReflectionUtils.GetAttributes(_attributeProvider, attributeType, inherit);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/ReflectionValueProvider.cs b/Libs/Newtonsoft.Json/Serialization/ReflectionValueProvider.cs
new file mode 100644
index 0000000..f0b5f21
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/ReflectionValueProvider.cs
@@ -0,0 +1,90 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Reflection;
+using LC.Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// Get and set values for a <see cref="MemberInfo"/> using reflection.
+    /// </summary>
+    public class ReflectionValueProvider : IValueProvider
+    {
+        private readonly MemberInfo _memberInfo;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReflectionValueProvider"/> class.
+        /// </summary>
+        /// <param name="memberInfo">The member info.</param>
+        public ReflectionValueProvider(MemberInfo memberInfo)
+        {
+            ValidationUtils.ArgumentNotNull(memberInfo, nameof(memberInfo));
+            _memberInfo = memberInfo;
+        }
+
+        /// <summary>
+        /// Sets the value.
+        /// </summary>
+        /// <param name="target">The target to set the value on.</param>
+        /// <param name="value">The value to set on the target.</param>
+        public void SetValue(object target, object? value)
+        {
+            try
+            {
+                ReflectionUtils.SetMemberValue(_memberInfo, target, value);
+            }
+            catch (Exception ex)
+            {
+                throw new JsonSerializationException("Error setting value to '{0}' on '{1}'.".FormatWith(CultureInfo.InvariantCulture, _memberInfo.Name, target.GetType()), ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        /// <param name="target">The target to get the value from.</param>
+        /// <returns>The value.</returns>
+        public object? GetValue(object target)
+        {
+            try
+            {
+                // https://github.com/dotnet/corefx/issues/26053
+                if (_memberInfo is PropertyInfo propertyInfo && propertyInfo.PropertyType.IsByRef)
+                {
+                    throw new InvalidOperationException("Could not create getter for {0}. ByRef return values are not supported.".FormatWith(CultureInfo.InvariantCulture, propertyInfo));
+                }
+
+                return ReflectionUtils.GetMemberValue(_memberInfo, target);
+            }
+            catch (Exception ex)
+            {
+                throw new JsonSerializationException("Error getting value from '{0}' on '{1}'.".FormatWith(CultureInfo.InvariantCulture, _memberInfo.Name, target.GetType()), ex);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/SerializationBinderAdapter.cs b/Libs/Newtonsoft.Json/Serialization/SerializationBinderAdapter.cs
new file mode 100644
index 0000000..f2dceba
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/SerializationBinderAdapter.cs
@@ -0,0 +1,59 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Runtime.Serialization;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class SerializationBinderAdapter : ISerializationBinder
+    {
+#pragma warning disable 618
+        public readonly SerializationBinder SerializationBinder;
+#pragma warning restore 618
+
+#pragma warning disable 618
+        public SerializationBinderAdapter(SerializationBinder serializationBinder)
+        {
+            SerializationBinder = serializationBinder;
+        }
+#pragma warning restore 618
+
+        public Type BindToType(string? assemblyName, string typeName)
+        {
+            return SerializationBinder.BindToType(assemblyName, typeName);
+        }
+
+        public void BindToName(Type serializedType, out string? assemblyName, out string? typeName)
+        {
+#if HAVE_SERIALIZATION_BINDER_BIND_TO_NAME
+            SerializationBinder.BindToName(serializedType, out assemblyName, out typeName);
+#else
+            assemblyName = null;
+            typeName = null;
+#endif
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/SnakeCaseNamingStrategy.cs b/Libs/Newtonsoft.Json/Serialization/SnakeCaseNamingStrategy.cs
new file mode 100644
index 0000000..cdd90bb
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/SnakeCaseNamingStrategy.cs
@@ -0,0 +1,87 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using LC.Newtonsoft.Json.Utilities;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// A snake case naming strategy.
+    /// </summary>
+    public class SnakeCaseNamingStrategy : NamingStrategy
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SnakeCaseNamingStrategy"/> class.
+        /// </summary>
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
+        /// </param>
+        /// <param name="overrideSpecifiedNames">
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
+        /// </param>
+        public SnakeCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames)
+        {
+            ProcessDictionaryKeys = processDictionaryKeys;
+            OverrideSpecifiedNames = overrideSpecifiedNames;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SnakeCaseNamingStrategy"/> class.
+        /// </summary>
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
+        /// </param>
+        /// <param name="overrideSpecifiedNames">
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
+        /// </param>
+        /// <param name="processExtensionDataNames">
+        /// A flag indicating whether extension data names should be processed.
+        /// </param>
+        public SnakeCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames, bool processExtensionDataNames)
+            : this(processDictionaryKeys, overrideSpecifiedNames)
+        {
+            ProcessExtensionDataNames = processExtensionDataNames;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SnakeCaseNamingStrategy"/> class.
+        /// </summary>
+        public SnakeCaseNamingStrategy()
+        {
+        }
+
+        /// <summary>
+        /// Resolves the specified property name.
+        /// </summary>
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected override string ResolvePropertyName(string name)
+        {
+            return StringUtils.ToSnakeCase(name);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/TraceJsonReader.cs b/Libs/Newtonsoft.Json/Serialization/TraceJsonReader.cs
new file mode 100644
index 0000000..e01a639
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/TraceJsonReader.cs
@@ -0,0 +1,157 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class TraceJsonReader : JsonReader, IJsonLineInfo
+    {
+        private readonly JsonReader _innerReader;
+        private readonly JsonTextWriter _textWriter;
+        private readonly StringWriter _sw;
+
+        public TraceJsonReader(JsonReader innerReader)
+        {
+            _innerReader = innerReader;
+
+            _sw = new StringWriter(CultureInfo.InvariantCulture);
+            // prefix the message in the stringwriter to avoid concat with a potentially large JSON string
+            _sw.Write("Deserialized JSON: " + Environment.NewLine);
+
+            _textWriter = new JsonTextWriter(_sw);
+            _textWriter.Formatting = Formatting.Indented;
+        }
+
+        public string GetDeserializedJsonMessage()
+        {
+            return _sw.ToString();
+        }
+
+        public override bool Read()
+        {
+            bool value = _innerReader.Read();
+            WriteCurrentToken();
+            return value;
+        }
+
+        public override int? ReadAsInt32()
+        {
+            int? value = _innerReader.ReadAsInt32();
+            WriteCurrentToken();
+            return value;
+        }
+
+        public override string? ReadAsString()
+        {
+            string? value = _innerReader.ReadAsString();
+            WriteCurrentToken();
+            return value;
+        }
+
+        public override byte[]? ReadAsBytes()
+        {
+            byte[]? value = _innerReader.ReadAsBytes();
+            WriteCurrentToken();
+            return value;
+        }
+
+        public override decimal? ReadAsDecimal()
+        {
+            decimal? value = _innerReader.ReadAsDecimal();
+            WriteCurrentToken();
+            return value;
+        }
+
+        public override double? ReadAsDouble()
+        {
+            double? value = _innerReader.ReadAsDouble();
+            WriteCurrentToken();
+            return value;
+        }
+
+        public override bool? ReadAsBoolean()
+        {
+            bool? value = _innerReader.ReadAsBoolean();
+            WriteCurrentToken();
+            return value;
+        }
+
+        public override DateTime? ReadAsDateTime()
+        {
+            DateTime? value = _innerReader.ReadAsDateTime();
+            WriteCurrentToken();
+            return value;
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        public override DateTimeOffset? ReadAsDateTimeOffset()
+        {
+            DateTimeOffset? value = _innerReader.ReadAsDateTimeOffset();
+            WriteCurrentToken();
+            return value;
+        }
+#endif
+
+        public void WriteCurrentToken()
+        {
+            _textWriter.WriteToken(_innerReader, false, false, true);
+        }
+
+        public override int Depth => _innerReader.Depth;
+
+        public override string Path => _innerReader.Path;
+
+        public override char QuoteChar
+        {
+            get => _innerReader.QuoteChar;
+            protected internal set => _innerReader.QuoteChar = value;
+        }
+
+        public override JsonToken TokenType => _innerReader.TokenType;
+
+        public override object? Value => _innerReader.Value;
+
+        public override Type ?ValueType => _innerReader.ValueType;
+
+        public override void Close()
+        {
+            _innerReader.Close();
+        }
+
+        bool IJsonLineInfo.HasLineInfo()
+        {
+            return _innerReader is IJsonLineInfo lineInfo && lineInfo.HasLineInfo();
+        }
+
+        int IJsonLineInfo.LineNumber => (_innerReader is IJsonLineInfo lineInfo) ? lineInfo.LineNumber : 0;
+
+        int IJsonLineInfo.LinePosition => (_innerReader is IJsonLineInfo lineInfo) ? lineInfo.LinePosition : 0;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Serialization/TraceJsonWriter.cs b/Libs/Newtonsoft.Json/Serialization/TraceJsonWriter.cs
new file mode 100644
index 0000000..68c47ce
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Serialization/TraceJsonWriter.cs
@@ -0,0 +1,598 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.IO;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+    internal class TraceJsonWriter : JsonWriter
+    {
+        private readonly JsonWriter _innerWriter;
+        private readonly JsonTextWriter _textWriter;
+        private readonly StringWriter _sw;
+
+        public TraceJsonWriter(JsonWriter innerWriter)
+        {
+            _innerWriter = innerWriter;
+
+            _sw = new StringWriter(CultureInfo.InvariantCulture);
+            // prefix the message in the stringwriter to avoid concat with a potentially large JSON string
+            _sw.Write("Serialized JSON: " + Environment.NewLine);
+
+            _textWriter = new JsonTextWriter(_sw);
+            _textWriter.Formatting = Formatting.Indented;
+            _textWriter.Culture = innerWriter.Culture;
+            _textWriter.DateFormatHandling = innerWriter.DateFormatHandling;
+            _textWriter.DateFormatString = innerWriter.DateFormatString;
+            _textWriter.DateTimeZoneHandling = innerWriter.DateTimeZoneHandling;
+            _textWriter.FloatFormatHandling = innerWriter.FloatFormatHandling;
+        }
+
+        public string GetSerializedJsonMessage()
+        {
+            return _sw.ToString();
+        }
+
+        public override void WriteValue(decimal value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(decimal? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(bool value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(bool? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(byte value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(byte? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(char value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(char? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(byte[]? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value == null)
+            {
+                base.WriteUndefined();
+            }
+            else
+            {
+                base.WriteValue(value);
+            }
+        }
+
+        public override void WriteValue(DateTime value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(DateTime? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        public override void WriteValue(DateTimeOffset value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(DateTimeOffset? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+#endif
+
+        public override void WriteValue(double value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(double? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteUndefined()
+        {
+            _textWriter.WriteUndefined();
+            _innerWriter.WriteUndefined();
+            base.WriteUndefined();
+        }
+
+        public override void WriteNull()
+        {
+            _textWriter.WriteNull();
+            _innerWriter.WriteNull();
+            base.WriteUndefined();
+        }
+
+        public override void WriteValue(float value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(float? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(Guid value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(Guid? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(int value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(int? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(long value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(long? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(object? value)
+        {
+#if HAVE_BIG_INTEGER
+            if (value is BigInteger)
+            {
+                _textWriter.WriteValue(value);
+                _innerWriter.WriteValue(value);
+                InternalWriteValue(JsonToken.Integer);
+            }
+            else
+#endif
+            {
+                _textWriter.WriteValue(value);
+                _innerWriter.WriteValue(value);
+                if (value == null)
+                {
+                    base.WriteUndefined();
+                }
+                else
+                {
+                    // base.WriteValue(value) will error
+                    InternalWriteValue(JsonToken.String);
+                }
+            }
+        }
+
+        public override void WriteValue(sbyte value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(sbyte? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(short value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(short? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(string? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(TimeSpan value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(TimeSpan? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(uint value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(uint? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(ulong value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(ulong? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteValue(Uri? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value == null)
+            {
+                base.WriteUndefined();
+            }
+            else
+            {
+                base.WriteValue(value);
+            }
+        }
+
+        public override void WriteValue(ushort value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            base.WriteValue(value);
+        }
+
+        public override void WriteValue(ushort? value)
+        {
+            _textWriter.WriteValue(value);
+            _innerWriter.WriteValue(value);
+            if (value.HasValue)
+            {
+                base.WriteValue(value.GetValueOrDefault());
+            }
+            else
+            {
+                base.WriteUndefined();
+            }
+        }
+
+        public override void WriteWhitespace(string ws)
+        {
+            _textWriter.WriteWhitespace(ws);
+            _innerWriter.WriteWhitespace(ws);
+            base.WriteWhitespace(ws);
+        }
+
+        public override void WriteComment(string? text)
+        {
+            _textWriter.WriteComment(text);
+            _innerWriter.WriteComment(text);
+            base.WriteComment(text);
+        }
+
+        public override void WriteStartArray()
+        {
+            _textWriter.WriteStartArray();
+            _innerWriter.WriteStartArray();
+            base.WriteStartArray();
+        }
+
+        public override void WriteEndArray()
+        {
+            _textWriter.WriteEndArray();
+            _innerWriter.WriteEndArray();
+            base.WriteEndArray();
+        }
+
+        public override void WriteStartConstructor(string name)
+        {
+            _textWriter.WriteStartConstructor(name);
+            _innerWriter.WriteStartConstructor(name);
+            base.WriteStartConstructor(name);
+        }
+
+        public override void WriteEndConstructor()
+        {
+            _textWriter.WriteEndConstructor();
+            _innerWriter.WriteEndConstructor();
+            base.WriteEndConstructor();
+        }
+
+        public override void WritePropertyName(string name)
+        {
+            _textWriter.WritePropertyName(name);
+            _innerWriter.WritePropertyName(name);
+            base.WritePropertyName(name);
+        }
+
+        public override void WritePropertyName(string name, bool escape)
+        {
+            _textWriter.WritePropertyName(name, escape);
+            _innerWriter.WritePropertyName(name, escape);
+
+            // method with escape will error
+            base.WritePropertyName(name);
+        }
+
+        public override void WriteStartObject()
+        {
+            _textWriter.WriteStartObject();
+            _innerWriter.WriteStartObject();
+            base.WriteStartObject();
+        }
+
+        public override void WriteEndObject()
+        {
+            _textWriter.WriteEndObject();
+            _innerWriter.WriteEndObject();
+            base.WriteEndObject();
+        }
+
+        public override void WriteRawValue(string? json)
+        {
+            _textWriter.WriteRawValue(json);
+            _innerWriter.WriteRawValue(json);
+
+            // calling base method will write json twice
+            InternalWriteValue(JsonToken.Undefined);
+        }
+
+        public override void WriteRaw(string? json)
+        {
+            _textWriter.WriteRaw(json);
+            _innerWriter.WriteRaw(json);
+            base.WriteRaw(json);
+        }
+
+        public override void Close()
+        {
+            _textWriter.Close();
+            _innerWriter.Close();
+            base.Close();
+        }
+
+        public override void Flush()
+        {
+            _textWriter.Flush();
+            _innerWriter.Flush();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/SerializationBinder.cs b/Libs/Newtonsoft.Json/SerializationBinder.cs
new file mode 100644
index 0000000..4cc7f59
--- /dev/null
+++ b/Libs/Newtonsoft.Json/SerializationBinder.cs
@@ -0,0 +1,36 @@
+
+#if (DOTNET || PORTABLE40 || PORTABLE)
+using System;
+using System.Reflection;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Allows users to control class loading and mandate what class to load.
+    /// </summary>
+    [Obsolete("SerializationBinder is obsolete. Use ISerializationBinder instead.")]
+    public abstract class SerializationBinder
+    {
+        /// <summary>
+        /// When overridden in a derived class, controls the binding of a serialized object to a type.
+        /// </summary>
+        /// <param name="assemblyName">Specifies the <see cref="Assembly"/> name of the serialized object.</param>
+        /// <param name="typeName">Specifies the <see cref="System.Type"/> name of the serialized object</param>
+        /// <returns>The type of the object the formatter creates a new instance of.</returns>
+        public abstract Type BindToType(string? assemblyName, string typeName);
+
+        /// <summary>
+        /// When overridden in a derived class, controls the binding of a serialized object to a type.
+        /// </summary>
+        /// <param name="serializedType">The type of the object the formatter creates a new instance of.</param>
+        /// <param name="assemblyName">Specifies the <see cref="Assembly"/> name of the serialized object.</param>
+        /// <param name="typeName">Specifies the <see cref="System.Type"/> name of the serialized object.</param>
+        public virtual void BindToName(Type serializedType, out string? assemblyName, out string? typeName)
+        {
+            assemblyName = null;
+            typeName = null;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/StringEscapeHandling.cs b/Libs/Newtonsoft.Json/StringEscapeHandling.cs
new file mode 100644
index 0000000..61060f2
--- /dev/null
+++ b/Libs/Newtonsoft.Json/StringEscapeHandling.cs
@@ -0,0 +1,48 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies how strings are escaped when writing JSON text.
+    /// </summary>
+    public enum StringEscapeHandling
+    {
+        /// <summary>
+        /// Only control characters (e.g. newline) are escaped.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// All non-ASCII and control characters (e.g. newline) are escaped.
+        /// </summary>
+        EscapeNonAscii = 1,
+
+        /// <summary>
+        /// HTML (&lt;, &gt;, &amp;, &apos;, &quot;) and control characters (e.g. newline) are escaped.
+        /// </summary>
+        EscapeHtml = 2
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/TraceLevel.cs b/Libs/Newtonsoft.Json/TraceLevel.cs
new file mode 100644
index 0000000..e62e8f8
--- /dev/null
+++ b/Libs/Newtonsoft.Json/TraceLevel.cs
@@ -0,0 +1,39 @@
+
+#if !HAVE_TRACE_WRITER
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies what messages to output for the <see cref="ITraceWriter"/> class.
+    /// </summary>
+    public enum TraceLevel
+    {
+        /// <summary>
+        /// Output no tracing and debugging messages.
+        /// </summary>
+        Off = 0,
+
+        /// <summary>
+        /// Output error-handling messages.
+        /// </summary>
+        Error = 1,
+
+        /// <summary>
+        /// Output warnings and error-handling messages.
+        /// </summary>
+        Warning = 2,
+
+        /// <summary>
+        /// Output informational messages, warnings, and error-handling messages.
+        /// </summary>
+        Info = 3,
+
+        /// <summary>
+        /// Output all debugging and tracing messages.
+        /// </summary>
+        Verbose = 4
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/TypeNameAssemblyFormatHandling.cs b/Libs/Newtonsoft.Json/TypeNameAssemblyFormatHandling.cs
new file mode 100644
index 0000000..6d9ac60
--- /dev/null
+++ b/Libs/Newtonsoft.Json/TypeNameAssemblyFormatHandling.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Indicates the method that will be used during deserialization for locating and loading assemblies.
+    /// </summary>
+    public enum TypeNameAssemblyFormatHandling
+    {
+        /// <summary>
+        /// In simple mode, the assembly used during deserialization need not match exactly the assembly used during serialization. Specifically, the version numbers need not match as the <c>LoadWithPartialName</c> method of the <see cref="System.Reflection.Assembly"/> class is used to load the assembly.
+        /// </summary>
+        Simple = 0,
+
+        /// <summary>
+        /// In full mode, the assembly used during deserialization must match exactly the assembly used during serialization. The <c>Load</c> method of the <see cref="System.Reflection.Assembly"/> class is used to load the assembly.
+        /// </summary>
+        Full = 1
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/TypeNameHandling.cs b/Libs/Newtonsoft.Json/TypeNameHandling.cs
new file mode 100644
index 0000000..69a021e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/TypeNameHandling.cs
@@ -0,0 +1,70 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Runtime.Serialization;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies type name handling options for the <see cref="JsonSerializer"/>.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="JsonSerializer.TypeNameHandling"/> should be used with caution when your application deserializes JSON from an external source.
+    /// Incoming types should be validated with a custom <see cref="JsonSerializer.SerializationBinder"/>
+    /// when deserializing with a value other than <see cref="TypeNameHandling.None"/>.
+    /// </remarks>
+    [Flags]
+    public enum TypeNameHandling
+    {
+        /// <summary>
+        /// Do not include the .NET type name when serializing types.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Include the .NET type name when serializing into a JSON object structure.
+        /// </summary>
+        Objects = 1,
+
+        /// <summary>
+        /// Include the .NET type name when serializing into a JSON array structure.
+        /// </summary>
+        Arrays = 2,
+
+        /// <summary>
+        /// Always include the .NET type name when serializing.
+        /// </summary>
+        All = Objects | Arrays,
+
+        /// <summary>
+        /// Include the .NET type name when the type of the object being serialized is not the same as its declared type.
+        /// Note that this doesn't include the root serialized object by default. To include the root object's type name in JSON
+        /// you must specify a root type object with <see cref="JsonConvert.SerializeObject(object, Type, JsonSerializerSettings)"/>
+        /// or <see cref="JsonSerializer.Serialize(JsonWriter, object, Type)"/>.
+        /// </summary>
+        Auto = 4
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/AsyncUtils.cs b/Libs/Newtonsoft.Json/Utilities/AsyncUtils.cs
new file mode 100644
index 0000000..dc4a5eb
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/AsyncUtils.cs
@@ -0,0 +1,110 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_ASYNC
+
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class AsyncUtils
+    {
+        // Pre-allocate to avoid wasted allocations.
+        public static readonly Task<bool> False = Task.FromResult(false);
+        public static readonly Task<bool> True = Task.FromResult(true);
+
+        internal static Task<bool> ToAsync(this bool value) => value ? True : False;
+
+        public static Task? CancelIfRequestedAsync(this CancellationToken cancellationToken)
+        {
+            return cancellationToken.IsCancellationRequested ? FromCanceled(cancellationToken) : null;
+        }
+
+        public static Task<T>? CancelIfRequestedAsync<T>(this CancellationToken cancellationToken)
+        {
+            return cancellationToken.IsCancellationRequested ? FromCanceled<T>(cancellationToken) : null;
+        }
+
+        // From 4.6 on we could use Task.FromCanceled(), but we need an equivalent for
+        // previous frameworks.
+        public static Task FromCanceled(this CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(cancellationToken.IsCancellationRequested);
+            return new Task(() => {}, cancellationToken);
+        }
+
+        public static Task<T> FromCanceled<T>(this CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(cancellationToken.IsCancellationRequested);
+#pragma warning disable CS8603 // Possible null reference return.
+            return new Task<T>(() => default, cancellationToken);
+#pragma warning restore CS8603 // Possible null reference return.
+        }
+
+        // Task.Delay(0) is optimised as a cached task within the framework, and indeed
+        // the same cached task that Task.CompletedTask returns as of 4.6, but we'll add
+        // our own cached field for previous frameworks.
+        internal static readonly Task CompletedTask = Task.Delay(0);
+
+        public static Task WriteAsync(this TextWriter writer, char value, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(writer != null);
+            return cancellationToken.IsCancellationRequested ? FromCanceled(cancellationToken) : writer.WriteAsync(value);
+        }
+
+        public static Task WriteAsync(this TextWriter writer, string? value, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(writer != null);
+            return cancellationToken.IsCancellationRequested ? FromCanceled(cancellationToken) : writer.WriteAsync(value);
+        }
+
+        public static Task WriteAsync(this TextWriter writer, char[] value, int start, int count, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(writer != null);
+            return cancellationToken.IsCancellationRequested ? FromCanceled(cancellationToken) : writer.WriteAsync(value, start, count);
+        }
+
+        public static Task<int> ReadAsync(this TextReader reader, char[] buffer, int index, int count, CancellationToken cancellationToken)
+        {
+            MiscellaneousUtils.Assert(reader != null);
+            return cancellationToken.IsCancellationRequested ? FromCanceled<int>(cancellationToken) : reader.ReadAsync(buffer, index, count);
+        }
+
+        public static bool IsCompletedSucessfully(this Task task)
+        {
+            // IsCompletedSucessfully is the faster method, but only currently exposed on .NET Core 2.0
+#if NETCOREAPP2_0
+            return task.IsCompletedSucessfully;
+#else
+            return task.Status == TaskStatus.RanToCompletion;
+#endif
+        }
+    }
+}
+
+#endif
diff --git a/Libs/Newtonsoft.Json/Utilities/Base64Encoder.cs b/Libs/Newtonsoft.Json/Utilities/Base64Encoder.cs
new file mode 100644
index 0000000..4d9130f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/Base64Encoder.cs
@@ -0,0 +1,217 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.IO;
+#if HAVE_ASYNC
+using System.Threading;
+using System.Threading.Tasks;
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class Base64Encoder
+    {
+        private const int Base64LineSize = 76;
+        private const int LineSizeInBytes = 57;
+
+        private readonly char[] _charsLine = new char[Base64LineSize];
+        private readonly TextWriter _writer;
+
+        private byte[]? _leftOverBytes;
+        private int _leftOverBytesCount;
+
+        public Base64Encoder(TextWriter writer)
+        {
+            ValidationUtils.ArgumentNotNull(writer, nameof(writer));
+            _writer = writer;
+        }
+
+        private void ValidateEncode(byte[] buffer, int index, int count)
+        {
+            if (buffer == null)
+            {
+                throw new ArgumentNullException(nameof(buffer));
+            }
+
+            if (index < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+
+            if (count < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(count));
+            }
+
+            if (count > (buffer.Length - index))
+            {
+                throw new ArgumentOutOfRangeException(nameof(count));
+            }
+        }
+
+        public void Encode(byte[] buffer, int index, int count)
+        {
+            ValidateEncode(buffer, index, count);
+
+            if (_leftOverBytesCount > 0)
+            {
+                if(FulfillFromLeftover(buffer, index, ref count))
+                {
+                    return;
+                }
+
+                int num2 = Convert.ToBase64CharArray(_leftOverBytes, 0, 3, _charsLine, 0);
+                WriteChars(_charsLine, 0, num2);
+            }
+
+            StoreLeftOverBytes(buffer, index, ref count);
+
+            int num4 = index + count;
+            int length = LineSizeInBytes;
+            while (index < num4)
+            {
+                if ((index + length) > num4)
+                {
+                    length = num4 - index;
+                }
+                int num6 = Convert.ToBase64CharArray(buffer, index, length, _charsLine, 0);
+                WriteChars(_charsLine, 0, num6);
+                index += length;
+            }
+        }
+
+        private void StoreLeftOverBytes(byte[] buffer, int index, ref int count)
+        {
+            int leftOverBytesCount = count % 3;
+            if (leftOverBytesCount > 0)
+            {
+                count -= leftOverBytesCount;
+                if (_leftOverBytes == null)
+                {
+                    _leftOverBytes = new byte[3];
+                }
+
+                for (int i = 0; i < leftOverBytesCount; i++)
+                {
+                    _leftOverBytes[i] = buffer[index + count + i];
+                }
+            }
+
+            _leftOverBytesCount = leftOverBytesCount;
+        }
+
+        private bool FulfillFromLeftover(byte[] buffer, int index, ref int count)
+        {
+            int leftOverBytesCount = _leftOverBytesCount;
+            while (leftOverBytesCount < 3 && count > 0)
+            {
+                _leftOverBytes![leftOverBytesCount++] = buffer[index++];
+                count--;
+            }
+
+            if (count == 0 && leftOverBytesCount < 3)
+            {
+                _leftOverBytesCount = leftOverBytesCount;
+                return true;
+            }
+
+            return false;
+        }
+
+        public void Flush()
+        {
+            if (_leftOverBytesCount > 0)
+            {
+                int count = Convert.ToBase64CharArray(_leftOverBytes, 0, _leftOverBytesCount, _charsLine, 0);
+                WriteChars(_charsLine, 0, count);
+                _leftOverBytesCount = 0;
+            }
+        }
+
+        private void WriteChars(char[] chars, int index, int count)
+        {
+            _writer.Write(chars, index, count);
+        }
+
+#if HAVE_ASYNC
+
+        public async Task EncodeAsync(byte[] buffer, int index, int count, CancellationToken cancellationToken)
+        {
+            ValidateEncode(buffer, index, count);
+
+            if (_leftOverBytesCount > 0)
+            {
+                if (FulfillFromLeftover(buffer, index, ref count))
+                {
+                    return;
+                }
+
+                int num2 = Convert.ToBase64CharArray(_leftOverBytes, 0, 3, _charsLine, 0);
+                await WriteCharsAsync(_charsLine, 0, num2, cancellationToken).ConfigureAwait(false);
+            }
+
+            StoreLeftOverBytes(buffer, index, ref count);
+
+            int num4 = index + count;
+            int length = LineSizeInBytes;
+            while (index < num4)
+            {
+                if (index + length > num4)
+                {
+                    length = num4 - index;
+                }
+                int num6 = Convert.ToBase64CharArray(buffer, index, length, _charsLine, 0);
+                await WriteCharsAsync(_charsLine, 0, num6, cancellationToken).ConfigureAwait(false);
+                index += length;
+            }
+        }
+
+        private Task WriteCharsAsync(char[] chars, int index, int count, CancellationToken cancellationToken)
+        {
+            return _writer.WriteAsync(chars, index, count, cancellationToken);
+        }
+
+        public Task FlushAsync(CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            if (_leftOverBytesCount > 0)
+            {
+                int count = Convert.ToBase64CharArray(_leftOverBytes, 0, _leftOverBytesCount, _charsLine, 0);
+                _leftOverBytesCount = 0;
+                return WriteCharsAsync(_charsLine, 0, count, cancellationToken);
+            }
+
+            return AsyncUtils.CompletedTask;
+        }
+
+#endif
+
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/BidirectionalDictionary.cs b/Libs/Newtonsoft.Json/Utilities/BidirectionalDictionary.cs
new file mode 100644
index 0000000..1e8bf88
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/BidirectionalDictionary.cs
@@ -0,0 +1,94 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class BidirectionalDictionary<TFirst, TSecond>
+    {
+        private readonly IDictionary<TFirst, TSecond> _firstToSecond;
+        private readonly IDictionary<TSecond, TFirst> _secondToFirst;
+        private readonly string _duplicateFirstErrorMessage;
+        private readonly string _duplicateSecondErrorMessage;
+
+        public BidirectionalDictionary()
+            : this(EqualityComparer<TFirst>.Default, EqualityComparer<TSecond>.Default)
+        {
+        }
+
+        public BidirectionalDictionary(IEqualityComparer<TFirst> firstEqualityComparer, IEqualityComparer<TSecond> secondEqualityComparer)
+            : this(
+                firstEqualityComparer,
+                secondEqualityComparer,
+                "Duplicate item already exists for '{0}'.",
+                "Duplicate item already exists for '{0}'.")
+        {
+        }
+
+        public BidirectionalDictionary(IEqualityComparer<TFirst> firstEqualityComparer, IEqualityComparer<TSecond> secondEqualityComparer,
+            string duplicateFirstErrorMessage, string duplicateSecondErrorMessage)
+        {
+            _firstToSecond = new Dictionary<TFirst, TSecond>(firstEqualityComparer);
+            _secondToFirst = new Dictionary<TSecond, TFirst>(secondEqualityComparer);
+            _duplicateFirstErrorMessage = duplicateFirstErrorMessage;
+            _duplicateSecondErrorMessage = duplicateSecondErrorMessage;
+        }
+
+        public void Set(TFirst first, TSecond second)
+        {
+            if (_firstToSecond.TryGetValue(first, out TSecond existingSecond))
+            {
+                if (!existingSecond!.Equals(second))
+                {
+                    throw new ArgumentException(_duplicateFirstErrorMessage.FormatWith(CultureInfo.InvariantCulture, first));
+                }
+            }
+
+            if (_secondToFirst.TryGetValue(second, out TFirst existingFirst))
+            {
+                if (!existingFirst!.Equals(first))
+                {
+                    throw new ArgumentException(_duplicateSecondErrorMessage.FormatWith(CultureInfo.InvariantCulture, second));
+                }
+            }
+
+            _firstToSecond.Add(first, second);
+            _secondToFirst.Add(second, first);
+        }
+
+        public bool TryGetByFirst(TFirst first, out TSecond second)
+        {
+            return _firstToSecond.TryGetValue(first, out second);
+        }
+
+        public bool TryGetBySecond(TSecond second, out TFirst first)
+        {
+            return _secondToFirst.TryGetValue(second, out first);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/CollectionUtils.cs b/Libs/Newtonsoft.Json/Utilities/CollectionUtils.cs
new file mode 100644
index 0000000..d8fd400
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/CollectionUtils.cs
@@ -0,0 +1,382 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using System.Text;
+using System.Collections;
+using System.Diagnostics;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Globalization;
+#if HAVE_METHOD_IMPL_ATTRIBUTE
+using System.Runtime.CompilerServices;
+#endif
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class CollectionUtils
+    {
+        /// <summary>
+        /// Determines whether the collection is <c>null</c> or empty.
+        /// </summary>
+        /// <param name="collection">The collection.</param>
+        /// <returns>
+        /// 	<c>true</c> if the collection is <c>null</c> or empty; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsNullOrEmpty<T>(ICollection<T> collection)
+        {
+            if (collection != null)
+            {
+                return (collection.Count == 0);
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Adds the elements of the specified collection to the specified generic <see cref="IList{T}"/>.
+        /// </summary>
+        /// <param name="initial">The list to add to.</param>
+        /// <param name="collection">The collection of elements to add.</param>
+        public static void AddRange<T>(this IList<T> initial, IEnumerable<T> collection)
+        {
+            if (initial == null)
+            {
+                throw new ArgumentNullException(nameof(initial));
+            }
+
+            if (collection == null)
+            {
+                return;
+            }
+
+            foreach (T value in collection)
+            {
+                initial.Add(value);
+            }
+        }
+
+#if !HAVE_COVARIANT_GENERICS
+        public static void AddRange<T>(this IList<T> initial, IEnumerable collection)
+        {
+            ValidationUtils.ArgumentNotNull(initial, nameof(initial));
+
+            // because earlier versions of .NET didn't support covariant generics
+            initial.AddRange(collection.Cast<T>());
+        }
+#endif
+
+        public static bool IsDictionaryType(Type type)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+
+            if (typeof(IDictionary).IsAssignableFrom(type))
+            {
+                return true;
+            }
+            if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IDictionary<,>)))
+            {
+                return true;
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IReadOnlyDictionary<,>)))
+            {
+                return true;
+            }
+#endif
+
+            return false;
+        }
+
+        public static ConstructorInfo? ResolveEnumerableCollectionConstructor(Type collectionType, Type collectionItemType)
+        {
+            Type genericConstructorArgument = typeof(IList<>).MakeGenericType(collectionItemType);
+
+            return ResolveEnumerableCollectionConstructor(collectionType, collectionItemType, genericConstructorArgument);
+        }
+
+        public static ConstructorInfo? ResolveEnumerableCollectionConstructor(Type collectionType, Type collectionItemType, Type constructorArgumentType)
+        {
+            Type genericEnumerable = typeof(IEnumerable<>).MakeGenericType(collectionItemType);
+            ConstructorInfo? match = null;
+
+            foreach (ConstructorInfo constructor in collectionType.GetConstructors(BindingFlags.Public | BindingFlags.Instance))
+            {
+                IList<ParameterInfo> parameters = constructor.GetParameters();
+
+                if (parameters.Count == 1)
+                {
+                    Type parameterType = parameters[0].ParameterType;
+
+                    if (genericEnumerable == parameterType)
+                    {
+                        // exact match
+                        match = constructor;
+                        break;
+                    }
+
+                    // in case we can't find an exact match, use first inexact
+                    if (match == null)
+                    {
+                        if (parameterType.IsAssignableFrom(constructorArgumentType))
+                        {
+                            match = constructor;
+                        }
+                    }
+                }
+            }
+
+            return match;
+        }
+
+        public static bool AddDistinct<T>(this IList<T> list, T value)
+        {
+            return list.AddDistinct(value, EqualityComparer<T>.Default);
+        }
+
+        public static bool AddDistinct<T>(this IList<T> list, T value, IEqualityComparer<T> comparer)
+        {
+            if (list.ContainsValue(value, comparer))
+            {
+                return false;
+            }
+
+            list.Add(value);
+            return true;
+        }
+
+        // this is here because LINQ Bridge doesn't support Contains with IEqualityComparer<T>
+        public static bool ContainsValue<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
+        {
+            if (comparer == null)
+            {
+                comparer = EqualityComparer<TSource>.Default;
+            }
+
+            if (source == null)
+            {
+                throw new ArgumentNullException(nameof(source));
+            }
+
+            foreach (TSource local in source)
+            {
+                if (comparer.Equals(local, value))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static bool AddRangeDistinct<T>(this IList<T> list, IEnumerable<T> values, IEqualityComparer<T> comparer)
+        {
+            bool allAdded = true;
+            foreach (T value in values)
+            {
+                if (!list.AddDistinct(value, comparer))
+                {
+                    allAdded = false;
+                }
+            }
+
+            return allAdded;
+        }
+
+        public static int IndexOf<T>(this IEnumerable<T> collection, Func<T, bool> predicate)
+        {
+            int index = 0;
+            foreach (T value in collection)
+            {
+                if (predicate(value))
+                {
+                    return index;
+                }
+
+                index++;
+            }
+
+            return -1;
+        }
+
+        public static bool Contains<T>(this List<T> list, T value, IEqualityComparer comparer)
+        {
+            for (int i = 0; i < list.Count; i++)
+            {
+                if (comparer.Equals(value, list[i]))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public static int IndexOfReference<T>(this List<T> list, T item)
+        {
+            for (int i = 0; i < list.Count; i++)
+            {
+                if (ReferenceEquals(item, list[i]))
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+#if HAVE_FAST_REVERSE
+        // faster reverse in .NET Framework with value types - https://github.com/JamesNK/Newtonsoft.Json/issues/1430
+        public static void FastReverse<T>(this List<T> list)
+        {
+            int i = 0;
+            int j = list.Count - 1;
+            while (i < j)
+            {
+                T temp = list[i];
+                list[i] = list[j];
+                list[j] = temp;
+                i++;
+                j--;
+            }
+        }
+#endif
+
+        private static IList<int> GetDimensions(IList values, int dimensionsCount)
+        {
+            IList<int> dimensions = new List<int>();
+
+            IList currentArray = values;
+            while (true)
+            {
+                dimensions.Add(currentArray.Count);
+
+                // don't keep calculating dimensions for arrays inside the value array
+                if (dimensions.Count == dimensionsCount)
+                {
+                    break;
+                }
+
+                if (currentArray.Count == 0)
+                {
+                    break;
+                }
+
+                object v = currentArray[0];
+                if (v is IList list)
+                {
+                    currentArray = list;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            return dimensions;
+        }
+
+        private static void CopyFromJaggedToMultidimensionalArray(IList values, Array multidimensionalArray, int[] indices)
+        {
+            int dimension = indices.Length;
+            if (dimension == multidimensionalArray.Rank)
+            {
+                multidimensionalArray.SetValue(JaggedArrayGetValue(values, indices), indices);
+                return;
+            }
+
+            int dimensionLength = multidimensionalArray.GetLength(dimension);
+            IList list = (IList)JaggedArrayGetValue(values, indices);
+            int currentValuesLength = list.Count;
+            if (currentValuesLength != dimensionLength)
+            {
+                throw new Exception("Cannot deserialize non-cubical array as multidimensional array.");
+            }
+
+            int[] newIndices = new int[dimension + 1];
+            for (int i = 0; i < dimension; i++)
+            {
+                newIndices[i] = indices[i];
+            }
+
+            for (int i = 0; i < multidimensionalArray.GetLength(dimension); i++)
+            {
+                newIndices[dimension] = i;
+                CopyFromJaggedToMultidimensionalArray(values, multidimensionalArray, newIndices);
+            }
+        }
+
+        private static object JaggedArrayGetValue(IList values, int[] indices)
+        {
+            IList currentList = values;
+            for (int i = 0; i < indices.Length; i++)
+            {
+                int index = indices[i];
+                if (i == indices.Length - 1)
+                {
+                    return currentList[index];
+                }
+                else
+                {
+                    currentList = (IList)currentList[index];
+                }
+            }
+            return currentList;
+        }
+
+        public static Array ToMultidimensionalArray(IList values, Type type, int rank)
+        {
+            IList<int> dimensions = GetDimensions(values, rank);
+
+            while (dimensions.Count < rank)
+            {
+                dimensions.Add(0);
+            }
+
+            Array multidimensionalArray = Array.CreateInstance(type, dimensions.ToArray());
+            CopyFromJaggedToMultidimensionalArray(values, multidimensionalArray, ArrayEmpty<int>());
+
+            return multidimensionalArray;
+        }
+
+        public static T[] ArrayEmpty<T>()
+        {
+            // Enumerable.Empty<T> no longer returns an empty array in .NET Core 3.0
+            return EmptyArrayContainer<T>.Empty;
+        }
+
+        private static class EmptyArrayContainer<T>
+        {
+#pragma warning disable CA1825 // Avoid zero-length array allocations.
+            public static readonly T[] Empty = new T[0];
+#pragma warning restore CA1825 // Avoid zero-length array allocations.
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/CollectionWrapper.cs b/Libs/Newtonsoft.Json/Utilities/CollectionWrapper.cs
new file mode 100644
index 0000000..d16b1b7
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/CollectionWrapper.cs
@@ -0,0 +1,320 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using System.Globalization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal interface IWrappedCollection : IList
+    {
+        object UnderlyingCollection { get; }
+    }
+
+    internal class CollectionWrapper<T> : ICollection<T>, IWrappedCollection
+    {
+        private readonly IList? _list;
+        private readonly ICollection<T>? _genericCollection;
+        private object? _syncRoot;
+
+        public CollectionWrapper(IList list)
+        {
+            ValidationUtils.ArgumentNotNull(list, nameof(list));
+
+            if (list is ICollection<T> collection)
+            {
+                _genericCollection = collection;
+            }
+            else
+            {
+                _list = list;
+            }
+        }
+
+        public CollectionWrapper(ICollection<T> list)
+        {
+            ValidationUtils.ArgumentNotNull(list, nameof(list));
+
+            _genericCollection = list;
+        }
+
+        public virtual void Add(T item)
+        {
+            if (_genericCollection != null)
+            {
+                _genericCollection.Add(item);
+            }
+            else
+            {
+                _list!.Add(item);
+            }
+        }
+
+        public virtual void Clear()
+        {
+            if (_genericCollection != null)
+            {
+                _genericCollection.Clear();
+            }
+            else
+            {
+                _list!.Clear();
+            }
+        }
+
+        public virtual bool Contains(T item)
+        {
+            if (_genericCollection != null)
+            {
+                return _genericCollection.Contains(item);
+            }
+            else
+            {
+                return _list!.Contains(item);
+            }
+        }
+
+        public virtual void CopyTo(T[] array, int arrayIndex)
+        {
+            if (_genericCollection != null)
+            {
+                _genericCollection.CopyTo(array, arrayIndex);
+            }
+            else
+            {
+                _list!.CopyTo(array, arrayIndex);
+            }
+        }
+
+        public virtual int Count
+        {
+            get
+            {
+                if (_genericCollection != null)
+                {
+                    return _genericCollection.Count;
+                }
+                else
+                {
+                    return _list!.Count;
+                }
+            }
+        }
+
+        public virtual bool IsReadOnly
+        {
+            get
+            {
+                if (_genericCollection != null)
+                {
+                    return _genericCollection.IsReadOnly;
+                }
+                else
+                {
+                    return _list!.IsReadOnly;
+                }
+            }
+        }
+
+        public virtual bool Remove(T item)
+        {
+            if (_genericCollection != null)
+            {
+                return _genericCollection.Remove(item);
+            }
+            else
+            {
+                bool contains = _list!.Contains(item);
+
+                if (contains)
+                {
+                    _list!.Remove(item);
+                }
+
+                return contains;
+            }
+        }
+
+        public virtual IEnumerator<T> GetEnumerator()
+        {
+            return (_genericCollection ?? _list.Cast<T>()).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable)_genericCollection! ?? _list!).GetEnumerator();
+        }
+
+        int IList.Add(object value)
+        {
+            VerifyValueType(value);
+            Add((T)value);
+
+            return (Count - 1);
+        }
+
+        bool IList.Contains(object value)
+        {
+            if (IsCompatibleObject(value))
+            {
+                return Contains((T)value);
+            }
+
+            return false;
+        }
+
+        int IList.IndexOf(object value)
+        {
+            if (_genericCollection != null)
+            {
+                throw new InvalidOperationException("Wrapped ICollection<T> does not support IndexOf.");
+            }
+
+            if (IsCompatibleObject(value))
+            {
+                return _list!.IndexOf((T)value);
+            }
+
+            return -1;
+        }
+
+        void IList.RemoveAt(int index)
+        {
+            if (_genericCollection != null)
+            {
+                throw new InvalidOperationException("Wrapped ICollection<T> does not support RemoveAt.");
+            }
+
+            _list!.RemoveAt(index);
+        }
+
+        void IList.Insert(int index, object value)
+        {
+            if (_genericCollection != null)
+            {
+                throw new InvalidOperationException("Wrapped ICollection<T> does not support Insert.");
+            }
+
+            VerifyValueType(value);
+            _list!.Insert(index, (T)value);
+        }
+
+        bool IList.IsFixedSize
+        {
+            get
+            {
+                if (_genericCollection != null)
+                {
+                    // ICollection<T> only has IsReadOnly
+                    return _genericCollection.IsReadOnly;
+                }
+                else
+                {
+                    return _list!.IsFixedSize;
+                }
+            }
+        }
+
+        void IList.Remove(object value)
+        {
+            if (IsCompatibleObject(value))
+            {
+                Remove((T)value);
+            }
+        }
+
+        object IList.this[int index]
+        {
+            get
+            {
+                if (_genericCollection != null)
+                {
+                    throw new InvalidOperationException("Wrapped ICollection<T> does not support indexer.");
+                }
+
+                return _list![index];
+            }
+            set
+            {
+                if (_genericCollection != null)
+                {
+                    throw new InvalidOperationException("Wrapped ICollection<T> does not support indexer.");
+                }
+
+                VerifyValueType(value);
+                _list![index] = (T)value;
+            }
+        }
+
+        void ICollection.CopyTo(Array array, int arrayIndex)
+        {
+            CopyTo((T[])array, arrayIndex);
+        }
+
+        bool ICollection.IsSynchronized => false;
+
+        object ICollection.SyncRoot
+        {
+            get
+            {
+                if (_syncRoot == null)
+                {
+                    Interlocked.CompareExchange(ref _syncRoot, new object(), null);
+                }
+
+                return _syncRoot;
+            }
+        }
+
+        private static void VerifyValueType(object value)
+        {
+            if (!IsCompatibleObject(value))
+            {
+                throw new ArgumentException("The value '{0}' is not of type '{1}' and cannot be used in this generic collection.".FormatWith(CultureInfo.InvariantCulture, value, typeof(T)), nameof(value));
+            }
+        }
+
+        private static bool IsCompatibleObject(object value)
+        {
+            if (!(value is T) && (value != null || (typeof(T).IsValueType() && !ReflectionUtils.IsNullableType(typeof(T)))))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        public object UnderlyingCollection => (object)_genericCollection! ?? _list!;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ConvertUtils.cs b/Libs/Newtonsoft.Json/Utilities/ConvertUtils.cs
new file mode 100644
index 0000000..3356735
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ConvertUtils.cs
@@ -0,0 +1,1577 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+#if !HAVE_GUID_TRY_PARSE
+using System.Text;
+using System.Text.RegularExpressions;
+#endif
+using LC.Newtonsoft.Json.Serialization;
+using System.Reflection;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+#if HAVE_ADO_NET
+using System.Data.SqlTypes;
+
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal enum PrimitiveTypeCode
+    {
+        Empty = 0,
+        Object = 1,
+        Char = 2,
+        CharNullable = 3,
+        Boolean = 4,
+        BooleanNullable = 5,
+        SByte = 6,
+        SByteNullable = 7,
+        Int16 = 8,
+        Int16Nullable = 9,
+        UInt16 = 10,
+        UInt16Nullable = 11,
+        Int32 = 12,
+        Int32Nullable = 13,
+        Byte = 14,
+        ByteNullable = 15,
+        UInt32 = 16,
+        UInt32Nullable = 17,
+        Int64 = 18,
+        Int64Nullable = 19,
+        UInt64 = 20,
+        UInt64Nullable = 21,
+        Single = 22,
+        SingleNullable = 23,
+        Double = 24,
+        DoubleNullable = 25,
+        DateTime = 26,
+        DateTimeNullable = 27,
+        DateTimeOffset = 28,
+        DateTimeOffsetNullable = 29,
+        Decimal = 30,
+        DecimalNullable = 31,
+        Guid = 32,
+        GuidNullable = 33,
+        TimeSpan = 34,
+        TimeSpanNullable = 35,
+        BigInteger = 36,
+        BigIntegerNullable = 37,
+        Uri = 38,
+        String = 39,
+        Bytes = 40,
+        DBNull = 41
+    }
+
+    internal class TypeInformation
+    {
+        public Type Type { get; }
+        public PrimitiveTypeCode TypeCode { get; }
+
+        public TypeInformation(Type type, PrimitiveTypeCode typeCode)
+        {
+            Type = type;
+            TypeCode = typeCode;
+        }
+    }
+
+    internal enum ParseResult
+    {
+        None = 0,
+        Success = 1,
+        Overflow = 2,
+        Invalid = 3
+    }
+
+    internal static class ConvertUtils
+    {
+        private static readonly Dictionary<Type, PrimitiveTypeCode> TypeCodeMap =
+            new Dictionary<Type, PrimitiveTypeCode>
+            {
+                { typeof(char), PrimitiveTypeCode.Char },
+                { typeof(char?), PrimitiveTypeCode.CharNullable },
+                { typeof(bool), PrimitiveTypeCode.Boolean },
+                { typeof(bool?), PrimitiveTypeCode.BooleanNullable },
+                { typeof(sbyte), PrimitiveTypeCode.SByte },
+                { typeof(sbyte?), PrimitiveTypeCode.SByteNullable },
+                { typeof(short), PrimitiveTypeCode.Int16 },
+                { typeof(short?), PrimitiveTypeCode.Int16Nullable },
+                { typeof(ushort), PrimitiveTypeCode.UInt16 },
+                { typeof(ushort?), PrimitiveTypeCode.UInt16Nullable },
+                { typeof(int), PrimitiveTypeCode.Int32 },
+                { typeof(int?), PrimitiveTypeCode.Int32Nullable },
+                { typeof(byte), PrimitiveTypeCode.Byte },
+                { typeof(byte?), PrimitiveTypeCode.ByteNullable },
+                { typeof(uint), PrimitiveTypeCode.UInt32 },
+                { typeof(uint?), PrimitiveTypeCode.UInt32Nullable },
+                { typeof(long), PrimitiveTypeCode.Int64 },
+                { typeof(long?), PrimitiveTypeCode.Int64Nullable },
+                { typeof(ulong), PrimitiveTypeCode.UInt64 },
+                { typeof(ulong?), PrimitiveTypeCode.UInt64Nullable },
+                { typeof(float), PrimitiveTypeCode.Single },
+                { typeof(float?), PrimitiveTypeCode.SingleNullable },
+                { typeof(double), PrimitiveTypeCode.Double },
+                { typeof(double?), PrimitiveTypeCode.DoubleNullable },
+                { typeof(DateTime), PrimitiveTypeCode.DateTime },
+                { typeof(DateTime?), PrimitiveTypeCode.DateTimeNullable },
+#if HAVE_DATE_TIME_OFFSET
+                { typeof(DateTimeOffset), PrimitiveTypeCode.DateTimeOffset },
+                { typeof(DateTimeOffset?), PrimitiveTypeCode.DateTimeOffsetNullable },
+#endif
+                { typeof(decimal), PrimitiveTypeCode.Decimal },
+                { typeof(decimal?), PrimitiveTypeCode.DecimalNullable },
+                { typeof(Guid), PrimitiveTypeCode.Guid },
+                { typeof(Guid?), PrimitiveTypeCode.GuidNullable },
+                { typeof(TimeSpan), PrimitiveTypeCode.TimeSpan },
+                { typeof(TimeSpan?), PrimitiveTypeCode.TimeSpanNullable },
+#if HAVE_BIG_INTEGER
+                { typeof(BigInteger), PrimitiveTypeCode.BigInteger },
+                { typeof(BigInteger?), PrimitiveTypeCode.BigIntegerNullable },
+#endif
+                { typeof(Uri), PrimitiveTypeCode.Uri },
+                { typeof(string), PrimitiveTypeCode.String },
+                { typeof(byte[]), PrimitiveTypeCode.Bytes },
+#if HAVE_ADO_NET
+                { typeof(DBNull), PrimitiveTypeCode.DBNull }
+#endif
+            };
+
+#if HAVE_ICONVERTIBLE
+        private static readonly TypeInformation[] PrimitiveTypeCodes =
+        {
+            // need all of these. lookup against the index with TypeCode value
+            new TypeInformation(typeof(object), PrimitiveTypeCode.Empty), 
+            new TypeInformation(typeof(object), PrimitiveTypeCode.Object), 
+            new TypeInformation(typeof(object), PrimitiveTypeCode.DBNull), 
+            new TypeInformation(typeof(bool), PrimitiveTypeCode.Boolean), 
+            new TypeInformation(typeof(char), PrimitiveTypeCode.Char), 
+            new TypeInformation(typeof(sbyte), PrimitiveTypeCode.SByte), 
+            new TypeInformation(typeof(byte), PrimitiveTypeCode.Byte), 
+            new TypeInformation(typeof(short), PrimitiveTypeCode.Int16), 
+            new TypeInformation(typeof(ushort), PrimitiveTypeCode.UInt16), 
+            new TypeInformation(typeof(int), PrimitiveTypeCode.Int32), 
+            new TypeInformation(typeof(uint), PrimitiveTypeCode.UInt32), 
+            new TypeInformation(typeof(long), PrimitiveTypeCode.Int64), 
+            new TypeInformation(typeof(ulong), PrimitiveTypeCode.UInt64), 
+            new TypeInformation(typeof(float), PrimitiveTypeCode.Single), 
+            new TypeInformation(typeof(double), PrimitiveTypeCode.Double), 
+            new TypeInformation(typeof(decimal), PrimitiveTypeCode.Decimal), 
+            new TypeInformation(typeof(DateTime), PrimitiveTypeCode.DateTime), 
+            new TypeInformation(typeof(object), PrimitiveTypeCode.Empty), // no 17 in TypeCode for some reason
+            new TypeInformation(typeof(string), PrimitiveTypeCode.String)
+        };
+#endif
+
+        public static PrimitiveTypeCode GetTypeCode(Type t)
+        {
+            return GetTypeCode(t, out _);
+        }
+
+        public static PrimitiveTypeCode GetTypeCode(Type t, out bool isEnum)
+        {
+            if (TypeCodeMap.TryGetValue(t, out PrimitiveTypeCode typeCode))
+            {
+                isEnum = false;
+                return typeCode;
+            }
+
+            if (t.IsEnum())
+            {
+                isEnum = true;
+                return GetTypeCode(Enum.GetUnderlyingType(t));
+            }
+
+            // performance?
+            if (ReflectionUtils.IsNullableType(t))
+            {
+                Type nonNullable = Nullable.GetUnderlyingType(t);
+                if (nonNullable.IsEnum())
+                {
+                    Type nullableUnderlyingType = typeof(Nullable<>).MakeGenericType(Enum.GetUnderlyingType(nonNullable));
+                    isEnum = true;
+                    return GetTypeCode(nullableUnderlyingType);
+                }
+            }
+
+            isEnum = false;
+            return PrimitiveTypeCode.Object;
+        }
+
+#if HAVE_ICONVERTIBLE
+        public static TypeInformation GetTypeInformation(IConvertible convertable)
+        {
+            TypeInformation typeInformation = PrimitiveTypeCodes[(int)convertable.GetTypeCode()];
+            return typeInformation;
+        }
+#endif
+
+        public static bool IsConvertible(Type t)
+        {
+#if HAVE_ICONVERTIBLE
+            return typeof(IConvertible).IsAssignableFrom(t);
+#else
+            return (
+                t == typeof(bool) || t == typeof(byte) || t == typeof(char) || t == typeof(DateTime) || t == typeof(decimal) || t == typeof(double) || t == typeof(short) || t == typeof(int) ||
+                t == typeof(long) || t == typeof(sbyte) || t == typeof(float) || t == typeof(string) || t == typeof(ushort) || t == typeof(uint) || t == typeof(ulong) || t.IsEnum());
+#endif
+        }
+
+        public static TimeSpan ParseTimeSpan(string input)
+        {
+#if HAVE_TIME_SPAN_PARSE_WITH_CULTURE
+            return TimeSpan.Parse(input, CultureInfo.InvariantCulture);
+#else
+            return TimeSpan.Parse(input);
+#endif
+        }
+
+        private static readonly ThreadSafeStore<StructMultiKey<Type, Type>, Func<object?, object?>?> CastConverters =
+            new ThreadSafeStore<StructMultiKey<Type, Type>, Func<object?, object?>?>(CreateCastConverter);
+
+        private static Func<object?, object?>? CreateCastConverter(StructMultiKey<Type, Type> t)
+        {
+            Type initialType = t.Value1;
+            Type targetType = t.Value2;
+            MethodInfo castMethodInfo = targetType.GetMethod("op_Implicit", new[] { initialType })
+                ?? targetType.GetMethod("op_Explicit", new[] { initialType });
+
+            if (castMethodInfo == null)
+            {
+                return null;
+            }
+
+            MethodCall<object?, object?> call = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object?>(castMethodInfo);
+
+            return o => call(null, o);
+        }
+
+#if HAVE_BIG_INTEGER
+        internal static BigInteger ToBigInteger(object value)
+        {
+            if (value is BigInteger integer)
+            {
+                return integer;
+            }
+
+            if (value is string s)
+            {
+                return BigInteger.Parse(s, CultureInfo.InvariantCulture);
+            }
+
+            if (value is float f)
+            {
+                return new BigInteger(f);
+            }
+            if (value is double d)
+            {
+                return new BigInteger(d);
+            }
+            if (value is decimal @decimal)
+            {
+                return new BigInteger(@decimal);
+            }
+            if (value is int i)
+            {
+                return new BigInteger(i);
+            }
+            if (value is long l)
+            {
+                return new BigInteger(l);
+            }
+            if (value is uint u)
+            {
+                return new BigInteger(u);
+            }
+            if (value is ulong @ulong)
+            {
+                return new BigInteger(@ulong);
+            }
+
+            if (value is byte[] bytes)
+            {
+                return new BigInteger(bytes);
+            }
+
+            throw new InvalidCastException("Cannot convert {0} to BigInteger.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
+        }
+
+        public static object FromBigInteger(BigInteger i, Type targetType)
+        {
+            if (targetType == typeof(decimal))
+            {
+                return (decimal)i;
+            }
+            if (targetType == typeof(double))
+            {
+                return (double)i;
+            }
+            if (targetType == typeof(float))
+            {
+                return (float)i;
+            }
+            if (targetType == typeof(ulong))
+            {
+                return (ulong)i;
+            }
+            if (targetType == typeof(bool))
+            {
+                return i != 0;
+            }
+
+            try
+            {
+                return System.Convert.ChangeType((long)i, targetType, CultureInfo.InvariantCulture);
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException("Can not convert from BigInteger to {0}.".FormatWith(CultureInfo.InvariantCulture, targetType), ex);
+            }
+        }
+#endif
+
+#region TryConvert
+        internal enum ConvertResult
+        {
+            Success = 0,
+            CannotConvertNull = 1,
+            NotInstantiableType = 2,
+            NoValidConversion = 3
+        }
+
+        public static object Convert(object initialValue, CultureInfo culture, Type targetType)
+        {
+            switch (TryConvertInternal(initialValue, culture, targetType, out object? value))
+            {
+                case ConvertResult.Success:
+                    return value!;
+                case ConvertResult.CannotConvertNull:
+                    throw new Exception("Can not convert null {0} into non-nullable {1}.".FormatWith(CultureInfo.InvariantCulture, initialValue.GetType(), targetType));
+                case ConvertResult.NotInstantiableType:
+                    throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.InvariantCulture, targetType), nameof(targetType));
+                case ConvertResult.NoValidConversion:
+                    throw new InvalidOperationException("Can not convert from {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, initialValue.GetType(), targetType));
+                default:
+                    throw new InvalidOperationException("Unexpected conversion result.");
+            }
+        }
+
+        private static bool TryConvert(object? initialValue, CultureInfo culture, Type targetType, out object? value)
+        {
+            try
+            {
+                if (TryConvertInternal(initialValue, culture, targetType, out value) == ConvertResult.Success)
+                {
+                    return true;
+                }
+
+                value = null;
+                return false;
+            }
+            catch
+            {
+                value = null;
+                return false;
+            }
+        }
+
+        private static ConvertResult TryConvertInternal(object? initialValue, CultureInfo culture, Type targetType, out object? value)
+        {
+            if (initialValue == null)
+            {
+                throw new ArgumentNullException(nameof(initialValue));
+            }
+
+            if (ReflectionUtils.IsNullableType(targetType))
+            {
+                targetType = Nullable.GetUnderlyingType(targetType);
+            }
+
+            Type initialType = initialValue.GetType();
+
+            if (targetType == initialType)
+            {
+                value = initialValue;
+                return ConvertResult.Success;
+            }
+
+            // use Convert.ChangeType if both types are IConvertible
+            if (IsConvertible(initialValue.GetType()) && IsConvertible(targetType))
+            {
+                if (targetType.IsEnum())
+                {
+                    if (initialValue is string)
+                    {
+                        value = Enum.Parse(targetType, initialValue.ToString(), true);
+                        return ConvertResult.Success;
+                    }
+                    else if (IsInteger(initialValue))
+                    {
+                        value = Enum.ToObject(targetType, initialValue);
+                        return ConvertResult.Success;
+                    }
+                }
+
+                value = System.Convert.ChangeType(initialValue, targetType, culture);
+                return ConvertResult.Success;
+            }
+
+#if HAVE_DATE_TIME_OFFSET
+            if (initialValue is DateTime dt && targetType == typeof(DateTimeOffset))
+            {
+                value = new DateTimeOffset(dt);
+                return ConvertResult.Success;
+            }
+#endif
+
+            if (initialValue is byte[] bytes && targetType == typeof(Guid))
+            {
+                value = new Guid(bytes);
+                return ConvertResult.Success;
+            }
+
+            if (initialValue is Guid guid && targetType == typeof(byte[]))
+            {
+                value = guid.ToByteArray();
+                return ConvertResult.Success;
+            }
+
+            if (initialValue is string s)
+            {
+                if (targetType == typeof(Guid))
+                {
+                    value = new Guid(s);
+                    return ConvertResult.Success;
+                }
+                if (targetType == typeof(Uri))
+                {
+                    value = new Uri(s, UriKind.RelativeOrAbsolute);
+                    return ConvertResult.Success;
+                }
+                if (targetType == typeof(TimeSpan))
+                {
+                    value = ParseTimeSpan(s);
+                    return ConvertResult.Success;
+                }
+                if (targetType == typeof(byte[]))
+                {
+                    value = System.Convert.FromBase64String(s);
+                    return ConvertResult.Success;
+                }
+                if (targetType == typeof(Version))
+                {
+                    if (VersionTryParse(s, out Version? result))
+                    {
+                        value = result;
+                        return ConvertResult.Success;
+                    }
+                    value = null;
+                    return ConvertResult.NoValidConversion;
+                }
+                if (typeof(Type).IsAssignableFrom(targetType))
+                {
+                    value = Type.GetType(s, true);
+                    return ConvertResult.Success;
+                }
+            }
+
+#if HAVE_BIG_INTEGER
+            if (targetType == typeof(BigInteger))
+            {
+                value = ToBigInteger(initialValue);
+                return ConvertResult.Success;
+            }
+            if (initialValue is BigInteger integer)
+            {
+                value = FromBigInteger(integer, targetType);
+                return ConvertResult.Success;
+            }
+#endif
+
+#if HAVE_TYPE_DESCRIPTOR
+            // see if source or target types have a TypeConverter that converts between the two
+            TypeConverter toConverter = TypeDescriptor.GetConverter(initialType);
+
+            if (toConverter != null && toConverter.CanConvertTo(targetType))
+            {
+                value = toConverter.ConvertTo(null, culture, initialValue, targetType);
+                return ConvertResult.Success;
+            }
+
+            TypeConverter fromConverter = TypeDescriptor.GetConverter(targetType);
+
+            if (fromConverter != null && fromConverter.CanConvertFrom(initialType))
+            {
+                value = fromConverter.ConvertFrom(null, culture, initialValue);
+                return ConvertResult.Success;
+            }
+#endif
+#if HAVE_ADO_NET
+            // handle DBNull
+            if (initialValue == DBNull.Value)
+            {
+                if (ReflectionUtils.IsNullable(targetType))
+                {
+                    value = EnsureTypeAssignable(null, initialType, targetType);
+                    return ConvertResult.Success;
+                }
+
+                // cannot convert null to non-nullable
+                value = null;
+                return ConvertResult.CannotConvertNull;
+            }
+#endif
+
+            if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract())
+            {
+                value = null;
+                return ConvertResult.NotInstantiableType;
+            }
+
+            value = null;
+            return ConvertResult.NoValidConversion;
+        }
+#endregion
+
+#region ConvertOrCast
+        /// <summary>
+        /// Converts the value to the specified type. If the value is unable to be converted, the
+        /// value is checked whether it assignable to the specified type.
+        /// </summary>
+        /// <param name="initialValue">The value to convert.</param>
+        /// <param name="culture">The culture to use when converting.</param>
+        /// <param name="targetType">The type to convert or cast the value to.</param>
+        /// <returns>
+        /// The converted type. If conversion was unsuccessful, the initial value
+        /// is returned if assignable to the target type.
+        /// </returns>
+        public static object? ConvertOrCast(object? initialValue, CultureInfo culture, Type targetType)
+        {
+            if (targetType == typeof(object))
+            {
+                return initialValue;
+            }
+
+            if (initialValue == null && ReflectionUtils.IsNullable(targetType))
+            {
+                return null;
+            }
+
+            if (TryConvert(initialValue, culture, targetType, out object? convertedValue))
+            {
+                return convertedValue;
+            }
+
+            return EnsureTypeAssignable(initialValue, ReflectionUtils.GetObjectType(initialValue)!, targetType);
+        }
+#endregion
+
+        private static object? EnsureTypeAssignable(object? value, Type initialType, Type targetType)
+        {
+            if (value != null)
+            {
+                Type valueType = value.GetType();
+
+                if (targetType.IsAssignableFrom(valueType))
+                {
+                    return value;
+                }
+
+                Func<object?, object?>? castConverter = CastConverters.Get(new StructMultiKey<Type, Type>(valueType, targetType));
+                if (castConverter != null)
+                {
+                    return castConverter(value);
+                }
+            }
+            else
+            {
+                if (ReflectionUtils.IsNullable(targetType))
+                {
+                    return null;
+                }
+            }
+
+            throw new ArgumentException("Could not cast or convert from {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, initialType?.ToString() ?? "{null}", targetType));
+        }
+
+        public static bool VersionTryParse(string input, [NotNullWhen(true)]out Version? result)
+        {
+#if HAVE_VERSION_TRY_PARSE
+            return Version.TryParse(input, out result);
+#else
+            // improve failure performance with regex?
+            try
+            {
+                result = new Version(input);
+                return true;
+            }
+            catch
+            {
+                result = null;
+                return false;
+            }
+#endif
+        }
+
+        public static bool IsInteger(object value)
+        {
+            switch (GetTypeCode(value.GetType()))
+            {
+                case PrimitiveTypeCode.SByte:
+                case PrimitiveTypeCode.Byte:
+                case PrimitiveTypeCode.Int16:
+                case PrimitiveTypeCode.UInt16:
+                case PrimitiveTypeCode.Int32:
+                case PrimitiveTypeCode.UInt32:
+                case PrimitiveTypeCode.Int64:
+                case PrimitiveTypeCode.UInt64:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        public static ParseResult Int32TryParse(char[] chars, int start, int length, out int value)
+        {
+            value = 0;
+
+            if (length == 0)
+            {
+                return ParseResult.Invalid;
+            }
+
+            bool isNegative = (chars[start] == '-');
+
+            if (isNegative)
+            {
+                // text just a negative sign
+                if (length == 1)
+                {
+                    return ParseResult.Invalid;
+                }
+
+                start++;
+                length--;
+            }
+
+            int end = start + length;
+
+            // Int32.MaxValue and MinValue are 10 chars
+            // Or is 10 chars and start is greater than two
+            // Need to improve this!
+            if (length > 10 || (length == 10 && chars[start] - '0' > 2))
+            {
+                // invalid result takes precedence over overflow
+                for (int i = start; i < end; i++)
+                {
+                    int c = chars[i] - '0';
+
+                    if (c < 0 || c > 9)
+                    {
+                        return ParseResult.Invalid;
+                    }
+                }
+
+                return ParseResult.Overflow;
+            }
+
+            for (int i = start; i < end; i++)
+            {
+                int c = chars[i] - '0';
+
+                if (c < 0 || c > 9)
+                {
+                    return ParseResult.Invalid;
+                }
+
+                int newValue = (10 * value) - c;
+
+                // overflow has caused the number to loop around
+                if (newValue > value)
+                {
+                    i++;
+
+                    // double check the rest of the string that there wasn't anything invalid
+                    // invalid result takes precedence over overflow result
+                    for (; i < end; i++)
+                    {
+                        c = chars[i] - '0';
+
+                        if (c < 0 || c > 9)
+                        {
+                            return ParseResult.Invalid;
+                        }
+                    }
+
+                    return ParseResult.Overflow;
+                }
+
+                value = newValue;
+            }
+
+            // go from negative to positive to avoids overflow
+            // negative can be slightly bigger than positive
+            if (!isNegative)
+            {
+                // negative integer can be one bigger than positive
+                if (value == int.MinValue)
+                {
+                    return ParseResult.Overflow;
+                }
+
+                value = -value;
+            }
+
+            return ParseResult.Success;
+        }
+
+        public static ParseResult Int64TryParse(char[] chars, int start, int length, out long value)
+        {
+            value = 0;
+
+            if (length == 0)
+            {
+                return ParseResult.Invalid;
+            }
+
+            bool isNegative = (chars[start] == '-');
+
+            if (isNegative)
+            {
+                // text just a negative sign
+                if (length == 1)
+                {
+                    return ParseResult.Invalid;
+                }
+
+                start++;
+                length--;
+            }
+
+            int end = start + length;
+
+            // Int64.MaxValue and MinValue are 19 chars
+            if (length > 19)
+            {
+                // invalid result takes precedence over overflow
+                for (int i = start; i < end; i++)
+                {
+                    int c = chars[i] - '0';
+
+                    if (c < 0 || c > 9)
+                    {
+                        return ParseResult.Invalid;
+                    }
+                }
+
+                return ParseResult.Overflow;
+            }
+
+            for (int i = start; i < end; i++)
+            {
+                int c = chars[i] - '0';
+
+                if (c < 0 || c > 9)
+                {
+                    return ParseResult.Invalid;
+                }
+
+                long newValue = (10 * value) - c;
+
+                // overflow has caused the number to loop around
+                if (newValue > value)
+                {
+                    i++;
+
+                    // double check the rest of the string that there wasn't anything invalid
+                    // invalid result takes precedence over overflow result
+                    for (; i < end; i++)
+                    {
+                        c = chars[i] - '0';
+
+                        if (c < 0 || c > 9)
+                        {
+                            return ParseResult.Invalid;
+                        }
+                    }
+
+                    return ParseResult.Overflow;
+                }
+
+                value = newValue;
+            }
+
+            // go from negative to positive to avoids overflow
+            // negative can be slightly bigger than positive
+            if (!isNegative)
+            {
+                // negative integer can be one bigger than positive
+                if (value == long.MinValue)
+                {
+                    return ParseResult.Overflow;
+                }
+
+                value = -value;
+            }
+
+            return ParseResult.Success;
+        }
+
+#if HAS_CUSTOM_DOUBLE_PARSE
+        private static class IEEE754
+        {
+            /// <summary>
+            /// Exponents for both powers of 10 and 0.1
+            /// </summary>
+            private static readonly int[] MultExp64Power10 = new int[]
+            {
+                4, 7, 10, 14, 17, 20, 24, 27, 30, 34, 37, 40, 44, 47, 50
+            };
+
+            /// <summary>
+            /// Normalized powers of 10
+            /// </summary>
+            private static readonly ulong[] MultVal64Power10 = new ulong[]
+            {
+                0xa000000000000000, 0xc800000000000000, 0xfa00000000000000,
+                0x9c40000000000000, 0xc350000000000000, 0xf424000000000000,
+                0x9896800000000000, 0xbebc200000000000, 0xee6b280000000000,
+                0x9502f90000000000, 0xba43b74000000000, 0xe8d4a51000000000,
+                0x9184e72a00000000, 0xb5e620f480000000, 0xe35fa931a0000000,
+            };
+
+            /// <summary>
+            /// Normalized powers of 0.1
+            /// </summary>
+            private static readonly ulong[] MultVal64Power10Inv = new ulong[]
+            {
+                0xcccccccccccccccd, 0xa3d70a3d70a3d70b, 0x83126e978d4fdf3c,
+                0xd1b71758e219652e, 0xa7c5ac471b478425, 0x8637bd05af6c69b7,
+                0xd6bf94d5e57a42be, 0xabcc77118461ceff, 0x89705f4136b4a599,
+                0xdbe6fecebdedd5c2, 0xafebff0bcb24ab02, 0x8cbccc096f5088cf,
+                0xe12e13424bb40e18, 0xb424dc35095cd813, 0x901d7cf73ab0acdc,
+            };
+
+            /// <summary>
+            /// Exponents for both powers of 10^16 and 0.1^16
+            /// </summary>
+            private static readonly int[] MultExp64Power10By16 = new int[]
+            {
+                54, 107, 160, 213, 266, 319, 373, 426, 479, 532, 585, 638,
+                691, 745, 798, 851, 904, 957, 1010, 1064, 1117,
+            };
+
+            /// <summary>
+            /// Normalized powers of 10^16
+            /// </summary>
+            private static readonly ulong[] MultVal64Power10By16 = new ulong[]
+            {
+                0x8e1bc9bf04000000, 0x9dc5ada82b70b59e, 0xaf298d050e4395d6,
+                0xc2781f49ffcfa6d4, 0xd7e77a8f87daf7fa, 0xefb3ab16c59b14a0,
+                0x850fadc09923329c, 0x93ba47c980e98cde, 0xa402b9c5a8d3a6e6,
+                0xb616a12b7fe617a8, 0xca28a291859bbf90, 0xe070f78d39275566,
+                0xf92e0c3537826140, 0x8a5296ffe33cc92c, 0x9991a6f3d6bf1762,
+                0xaa7eebfb9df9de8a, 0xbd49d14aa79dbc7e, 0xd226fc195c6a2f88,
+                0xe950df20247c83f8, 0x81842f29f2cce373, 0x8fcac257558ee4e2,
+            };
+
+            /// <summary>
+            /// Normalized powers of 0.1^16
+            /// </summary>
+            private static readonly ulong[] MultVal64Power10By16Inv = new ulong[]
+            {
+                0xe69594bec44de160, 0xcfb11ead453994c3, 0xbb127c53b17ec165,
+                0xa87fea27a539e9b3, 0x97c560ba6b0919b5, 0x88b402f7fd7553ab,
+                0xf64335bcf065d3a0, 0xddd0467c64bce4c4, 0xc7caba6e7c5382ed,
+                0xb3f4e093db73a0b7, 0xa21727db38cb0053, 0x91ff83775423cc29,
+                0x8380dea93da4bc82, 0xece53cec4a314f00, 0xd5605fcdcf32e217,
+                0xc0314325637a1978, 0xad1c8eab5ee43ba2, 0x9becce62836ac5b0,
+                0x8c71dcd9ba0b495c, 0xfd00b89747823938, 0xe3e27a444d8d991a,
+            };
+
+            /// <summary>
+            /// Packs <paramref name="val"/>*10^<paramref name="scale"/> as 64-bit floating point value according to IEEE 754 standard
+            /// </summary>
+            /// <param name="negative">Sign</param>
+            /// <param name="val">Mantissa</param>
+            /// <param name="scale">Exponent</param>
+            /// <remarks>
+            /// Adoption of native function NumberToDouble() from coreclr sources,
+            /// see https://github.com/dotnet/coreclr/blob/master/src/classlibnative/bcltype/number.cpp#L451
+            /// </remarks>
+            public static double PackDouble(bool negative, ulong val, int scale)
+            {
+                // handle zero value
+                if (val == 0)
+                {
+                    return negative ? -0.0 : 0.0;
+                }
+
+                // normalize the mantissa
+                int exp = 64;
+
+                if ((val & 0xFFFFFFFF00000000) == 0)
+                {
+                    val <<= 32;
+                    exp -= 32;
+                }
+                if ((val & 0xFFFF000000000000) == 0)
+                {
+                    val <<= 16;
+                    exp -= 16;
+                }
+                if ((val & 0xFF00000000000000) == 0)
+                {
+                    val <<= 8;
+                    exp -= 8;
+                }
+                if ((val & 0xF000000000000000) == 0)
+                {
+                    val <<= 4;
+                    exp -= 4;
+                }
+                if ((val & 0xC000000000000000) == 0)
+                {
+                    val <<= 2;
+                    exp -= 2;
+                }
+                if ((val & 0x8000000000000000) == 0)
+                {
+                    val <<= 1;
+                    exp -= 1;
+                }
+
+                if (scale < 0)
+                {
+                    scale = -scale;
+
+                    // check scale bounds
+                    if (scale >= 22 * 16)
+                    {
+                        // underflow
+                        return negative ? -0.0 : 0.0;
+                    }
+
+                    // perform scaling
+                    int index = scale & 15;
+                    if (index != 0)
+                    {
+                        exp -= MultExp64Power10[index - 1] - 1;
+                        val = Mul64Lossy(val, MultVal64Power10Inv[index - 1], ref exp);
+                    }
+
+                    index = scale >> 4;
+                    if (index != 0)
+                    {
+                        exp -= MultExp64Power10By16[index - 1] - 1;
+                        val = Mul64Lossy(val, MultVal64Power10By16Inv[index - 1], ref exp);
+                    }
+                }
+                else
+                {
+                    // check scale bounds
+                    if (scale >= 22 * 16)
+                    {
+                        // overflow
+                        return negative ? double.NegativeInfinity : double.PositiveInfinity;
+                    }
+
+                    // perform scaling
+                    int index = scale & 15;
+                    if (index != 0)
+                    {
+                        exp += MultExp64Power10[index - 1];
+                        val = Mul64Lossy(val, MultVal64Power10[index - 1], ref exp);
+                    }
+
+                    index = scale >> 4;
+                    if (index != 0)
+                    {
+                        exp += MultExp64Power10By16[index - 1];
+                        val = Mul64Lossy(val, MultVal64Power10By16[index - 1], ref exp);
+                    }
+                }
+
+                // round & scale down
+
+                if ((val & (1 << 10)) != 0)
+                {
+                    // IEEE round to even
+                    ulong tmp = val + ((1UL << 10) - 1 + ((val >> 11) & 1));
+                    if (tmp < val)
+                    {
+                        // overflow
+                        tmp = (tmp >> 1) | 0x8000000000000000;
+                        exp++;
+                    }
+                    val = tmp;
+                }
+
+                // return the exponent to a biased state
+
+                exp += 0x3FE;
+
+                // handle overflow, underflow, "Epsilon - 1/2 Epsilon", denormalized, and the normal case
+
+                if (exp <= 0)
+                {
+                    if (exp == -52 && (val >= 0x8000000000000058))
+                    {
+                        // round X where {Epsilon > X >= 2.470328229206232730000000E-324} up to Epsilon (instead of down to zero)
+                        val = 0x0000000000000001;
+                    }
+                    else if (exp <= -52)
+                    {
+                        // underflow
+                        val = 0;
+                    }
+                    else
+                    {
+                        // denormalized value
+                        val >>= (-exp + 12);
+                    }
+                }
+                else if (exp >= 0x7FF)
+                {
+                    // overflow
+                    val = 0x7FF0000000000000;
+                }
+                else
+                {
+                    // normal positive exponent case
+                    val = ((ulong)exp << 52) | ((val >> 11) & 0x000FFFFFFFFFFFFF);
+                }
+
+                // apply sign
+
+                if (negative)
+                {
+                    val |= 0x8000000000000000;
+                }
+
+                return BitConverter.Int64BitsToDouble((long)val);
+            }
+
+            private static ulong Mul64Lossy(ulong a, ulong b, ref int exp)
+            {
+                ulong a_hi = (a >> 32);
+                uint a_lo = (uint)a;
+                ulong b_hi = (b >> 32);
+                uint b_lo = (uint)b;
+
+                ulong result = a_hi * b_hi;
+
+                // save some multiplications if lo-parts aren't big enough to produce carry
+                // (hi-parts will be always big enough, since a and b are normalized)
+
+                if ((b_lo & 0xFFFF0000) != 0)
+                {
+                    result += (a_hi * b_lo) >> 32;
+                }
+
+                if ((a_lo & 0xFFFF0000) != 0)
+                {
+                    result += (a_lo * b_hi) >> 32;
+                }
+
+                // normalize
+                if ((result & 0x8000000000000000) == 0)
+                {
+                    result <<= 1;
+                    exp--;
+                }
+
+                return result;
+            }
+        }
+
+        public static ParseResult DoubleTryParse(char[] chars, int start, int length, out double value)
+        {
+            value = 0;
+
+            if (length == 0)
+            {
+                return ParseResult.Invalid;
+            }
+
+            bool isNegative = (chars[start] == '-');
+            if (isNegative)
+            {
+                // text just a negative sign
+                if (length == 1)
+                {
+                    return ParseResult.Invalid;
+                }
+
+                start++;
+                length--;
+            }
+
+            int i = start;
+            int end = start + length;
+            int numDecimalStart = end;
+            int numDecimalEnd = end;
+            int exponent = 0;
+            ulong mantissa = 0UL;
+            int mantissaDigits = 0;
+            int exponentFromMantissa = 0;
+            for (; i < end; i++)
+            {
+                char c = chars[i];
+                switch (c)
+                {
+                    case '.':
+                        if (i == start)
+                        {
+                            return ParseResult.Invalid;
+                        }
+                        if (i + 1 == end)
+                        {
+                            return ParseResult.Invalid;
+                        }
+
+                        if (numDecimalStart != end)
+                        {
+                            // multiple decimal points
+                            return ParseResult.Invalid;
+                        }
+
+                        numDecimalStart = i + 1;
+                        break;
+                    case 'e':
+                    case 'E':
+                        if (i == start)
+                        {
+                            return ParseResult.Invalid;
+                        }
+                        if (i == numDecimalStart)
+                        {
+                            // E follows decimal point
+                            return ParseResult.Invalid;
+                        }
+                        i++;
+                        if (i == end)
+                        {
+                            return ParseResult.Invalid;
+                        }
+
+                        if (numDecimalStart < end)
+                        {
+                            numDecimalEnd = i - 1;
+                        }
+
+                        c = chars[i];
+                        bool exponentNegative = false;
+                        switch (c)
+                        {
+                            case '-':
+                                exponentNegative = true;
+                                i++;
+                                break;
+                            case '+':
+                                i++;
+                                break;
+                        }
+
+                        // parse 3 digit
+                        for (; i < end; i++)
+                        {
+                            c = chars[i];
+                            if (c < '0' || c > '9')
+                            {
+                                return ParseResult.Invalid;
+                            }
+
+                            int newExponent = (10 * exponent) + (c - '0');
+                            // stops updating exponent when overflowing
+                            if (exponent < newExponent)
+                            {
+                                exponent = newExponent;
+                            }
+                        }
+
+                        if (exponentNegative)
+                        {
+                            exponent = -exponent;
+                        }
+                        break;
+                    default:
+                        if (c < '0' || c > '9')
+                        {
+                            return ParseResult.Invalid;
+                        }
+
+                        if (i == start && c == '0')
+                        {
+                            i++;
+                            if (i != end)
+                            {
+                                c = chars[i];
+                                if (c == '.')
+                                {
+                                    goto case '.';
+                                }
+                                if (c == 'e' || c == 'E')
+                                {
+                                    goto case 'E';
+                                }
+
+                                return ParseResult.Invalid;
+                            }
+                        }
+
+                        if (mantissaDigits < 19)
+                        {
+                            mantissa = (10 * mantissa) + (ulong)(c - '0');
+                            if (mantissa > 0)
+                            {
+                                ++mantissaDigits;
+                            }
+                        }
+                        else
+                        {
+                            ++exponentFromMantissa;
+                        }
+                        break;
+                }
+            }
+
+            exponent += exponentFromMantissa;
+
+            // correct the decimal point
+            exponent -= (numDecimalEnd - numDecimalStart);
+
+            value = IEEE754.PackDouble(isNegative, mantissa, exponent);
+            return double.IsInfinity(value) ? ParseResult.Overflow : ParseResult.Success;
+        }
+#endif
+
+        public static ParseResult DecimalTryParse(char[] chars, int start, int length, out decimal value)
+        {
+            value = 0M;
+            const decimal decimalMaxValueHi28 = 7922816251426433759354395033M;
+            const ulong decimalMaxValueHi19 = 7922816251426433759UL;
+            const ulong decimalMaxValueLo9 = 354395033UL;
+            const char decimalMaxValueLo1 = '5';
+
+            if (length == 0)
+            {
+                return ParseResult.Invalid;
+            }
+
+            bool isNegative = (chars[start] == '-');
+            if (isNegative)
+            {
+                // text just a negative sign
+                if (length == 1)
+                {
+                    return ParseResult.Invalid;
+                }
+
+                start++;
+                length--;
+            }
+
+            int i = start;
+            int end = start + length;
+            int numDecimalStart = end;
+            int numDecimalEnd = end;
+            int exponent = 0;
+            ulong hi19 = 0UL;
+            ulong lo10 = 0UL;
+            int mantissaDigits = 0;
+            int exponentFromMantissa = 0;
+            char? digit29 = null;
+            bool? storeOnly28Digits = null;
+            for (; i < end; i++)
+            {
+                char c = chars[i];
+                switch (c)
+                {
+                    case '.':
+                        if (i == start)
+                        {
+                            return ParseResult.Invalid;
+                        }
+                        if (i + 1 == end)
+                        {
+                            return ParseResult.Invalid;
+                        }
+
+                        if (numDecimalStart != end)
+                        {
+                            // multiple decimal points
+                            return ParseResult.Invalid;
+                        }
+
+                        numDecimalStart = i + 1;
+                        break;
+                    case 'e':
+                    case 'E':
+                        if (i == start)
+                        {
+                            return ParseResult.Invalid;
+                        }
+                        if (i == numDecimalStart)
+                        {
+                            // E follows decimal point		
+                            return ParseResult.Invalid;
+                        }
+                        i++;
+                        if (i == end)
+                        {
+                            return ParseResult.Invalid;
+                        }
+
+                        if (numDecimalStart < end)
+                        {
+                            numDecimalEnd = i - 1;
+                        }
+
+                        c = chars[i];
+                        bool exponentNegative = false;
+                        switch (c)
+                        {
+                            case '-':
+                                exponentNegative = true;
+                                i++;
+                                break;
+                            case '+':
+                                i++;
+                                break;
+                        }
+
+                        // parse 3 digit 
+                        for (; i < end; i++)
+                        {
+                            c = chars[i];
+                            if (c < '0' || c > '9')
+                            {
+                                return ParseResult.Invalid;
+                            }
+
+                            int newExponent = (10 * exponent) + (c - '0');
+                            // stops updating exponent when overflowing
+                            if (exponent < newExponent)
+                            {
+                                exponent = newExponent;
+                            }
+                        }
+
+                        if (exponentNegative)
+                        {
+                            exponent = -exponent;
+                        }
+                        break;
+                    default:
+                        if (c < '0' || c > '9')
+                        {
+                            return ParseResult.Invalid;
+                        }
+
+                        if (i == start && c == '0')
+                        {
+                            i++;
+                            if (i != end)
+                            {
+                                c = chars[i];
+                                if (c == '.')
+                                {
+                                    goto case '.';
+                                }
+                                if (c == 'e' || c == 'E')
+                                {
+                                    goto case 'E';
+                                }
+
+                                return ParseResult.Invalid;
+                            }
+                        }
+
+                        if (mantissaDigits < 29 && (mantissaDigits != 28 || !(storeOnly28Digits ?? (storeOnly28Digits = (hi19 > decimalMaxValueHi19 || (hi19 == decimalMaxValueHi19 && (lo10 > decimalMaxValueLo9 || (lo10 == decimalMaxValueLo9 && c > decimalMaxValueLo1))))).GetValueOrDefault())))
+                        {
+                            if (mantissaDigits < 19)
+                            {
+                                hi19 = (hi19 * 10UL) + (ulong)(c - '0');
+                            }
+                            else
+                            {
+                                lo10 = (lo10 * 10UL) + (ulong)(c - '0');
+                            }
+                            ++mantissaDigits;
+                        }
+                        else
+                        {
+                            if (!digit29.HasValue)
+                            {
+                                digit29 = c;
+                            }
+                            ++exponentFromMantissa;
+                        }
+                        break;
+                }
+            }
+
+            exponent += exponentFromMantissa;
+
+            // correct the decimal point
+            exponent -= (numDecimalEnd - numDecimalStart);
+
+            if (mantissaDigits <= 19)
+            {
+                value = hi19;
+            }
+            else
+            {
+                value = (hi19 / new decimal(1, 0, 0, false, (byte)(mantissaDigits - 19))) + lo10;
+            }
+
+            if (exponent > 0)
+            {
+                mantissaDigits += exponent;
+                if (mantissaDigits > 29)
+                {
+                    return ParseResult.Overflow;
+                }
+                if (mantissaDigits == 29)
+                {
+                    if (exponent > 1)
+                    {
+                        value /= new decimal(1, 0, 0, false, (byte)(exponent - 1));
+                        if (value > decimalMaxValueHi28)
+                        {
+                            return ParseResult.Overflow;
+                        }
+                    }
+                    else if (value == decimalMaxValueHi28 && digit29 > decimalMaxValueLo1)
+                    {
+                        return ParseResult.Overflow;
+                    }
+                    value *= 10M;
+                }
+                else
+                {
+                    value /= new decimal(1, 0, 0, false, (byte)exponent);
+                }
+            }
+            else
+            {
+                if (digit29 >= '5' && exponent >= -28)
+                {
+                    ++value;
+                }
+                if (exponent < 0)
+                {
+                    if (mantissaDigits + exponent + 28 <= 0)
+                    {
+                        value = isNegative ? -0M : 0M;
+                        return ParseResult.Success;
+                    }
+                    if (exponent >= -28)
+                    {
+                        value *= new decimal(1, 0, 0, false, (byte)(-exponent));
+                    }
+                    else
+                    {
+                        value /= 1e28M;
+                        value *= new decimal(1, 0, 0, false, (byte)(-exponent - 28));
+                    }
+                }
+            }
+
+            if (isNegative)
+            {
+                value = -value;
+            }
+
+            return ParseResult.Success;
+        }
+
+        public static bool TryConvertGuid(string s, out Guid g)
+        {
+            // GUID has to have format 00000000-0000-0000-0000-000000000000
+#if !HAVE_GUID_TRY_PARSE
+            if (s == null)
+            {
+                throw new ArgumentNullException("s");
+            }
+
+            Regex format = new Regex("^[A-Fa-f0-9]{8}-([A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}$");
+            Match match = format.Match(s);
+            if (match.Success)
+            {
+                g = new Guid(s);
+                return true;
+            }
+
+            g = Guid.Empty;
+            return false;
+#else
+            return Guid.TryParseExact(s, "D", out g);
+#endif
+        }
+
+        public static bool TryHexTextToInt(char[] text, int start, int end, out int value)
+        {
+            value = 0;
+
+            for (int i = start; i < end; i++)
+            {
+                char ch = text[i];
+                int chValue;
+
+                if (ch <= 57 && ch >= 48)
+                {
+                    chValue = ch - 48;
+                }
+                else if (ch <= 70 && ch >= 65)
+                {
+                    chValue = ch - 55;
+                }
+                else if (ch <= 102 && ch >= 97)
+                {
+                    chValue = ch - 87;
+                }
+                else
+                {
+                    value = 0;
+                    return false;
+                }
+
+                value += chValue << ((end - 1 - i) * 4);
+            }
+
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/DateTimeParser.cs b/Libs/Newtonsoft.Json/Utilities/DateTimeParser.cs
new file mode 100644
index 0000000..0a0dc81
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/DateTimeParser.cs
@@ -0,0 +1,277 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal enum ParserTimeZone
+    {
+        Unspecified = 0,
+        Utc = 1,
+        LocalWestOfUtc = 2,
+        LocalEastOfUtc = 3
+    }
+
+    internal struct DateTimeParser
+    {
+        static DateTimeParser()
+        {
+            Power10 = new[] { -1, 10, 100, 1000, 10000, 100000, 1000000 };
+
+            Lzyyyy = "yyyy".Length;
+            Lzyyyy_ = "yyyy-".Length;
+            Lzyyyy_MM = "yyyy-MM".Length;
+            Lzyyyy_MM_ = "yyyy-MM-".Length;
+            Lzyyyy_MM_dd = "yyyy-MM-dd".Length;
+            Lzyyyy_MM_ddT = "yyyy-MM-ddT".Length;
+            LzHH = "HH".Length;
+            LzHH_ = "HH:".Length;
+            LzHH_mm = "HH:mm".Length;
+            LzHH_mm_ = "HH:mm:".Length;
+            LzHH_mm_ss = "HH:mm:ss".Length;
+            Lz_ = "-".Length;
+            Lz_zz = "-zz".Length;
+        }
+
+        public int Year;
+        public int Month;
+        public int Day;
+        public int Hour;
+        public int Minute;
+        public int Second;
+        public int Fraction;
+        public int ZoneHour;
+        public int ZoneMinute;
+        public ParserTimeZone Zone;
+
+        private char[] _text;
+        private int _end;
+
+        private static readonly int[] Power10;
+
+        private static readonly int Lzyyyy;
+        private static readonly int Lzyyyy_;
+        private static readonly int Lzyyyy_MM;
+        private static readonly int Lzyyyy_MM_;
+        private static readonly int Lzyyyy_MM_dd;
+        private static readonly int Lzyyyy_MM_ddT;
+        private static readonly int LzHH;
+        private static readonly int LzHH_;
+        private static readonly int LzHH_mm;
+        private static readonly int LzHH_mm_;
+        private static readonly int LzHH_mm_ss;
+        private static readonly int Lz_;
+        private static readonly int Lz_zz;
+
+        private const short MaxFractionDigits = 7;
+
+        public bool Parse(char[] text, int startIndex, int length)
+        {
+            _text = text;
+            _end = startIndex + length;
+
+            if (ParseDate(startIndex) && ParseChar(Lzyyyy_MM_dd + startIndex, 'T') && ParseTimeAndZoneAndWhitespace(Lzyyyy_MM_ddT + startIndex))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool ParseDate(int start)
+        {
+            return (Parse4Digit(start, out Year)
+                    && 1 <= Year
+                    && ParseChar(start + Lzyyyy, '-')
+                    && Parse2Digit(start + Lzyyyy_, out Month)
+                    && 1 <= Month
+                    && Month <= 12
+                    && ParseChar(start + Lzyyyy_MM, '-')
+                    && Parse2Digit(start + Lzyyyy_MM_, out Day)
+                    && 1 <= Day
+                    && Day <= DateTime.DaysInMonth(Year, Month));
+        }
+
+        private bool ParseTimeAndZoneAndWhitespace(int start)
+        {
+            return (ParseTime(ref start) && ParseZone(start));
+        }
+
+        private bool ParseTime(ref int start)
+        {
+            if (!(Parse2Digit(start, out Hour)
+                  && Hour <= 24
+                  && ParseChar(start + LzHH, ':')
+                  && Parse2Digit(start + LzHH_, out Minute)
+                  && Minute < 60
+                  && ParseChar(start + LzHH_mm, ':')
+                  && Parse2Digit(start + LzHH_mm_, out Second)
+                  && Second < 60
+                  && (Hour != 24 || (Minute == 0 && Second == 0)))) // hour can be 24 if minute/second is zero)
+            {
+                return false;
+            }
+
+            start += LzHH_mm_ss;
+            if (ParseChar(start, '.'))
+            {
+                Fraction = 0;
+                int numberOfDigits = 0;
+
+                while (++start < _end && numberOfDigits < MaxFractionDigits)
+                {
+                    int digit = _text[start] - '0';
+                    if (digit < 0 || digit > 9)
+                    {
+                        break;
+                    }
+
+                    Fraction = (Fraction * 10) + digit;
+
+                    numberOfDigits++;
+                }
+
+                if (numberOfDigits < MaxFractionDigits)
+                {
+                    if (numberOfDigits == 0)
+                    {
+                        return false;
+                    }
+
+                    Fraction *= Power10[MaxFractionDigits - numberOfDigits];
+                }
+
+                if (Hour == 24 && Fraction != 0)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private bool ParseZone(int start)
+        {
+            if (start < _end)
+            {
+                char ch = _text[start];
+                if (ch == 'Z' || ch == 'z')
+                {
+                    Zone = ParserTimeZone.Utc;
+                    start++;
+                }
+                else
+                {
+                    if (start + 2 < _end
+                        && Parse2Digit(start + Lz_, out ZoneHour)
+                        && ZoneHour <= 99)
+                    {
+                        switch (ch)
+                        {
+                            case '-':
+                                Zone = ParserTimeZone.LocalWestOfUtc;
+                                start += Lz_zz;
+                                break;
+
+                            case '+':
+                                Zone = ParserTimeZone.LocalEastOfUtc;
+                                start += Lz_zz;
+                                break;
+                        }
+                    }
+
+                    if (start < _end)
+                    {
+                        if (ParseChar(start, ':'))
+                        {
+                            start += 1;
+
+                            if (start + 1 < _end
+                                && Parse2Digit(start, out ZoneMinute)
+                                && ZoneMinute <= 99)
+                            {
+                                start += 2;
+                            }
+                        }
+                        else
+                        {
+                            if (start + 1 < _end
+                                && Parse2Digit(start, out ZoneMinute)
+                                && ZoneMinute <= 99)
+                            {
+                                start += 2;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return (start == _end);
+        }
+
+        private bool Parse4Digit(int start, out int num)
+        {
+            if (start + 3 < _end)
+            {
+                int digit1 = _text[start] - '0';
+                int digit2 = _text[start + 1] - '0';
+                int digit3 = _text[start + 2] - '0';
+                int digit4 = _text[start + 3] - '0';
+                if (0 <= digit1 && digit1 < 10
+                    && 0 <= digit2 && digit2 < 10
+                    && 0 <= digit3 && digit3 < 10
+                    && 0 <= digit4 && digit4 < 10)
+                {
+                    num = (((((digit1 * 10) + digit2) * 10) + digit3) * 10) + digit4;
+                    return true;
+                }
+            }
+            num = 0;
+            return false;
+        }
+
+        private bool Parse2Digit(int start, out int num)
+        {
+            if (start + 1 < _end)
+            {
+                int digit1 = _text[start] - '0';
+                int digit2 = _text[start + 1] - '0';
+                if (0 <= digit1 && digit1 < 10
+                    && 0 <= digit2 && digit2 < 10)
+                {
+                    num = (digit1 * 10) + digit2;
+                    return true;
+                }
+            }
+            num = 0;
+            return false;
+        }
+
+        private bool ParseChar(int start, char ch)
+        {
+            return (start < _end && _text[start] == ch);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/DateTimeUtils.cs b/Libs/Newtonsoft.Json/Utilities/DateTimeUtils.cs
new file mode 100644
index 0000000..5301d0f
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/DateTimeUtils.cs
@@ -0,0 +1,825 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.IO;
+using System.Xml;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class DateTimeUtils
+    {
+        internal static readonly long InitialJavaScriptDateTicks = 621355968000000000;
+        private const string IsoDateFormat = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
+
+        private const int DaysPer100Years = 36524;
+        private const int DaysPer400Years = 146097;
+        private const int DaysPer4Years = 1461;
+        private const int DaysPerYear = 365;
+        private const long TicksPerDay = 864000000000L;
+        private static readonly int[] DaysToMonth365;
+        private static readonly int[] DaysToMonth366;
+
+        static DateTimeUtils()
+        {
+            DaysToMonth365 = new[] { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
+            DaysToMonth366 = new[] { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 };
+        }
+
+        public static TimeSpan GetUtcOffset(this DateTime d)
+        {
+#if !HAVE_TIME_ZONE_INFO
+            return TimeZone.CurrentTimeZone.GetUtcOffset(d);
+#else
+            return TimeZoneInfo.Local.GetUtcOffset(d);
+#endif
+        }
+
+#if !(PORTABLE40 || PORTABLE) || NETSTANDARD1_3
+        public static XmlDateTimeSerializationMode ToSerializationMode(DateTimeKind kind)
+        {
+            switch (kind)
+            {
+                case DateTimeKind.Local:
+                    return XmlDateTimeSerializationMode.Local;
+                case DateTimeKind.Unspecified:
+                    return XmlDateTimeSerializationMode.Unspecified;
+                case DateTimeKind.Utc:
+                    return XmlDateTimeSerializationMode.Utc;
+                default:
+                    throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(kind), kind, "Unexpected DateTimeKind value.");
+            }
+        }
+#else
+        public static string ToDateTimeFormat(DateTimeKind kind)
+        {
+            switch (kind)
+            {
+                case DateTimeKind.Local:
+                    return IsoDateFormat;
+                case DateTimeKind.Unspecified:
+                    return "yyyy-MM-ddTHH:mm:ss.FFFFFFF";
+                case DateTimeKind.Utc:
+                    return "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ";
+                default:
+                    throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(kind), kind, "Unexpected DateTimeKind value.");
+            }
+        }
+#endif
+
+        internal static DateTime EnsureDateTime(DateTime value, DateTimeZoneHandling timeZone)
+        {
+            switch (timeZone)
+            {
+                case DateTimeZoneHandling.Local:
+                    value = SwitchToLocalTime(value);
+                    break;
+                case DateTimeZoneHandling.Utc:
+                    value = SwitchToUtcTime(value);
+                    break;
+                case DateTimeZoneHandling.Unspecified:
+                    value = new DateTime(value.Ticks, DateTimeKind.Unspecified);
+                    break;
+                case DateTimeZoneHandling.RoundtripKind:
+                    break;
+                default:
+                    throw new ArgumentException("Invalid date time handling value.");
+            }
+
+            return value;
+        }
+
+        private static DateTime SwitchToLocalTime(DateTime value)
+        {
+            switch (value.Kind)
+            {
+                case DateTimeKind.Unspecified:
+                    return new DateTime(value.Ticks, DateTimeKind.Local);
+
+                case DateTimeKind.Utc:
+                    return value.ToLocalTime();
+
+                case DateTimeKind.Local:
+                    return value;
+            }
+            return value;
+        }
+
+        private static DateTime SwitchToUtcTime(DateTime value)
+        {
+            switch (value.Kind)
+            {
+                case DateTimeKind.Unspecified:
+                    return new DateTime(value.Ticks, DateTimeKind.Utc);
+
+                case DateTimeKind.Utc:
+                    return value;
+
+                case DateTimeKind.Local:
+                    return value.ToUniversalTime();
+            }
+            return value;
+        }
+
+        private static long ToUniversalTicks(DateTime dateTime)
+        {
+            if (dateTime.Kind == DateTimeKind.Utc)
+            {
+                return dateTime.Ticks;
+            }
+
+            return ToUniversalTicks(dateTime, dateTime.GetUtcOffset());
+        }
+
+        private static long ToUniversalTicks(DateTime dateTime, TimeSpan offset)
+        {
+            // special case min and max value
+            // they never have a timezone appended to avoid issues
+            if (dateTime.Kind == DateTimeKind.Utc || dateTime == DateTime.MaxValue || dateTime == DateTime.MinValue)
+            {
+                return dateTime.Ticks;
+            }
+
+            long ticks = dateTime.Ticks - offset.Ticks;
+            if (ticks > 3155378975999999999L)
+            {
+                return 3155378975999999999L;
+            }
+
+            if (ticks < 0L)
+            {
+                return 0L;
+            }
+
+            return ticks;
+        }
+
+        internal static long ConvertDateTimeToJavaScriptTicks(DateTime dateTime, TimeSpan offset)
+        {
+            long universalTicks = ToUniversalTicks(dateTime, offset);
+
+            return UniversalTicksToJavaScriptTicks(universalTicks);
+        }
+
+        internal static long ConvertDateTimeToJavaScriptTicks(DateTime dateTime)
+        {
+            return ConvertDateTimeToJavaScriptTicks(dateTime, true);
+        }
+
+        internal static long ConvertDateTimeToJavaScriptTicks(DateTime dateTime, bool convertToUtc)
+        {
+            long ticks = (convertToUtc) ? ToUniversalTicks(dateTime) : dateTime.Ticks;
+
+            return UniversalTicksToJavaScriptTicks(ticks);
+        }
+
+        private static long UniversalTicksToJavaScriptTicks(long universalTicks)
+        {
+            long javaScriptTicks = (universalTicks - InitialJavaScriptDateTicks) / 10000;
+
+            return javaScriptTicks;
+        }
+
+        internal static DateTime ConvertJavaScriptTicksToDateTime(long javaScriptTicks)
+        {
+            DateTime dateTime = new DateTime((javaScriptTicks * 10000) + InitialJavaScriptDateTicks, DateTimeKind.Utc);
+
+            return dateTime;
+        }
+
+        #region Parse
+        internal static bool TryParseDateTimeIso(StringReference text, DateTimeZoneHandling dateTimeZoneHandling, out DateTime dt)
+        {
+            DateTimeParser dateTimeParser = new DateTimeParser();
+            if (!dateTimeParser.Parse(text.Chars, text.StartIndex, text.Length))
+            {
+                dt = default;
+                return false;
+            }
+
+            DateTime d = CreateDateTime(dateTimeParser);
+
+            long ticks;
+
+            switch (dateTimeParser.Zone)
+            {
+                case ParserTimeZone.Utc:
+                    d = new DateTime(d.Ticks, DateTimeKind.Utc);
+                    break;
+
+                case ParserTimeZone.LocalWestOfUtc:
+                {
+                    TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
+                    ticks = d.Ticks + offset.Ticks;
+                    if (ticks <= DateTime.MaxValue.Ticks)
+                    {
+                        d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
+                    }
+                    else
+                    {
+                        ticks += d.GetUtcOffset().Ticks;
+                        if (ticks > DateTime.MaxValue.Ticks)
+                        {
+                            ticks = DateTime.MaxValue.Ticks;
+                        }
+
+                        d = new DateTime(ticks, DateTimeKind.Local);
+                    }
+                    break;
+                }
+                case ParserTimeZone.LocalEastOfUtc:
+                {
+                    TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
+                    ticks = d.Ticks - offset.Ticks;
+                    if (ticks >= DateTime.MinValue.Ticks)
+                    {
+                        d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
+                    }
+                    else
+                    {
+                        ticks += d.GetUtcOffset().Ticks;
+                        if (ticks < DateTime.MinValue.Ticks)
+                        {
+                            ticks = DateTime.MinValue.Ticks;
+                        }
+
+                        d = new DateTime(ticks, DateTimeKind.Local);
+                    }
+                    break;
+                }
+            }
+
+            dt = EnsureDateTime(d, dateTimeZoneHandling);
+            return true;
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        internal static bool TryParseDateTimeOffsetIso(StringReference text, out DateTimeOffset dt)
+        {
+            DateTimeParser dateTimeParser = new DateTimeParser();
+            if (!dateTimeParser.Parse(text.Chars, text.StartIndex, text.Length))
+            {
+                dt = default;
+                return false;
+            }
+
+            DateTime d = CreateDateTime(dateTimeParser);
+
+            TimeSpan offset;
+
+            switch (dateTimeParser.Zone)
+            {
+                case ParserTimeZone.Utc:
+                    offset = new TimeSpan(0L);
+                    break;
+                case ParserTimeZone.LocalWestOfUtc:
+                    offset = new TimeSpan(-dateTimeParser.ZoneHour, -dateTimeParser.ZoneMinute, 0);
+                    break;
+                case ParserTimeZone.LocalEastOfUtc:
+                    offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
+                    break;
+                default:
+                    offset = TimeZoneInfo.Local.GetUtcOffset(d);
+                    break;
+            }
+
+            long ticks = d.Ticks - offset.Ticks;
+            if (ticks < 0 || ticks > 3155378975999999999)
+            {
+                dt = default;
+                return false;
+            }
+
+            dt = new DateTimeOffset(d, offset);
+            return true;
+        }
+#endif
+
+        private static DateTime CreateDateTime(DateTimeParser dateTimeParser)
+        {
+            bool is24Hour;
+            if (dateTimeParser.Hour == 24)
+            {
+                is24Hour = true;
+                dateTimeParser.Hour = 0;
+            }
+            else
+            {
+                is24Hour = false;
+            }
+
+            DateTime d = new DateTime(dateTimeParser.Year, dateTimeParser.Month, dateTimeParser.Day, dateTimeParser.Hour, dateTimeParser.Minute, dateTimeParser.Second);
+            d = d.AddTicks(dateTimeParser.Fraction);
+
+            if (is24Hour)
+            {
+                d = d.AddDays(1);
+            }
+            return d;
+        }
+
+        internal static bool TryParseDateTime(StringReference s, DateTimeZoneHandling dateTimeZoneHandling, string? dateFormatString, CultureInfo culture, out DateTime dt)
+        {
+            if (s.Length > 0)
+            {
+                int i = s.StartIndex;
+                if (s[i] == '/')
+                {
+                    if (s.Length >= 9 && s.StartsWith("/Date(") && s.EndsWith(")/"))
+                    {
+                        if (TryParseDateTimeMicrosoft(s, dateTimeZoneHandling, out dt))
+                        {
+                            return true;
+                        }
+                    }
+                }
+                else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[i]) && s[i + 10] == 'T')
+                {
+                    if (TryParseDateTimeIso(s, dateTimeZoneHandling, out dt))
+                    {
+                        return true;
+                    }
+                }
+
+                if (!StringUtils.IsNullOrEmpty(dateFormatString))
+                {
+                    if (TryParseDateTimeExact(s.ToString(), dateTimeZoneHandling, dateFormatString, culture, out dt))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            dt = default;
+            return false;
+        }
+
+        internal static bool TryParseDateTime(string s, DateTimeZoneHandling dateTimeZoneHandling, string? dateFormatString, CultureInfo culture, out DateTime dt)
+        {
+            if (s.Length > 0)
+            {
+                if (s[0] == '/')
+                {
+                    if (s.Length >= 9 && s.StartsWith("/Date(", StringComparison.Ordinal) && s.EndsWith(")/", StringComparison.Ordinal))
+                    {
+                        if (TryParseDateTimeMicrosoft(new StringReference(s.ToCharArray(), 0, s.Length), dateTimeZoneHandling, out dt))
+                        {
+                            return true;
+                        }
+                    }
+                }
+                else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[0]) && s[10] == 'T')
+                {
+                    if (DateTime.TryParseExact(s, IsoDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dt))
+                    {
+                        dt = EnsureDateTime(dt, dateTimeZoneHandling);
+                        return true;
+                    }
+                }
+
+                if (!StringUtils.IsNullOrEmpty(dateFormatString))
+                {
+                    if (TryParseDateTimeExact(s, dateTimeZoneHandling, dateFormatString, culture, out dt))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            dt = default;
+            return false;
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        internal static bool TryParseDateTimeOffset(StringReference s, string? dateFormatString, CultureInfo culture, out DateTimeOffset dt)
+        {
+            if (s.Length > 0)
+            {
+                int i = s.StartIndex;
+                if (s[i] == '/')
+                {
+                    if (s.Length >= 9 && s.StartsWith("/Date(") && s.EndsWith(")/"))
+                    {
+                        if (TryParseDateTimeOffsetMicrosoft(s, out dt))
+                        {
+                            return true;
+                        }
+                    }
+                }
+                else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[i]) && s[i + 10] == 'T')
+                {
+                    if (TryParseDateTimeOffsetIso(s, out dt))
+                    {
+                        return true;
+                    }
+                }
+
+                if (!StringUtils.IsNullOrEmpty(dateFormatString))
+                {
+                    if (TryParseDateTimeOffsetExact(s.ToString(), dateFormatString, culture, out dt))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            dt = default;
+            return false;
+        }
+
+        internal static bool TryParseDateTimeOffset(string s, string? dateFormatString, CultureInfo culture, out DateTimeOffset dt)
+        {
+            if (s.Length > 0)
+            {
+                if (s[0] == '/')
+                {
+                    if (s.Length >= 9 && s.StartsWith("/Date(", StringComparison.Ordinal) && s.EndsWith(")/", StringComparison.Ordinal))
+                    {
+                        if (TryParseDateTimeOffsetMicrosoft(new StringReference(s.ToCharArray(), 0, s.Length), out dt))
+                        {
+                            return true;
+                        }
+                    }
+                }
+                else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[0]) && s[10] == 'T')
+                {
+                    if (DateTimeOffset.TryParseExact(s, IsoDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dt))
+                    {
+                        if (TryParseDateTimeOffsetIso(new StringReference(s.ToCharArray(), 0, s.Length), out dt))
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                if (!StringUtils.IsNullOrEmpty(dateFormatString))
+                {
+                    if (TryParseDateTimeOffsetExact(s, dateFormatString, culture, out dt))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            dt = default;
+            return false;
+        }
+#endif
+
+        private static bool TryParseMicrosoftDate(StringReference text, out long ticks, out TimeSpan offset, out DateTimeKind kind)
+        {
+            kind = DateTimeKind.Utc;
+
+            int index = text.IndexOf('+', 7, text.Length - 8);
+
+            if (index == -1)
+            {
+                index = text.IndexOf('-', 7, text.Length - 8);
+            }
+
+            if (index != -1)
+            {
+                kind = DateTimeKind.Local;
+
+                if (!TryReadOffset(text, index + text.StartIndex, out offset))
+                {
+                    ticks = 0;
+                    return false;
+                }
+            }
+            else
+            {
+                offset = TimeSpan.Zero;
+                index = text.Length - 2;
+            }
+
+            return (ConvertUtils.Int64TryParse(text.Chars, 6 + text.StartIndex, index - 6, out ticks) == ParseResult.Success);
+        }
+
+        private static bool TryParseDateTimeMicrosoft(StringReference text, DateTimeZoneHandling dateTimeZoneHandling, out DateTime dt)
+        {
+            if (!TryParseMicrosoftDate(text, out long ticks, out _, out DateTimeKind kind))
+            {
+                dt = default;
+                return false;
+            }
+
+            DateTime utcDateTime = ConvertJavaScriptTicksToDateTime(ticks);
+
+            switch (kind)
+            {
+                case DateTimeKind.Unspecified:
+                    dt = DateTime.SpecifyKind(utcDateTime.ToLocalTime(), DateTimeKind.Unspecified);
+                    break;
+                case DateTimeKind.Local:
+                    dt = utcDateTime.ToLocalTime();
+                    break;
+                default:
+                    dt = utcDateTime;
+                    break;
+            }
+
+            dt = EnsureDateTime(dt, dateTimeZoneHandling);
+            return true;
+        }
+
+        private static bool TryParseDateTimeExact(string text, DateTimeZoneHandling dateTimeZoneHandling, string dateFormatString, CultureInfo culture, out DateTime dt)
+        {
+            if (DateTime.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out DateTime temp))
+            {
+                temp = EnsureDateTime(temp, dateTimeZoneHandling);
+                dt = temp;
+                return true;
+            }
+
+            dt = default;
+            return false;
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        private static bool TryParseDateTimeOffsetMicrosoft(StringReference text, out DateTimeOffset dt)
+        {
+            if (!TryParseMicrosoftDate(text, out long ticks, out TimeSpan offset, out _))
+            {
+                dt = default(DateTime);
+                return false;
+            }
+
+            DateTime utcDateTime = ConvertJavaScriptTicksToDateTime(ticks);
+
+            dt = new DateTimeOffset(utcDateTime.Add(offset).Ticks, offset);
+            return true;
+        }
+
+        private static bool TryParseDateTimeOffsetExact(string text, string dateFormatString, CultureInfo culture, out DateTimeOffset dt)
+        {
+            if (DateTimeOffset.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out DateTimeOffset temp))
+            {
+                dt = temp;
+                return true;
+            }
+
+            dt = default;
+            return false;
+        }
+#endif
+
+        private static bool TryReadOffset(StringReference offsetText, int startIndex, out TimeSpan offset)
+        {
+            bool negative = (offsetText[startIndex] == '-');
+
+            if (ConvertUtils.Int32TryParse(offsetText.Chars, startIndex + 1, 2, out int hours) != ParseResult.Success)
+            {
+                offset = default;
+                return false;
+            }
+
+            int minutes = 0;
+            if (offsetText.Length - startIndex > 5)
+            {
+                if (ConvertUtils.Int32TryParse(offsetText.Chars, startIndex + 3, 2, out minutes) != ParseResult.Success)
+                {
+                    offset = default;
+                    return false;
+                }
+            }
+
+            offset = TimeSpan.FromHours(hours) + TimeSpan.FromMinutes(minutes);
+            if (negative)
+            {
+                offset = offset.Negate();
+            }
+
+            return true;
+        }
+        #endregion
+
+        #region Write
+        internal static void WriteDateTimeString(TextWriter writer, DateTime value, DateFormatHandling format, string? formatString, CultureInfo culture)
+        {
+            if (StringUtils.IsNullOrEmpty(formatString))
+            {
+                char[] chars = new char[64];
+                int pos = WriteDateTimeString(chars, 0, value, null, value.Kind, format);
+                writer.Write(chars, 0, pos);
+            }
+            else
+            {
+                writer.Write(value.ToString(formatString, culture));
+            }
+        }
+
+        internal static int WriteDateTimeString(char[] chars, int start, DateTime value, TimeSpan? offset, DateTimeKind kind, DateFormatHandling format)
+        {
+            int pos = start;
+
+            if (format == DateFormatHandling.MicrosoftDateFormat)
+            {
+                TimeSpan o = offset ?? value.GetUtcOffset();
+
+                long javaScriptTicks = ConvertDateTimeToJavaScriptTicks(value, o);
+
+                @"\/Date(".CopyTo(0, chars, pos, 7);
+                pos += 7;
+
+                string ticksText = javaScriptTicks.ToString(CultureInfo.InvariantCulture);
+                ticksText.CopyTo(0, chars, pos, ticksText.Length);
+                pos += ticksText.Length;
+
+                switch (kind)
+                {
+                    case DateTimeKind.Unspecified:
+                        if (value != DateTime.MaxValue && value != DateTime.MinValue)
+                        {
+                            pos = WriteDateTimeOffset(chars, pos, o, format);
+                        }
+                        break;
+                    case DateTimeKind.Local:
+                        pos = WriteDateTimeOffset(chars, pos, o, format);
+                        break;
+                }
+
+                @")\/".CopyTo(0, chars, pos, 3);
+                pos += 3;
+            }
+            else
+            {
+                pos = WriteDefaultIsoDate(chars, pos, value);
+
+                switch (kind)
+                {
+                    case DateTimeKind.Local:
+                        pos = WriteDateTimeOffset(chars, pos, offset ?? value.GetUtcOffset(), format);
+                        break;
+                    case DateTimeKind.Utc:
+                        chars[pos++] = 'Z';
+                        break;
+                }
+            }
+
+            return pos;
+        }
+
+        internal static int WriteDefaultIsoDate(char[] chars, int start, DateTime dt)
+        {
+            int length = 19;
+
+            GetDateValues(dt, out int year, out int month, out int day);
+
+            CopyIntToCharArray(chars, start, year, 4);
+            chars[start + 4] = '-';
+            CopyIntToCharArray(chars, start + 5, month, 2);
+            chars[start + 7] = '-';
+            CopyIntToCharArray(chars, start + 8, day, 2);
+            chars[start + 10] = 'T';
+            CopyIntToCharArray(chars, start + 11, dt.Hour, 2);
+            chars[start + 13] = ':';
+            CopyIntToCharArray(chars, start + 14, dt.Minute, 2);
+            chars[start + 16] = ':';
+            CopyIntToCharArray(chars, start + 17, dt.Second, 2);
+
+            int fraction = (int)(dt.Ticks % 10000000L);
+
+            if (fraction != 0)
+            {
+                int digits = 7;
+                while ((fraction % 10) == 0)
+                {
+                    digits--;
+                    fraction /= 10;
+                }
+
+                chars[start + 19] = '.';
+                CopyIntToCharArray(chars, start + 20, fraction, digits);
+
+                length += digits + 1;
+            }
+
+            return start + length;
+        }
+
+        private static void CopyIntToCharArray(char[] chars, int start, int value, int digits)
+        {
+            while (digits-- != 0)
+            {
+                chars[start + digits] = (char)((value % 10) + 48);
+                value /= 10;
+            }
+        }
+
+        internal static int WriteDateTimeOffset(char[] chars, int start, TimeSpan offset, DateFormatHandling format)
+        {
+            chars[start++] = (offset.Ticks >= 0L) ? '+' : '-';
+
+            int absHours = Math.Abs(offset.Hours);
+            CopyIntToCharArray(chars, start, absHours, 2);
+            start += 2;
+
+            if (format == DateFormatHandling.IsoDateFormat)
+            {
+                chars[start++] = ':';
+            }
+
+            int absMinutes = Math.Abs(offset.Minutes);
+            CopyIntToCharArray(chars, start, absMinutes, 2);
+            start += 2;
+
+            return start;
+        }
+
+#if HAVE_DATE_TIME_OFFSET
+        internal static void WriteDateTimeOffsetString(TextWriter writer, DateTimeOffset value, DateFormatHandling format, string? formatString, CultureInfo culture)
+        {
+            if (StringUtils.IsNullOrEmpty(formatString))
+            {
+                char[] chars = new char[64];
+                int pos = WriteDateTimeString(chars, 0, (format == DateFormatHandling.IsoDateFormat) ? value.DateTime : value.UtcDateTime, value.Offset, DateTimeKind.Local, format);
+
+                writer.Write(chars, 0, pos);
+            }
+            else
+            {
+                writer.Write(value.ToString(formatString, culture));
+            }
+        }
+#endif
+        #endregion
+
+        private static void GetDateValues(DateTime td, out int year, out int month, out int day)
+        {
+            long ticks = td.Ticks;
+            // n = number of days since 1/1/0001
+            int n = (int)(ticks / TicksPerDay);
+            // y400 = number of whole 400-year periods since 1/1/0001
+            int y400 = n / DaysPer400Years;
+            // n = day number within 400-year period
+            n -= y400 * DaysPer400Years;
+            // y100 = number of whole 100-year periods within 400-year period
+            int y100 = n / DaysPer100Years;
+            // Last 100-year period has an extra day, so decrement result if 4
+            if (y100 == 4)
+            {
+                y100 = 3;
+            }
+            // n = day number within 100-year period
+            n -= y100 * DaysPer100Years;
+            // y4 = number of whole 4-year periods within 100-year period
+            int y4 = n / DaysPer4Years;
+            // n = day number within 4-year period
+            n -= y4 * DaysPer4Years;
+            // y1 = number of whole years within 4-year period
+            int y1 = n / DaysPerYear;
+            // Last year has an extra day, so decrement result if 4
+            if (y1 == 4)
+            {
+                y1 = 3;
+            }
+
+            year = y400 * 400 + y100 * 100 + y4 * 4 + y1 + 1;
+
+            // n = day number within year
+            n -= y1 * DaysPerYear;
+
+            // Leap year calculation looks different from IsLeapYear since y1, y4,
+            // and y100 are relative to year 1, not year 0
+            bool leapYear = y1 == 3 && (y4 != 24 || y100 == 3);
+            int[] days = leapYear ? DaysToMonth366 : DaysToMonth365;
+            // All months have less than 32 days, so n >> 5 is a good conservative
+            // estimate for the month
+            int m = n >> 5 + 1;
+            // m = 1-based month number
+            while (n >= days[m])
+            {
+                m++;
+            }
+
+            month = m;
+
+            // Return 1-based day-of-month
+            day = n - days[m - 1] + 1;
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Utilities/DictionaryWrapper.cs b/Libs/Newtonsoft.Json/Utilities/DictionaryWrapper.cs
new file mode 100644
index 0000000..6120a0b
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/DictionaryWrapper.cs
@@ -0,0 +1,719 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections;
+using System.Threading;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal interface IWrappedDictionary
+        : IDictionary
+    {
+        object UnderlyingDictionary { get; }
+    }
+
+    internal class DictionaryWrapper<TKey, TValue> : IDictionary<TKey, TValue>, IWrappedDictionary
+    {
+        private readonly IDictionary? _dictionary;
+        private readonly IDictionary<TKey, TValue>? _genericDictionary;
+#if HAVE_READ_ONLY_COLLECTIONS
+        private readonly IReadOnlyDictionary<TKey, TValue>? _readOnlyDictionary;
+#endif
+        private object? _syncRoot;
+
+        public DictionaryWrapper(IDictionary dictionary)
+        {
+            ValidationUtils.ArgumentNotNull(dictionary, nameof(dictionary));
+
+            _dictionary = dictionary;
+        }
+
+        public DictionaryWrapper(IDictionary<TKey, TValue> dictionary)
+        {
+            ValidationUtils.ArgumentNotNull(dictionary, nameof(dictionary));
+
+            _genericDictionary = dictionary;
+        }
+
+#if HAVE_READ_ONLY_COLLECTIONS
+        public DictionaryWrapper(IReadOnlyDictionary<TKey, TValue> dictionary)
+        {
+            ValidationUtils.ArgumentNotNull(dictionary, nameof(dictionary));
+
+            _readOnlyDictionary = dictionary;
+        }
+#endif
+
+        internal IDictionary<TKey, TValue> GenericDictionary
+        {
+            get
+            {
+                MiscellaneousUtils.Assert(_genericDictionary != null);
+                return _genericDictionary;
+            }
+        }
+
+        public void Add(TKey key, TValue value)
+        {
+            if (_dictionary != null)
+            {
+                _dictionary.Add(key, value);
+            }
+            else if (_genericDictionary != null)
+            {
+                _genericDictionary.Add(key, value);
+            }
+            else
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public bool ContainsKey(TKey key)
+        {
+            if (_dictionary != null)
+            {
+                return _dictionary.Contains(key);
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                return _readOnlyDictionary.ContainsKey(key);
+            }
+#endif
+            else
+            {
+                return GenericDictionary.ContainsKey(key);
+            }
+        }
+
+        public ICollection<TKey> Keys
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return _dictionary.Keys.Cast<TKey>().ToList();
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary.Keys.ToList();
+                }
+#endif
+                else
+                {
+                    return GenericDictionary.Keys;
+                }
+            }
+        }
+
+        public bool Remove(TKey key)
+        {
+            if (_dictionary != null)
+            {
+                if (_dictionary.Contains(key))
+                {
+                    _dictionary.Remove(key);
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                return GenericDictionary.Remove(key);
+            }
+        }
+
+#pragma warning disable CS8767 // Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
+        public bool TryGetValue(TKey key, out TValue? value)
+#pragma warning restore CS8767 // Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
+        {
+            if (_dictionary != null)
+            {
+                if (!_dictionary.Contains(key))
+                {
+#pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
+                    value = default;
+#pragma warning restore CS8653 // A default expression introduces a null value for a type parameter.
+                    return false;
+                }
+                else
+                {
+                    value = (TValue)_dictionary[key];
+                    return true;
+                }
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                return GenericDictionary.TryGetValue(key, out value);
+            }
+        }
+
+        public ICollection<TValue> Values
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return _dictionary.Values.Cast<TValue>().ToList();
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary.Values.ToList();
+                }
+#endif
+                else
+                {
+                    return GenericDictionary.Values;
+                }
+            }
+        }
+
+        public TValue this[TKey key]
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return (TValue)_dictionary[key];
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary[key];
+                }
+#endif
+                else
+                {
+                    return GenericDictionary[key];
+                }
+            }
+            set
+            {
+                if (_dictionary != null)
+                {
+                    _dictionary[key] = value;
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    throw new NotSupportedException();
+                }
+#endif
+                else
+                {
+                    GenericDictionary[key] = value;
+                }
+            }
+        }
+
+        public void Add(KeyValuePair<TKey, TValue> item)
+        {
+            if (_dictionary != null)
+            {
+                ((IList)_dictionary).Add(item);
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                _genericDictionary?.Add(item);
+            }
+        }
+
+        public void Clear()
+        {
+            if (_dictionary != null)
+            {
+                _dictionary.Clear();
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                GenericDictionary.Clear();
+            }
+        }
+
+        public bool Contains(KeyValuePair<TKey, TValue> item)
+        {
+            if (_dictionary != null)
+            {
+                return ((IList)_dictionary).Contains(item);
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                return _readOnlyDictionary.Contains(item);
+            }
+#endif
+            else
+            {
+                return GenericDictionary.Contains(item);
+            }
+        }
+
+        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            if (_dictionary != null)
+            {
+                // Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
+                IDictionaryEnumerator e = _dictionary.GetEnumerator();
+                try
+                {
+                    while (e.MoveNext())
+                    {
+                        DictionaryEntry entry = e.Entry;
+                        array[arrayIndex++] = new KeyValuePair<TKey, TValue>((TKey)entry.Key, (TValue)entry.Value);
+                    }
+                }
+                finally
+                {
+                    (e as IDisposable)?.Dispose();
+                }
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                GenericDictionary.CopyTo(array, arrayIndex);
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return _dictionary.Count;
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary.Count;
+                }
+#endif
+                else
+                {
+                    return GenericDictionary.Count;
+                }
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return _dictionary.IsReadOnly;
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return true;
+                }
+#endif
+                else
+                {
+                    return GenericDictionary.IsReadOnly;
+                }
+            }
+        }
+
+        public bool Remove(KeyValuePair<TKey, TValue> item)
+        {
+            if (_dictionary != null)
+            {
+                if (_dictionary.Contains(item.Key))
+                {
+                    object value = _dictionary[item.Key];
+
+                    if (Equals(value, item.Value))
+                    {
+                        _dictionary.Remove(item.Key);
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    return true;
+                }
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                return GenericDictionary.Remove(item);
+            }
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            if (_dictionary != null)
+            {
+                return _dictionary.Cast<DictionaryEntry>().Select(de => new KeyValuePair<TKey, TValue>((TKey)de.Key, (TValue)de.Value)).GetEnumerator();
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                return _readOnlyDictionary.GetEnumerator();
+            }
+#endif
+            else
+            {
+                return GenericDictionary.GetEnumerator();
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        void IDictionary.Add(object key, object value)
+        {
+            if (_dictionary != null)
+            {
+                _dictionary.Add(key, value);
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                GenericDictionary.Add((TKey)key, (TValue)value);
+            }
+        }
+
+        object? IDictionary.this[object key]
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return _dictionary[key];
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary[(TKey)key];
+                }
+#endif
+                else
+                {
+                    return GenericDictionary[(TKey)key];
+                }
+            }
+            set
+            {
+                if (_dictionary != null)
+                {
+                    _dictionary[key] = value;
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    throw new NotSupportedException();
+                }
+#endif
+                else
+                {
+                    // Consider changing this code to call GenericDictionary.Remove when value is null.
+                    //
+#pragma warning disable CS8601 // Possible null reference assignment.
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+                    GenericDictionary[(TKey)key] = (TValue)value;
+#pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type.
+#pragma warning restore CS8601 // Possible null reference assignment.
+                }
+            }
+        }
+
+        private readonly struct DictionaryEnumerator<TEnumeratorKey, TEnumeratorValue> : IDictionaryEnumerator
+        {
+            private readonly IEnumerator<KeyValuePair<TEnumeratorKey, TEnumeratorValue>> _e;
+
+            public DictionaryEnumerator(IEnumerator<KeyValuePair<TEnumeratorKey, TEnumeratorValue>> e)
+            {
+                ValidationUtils.ArgumentNotNull(e, nameof(e));
+                _e = e;
+            }
+
+            public DictionaryEntry Entry => (DictionaryEntry)Current;
+
+            public object Key => Entry.Key;
+
+            public object Value => Entry.Value;
+
+            public object Current => new DictionaryEntry(_e.Current.Key, _e.Current.Value);
+
+            public bool MoveNext()
+            {
+                return _e.MoveNext();
+            }
+
+            public void Reset()
+            {
+                _e.Reset();
+            }
+        }
+
+        IDictionaryEnumerator IDictionary.GetEnumerator()
+        {
+            if (_dictionary != null)
+            {
+                return _dictionary.GetEnumerator();
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                return new DictionaryEnumerator<TKey, TValue>(_readOnlyDictionary.GetEnumerator());
+            }
+#endif
+            else
+            {
+                return new DictionaryEnumerator<TKey, TValue>(GenericDictionary.GetEnumerator());
+            }
+        }
+
+        bool IDictionary.Contains(object key)
+        {
+            if (_genericDictionary != null)
+            {
+                return _genericDictionary.ContainsKey((TKey)key);
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                return _readOnlyDictionary.ContainsKey((TKey)key);
+            }
+#endif
+            else
+            {
+                return _dictionary!.Contains(key);
+            }
+        }
+
+        bool IDictionary.IsFixedSize
+        {
+            get
+            {
+                if (_genericDictionary != null)
+                {
+                    return false;
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return true;
+                }
+#endif
+                else
+                {
+                    return _dictionary!.IsFixedSize;
+                }
+            }
+        }
+
+        ICollection IDictionary.Keys
+        {
+            get
+            {
+                if (_genericDictionary != null)
+                {
+                    return _genericDictionary.Keys.ToList();
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary.Keys.ToList();
+                }
+#endif
+                else
+                {
+                    return _dictionary!.Keys;
+                }
+            }
+        }
+
+        public void Remove(object key)
+        {
+            if (_dictionary != null)
+            {
+                _dictionary.Remove(key);
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                GenericDictionary.Remove((TKey)key);
+            }
+        }
+
+        ICollection IDictionary.Values
+        {
+            get
+            {
+                if (_genericDictionary != null)
+                {
+                    return _genericDictionary.Values.ToList();
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary.Values.ToList();
+                }
+#endif
+                else
+                {
+                    return _dictionary!.Values;
+                }
+            }
+        }
+
+        void ICollection.CopyTo(Array array, int index)
+        {
+            if (_dictionary != null)
+            {
+                _dictionary.CopyTo(array, index);
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (_readOnlyDictionary != null)
+            {
+                throw new NotSupportedException();
+            }
+#endif
+            else
+            {
+                GenericDictionary.CopyTo((KeyValuePair<TKey, TValue>[])array, index);
+            }
+        }
+
+        bool ICollection.IsSynchronized
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return _dictionary.IsSynchronized;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+
+        object ICollection.SyncRoot
+        {
+            get
+            {
+                if (_syncRoot == null)
+                {
+                    Interlocked.CompareExchange(ref _syncRoot, new object(), null);
+                }
+
+                return _syncRoot;
+            }
+        }
+
+        public object UnderlyingDictionary
+        {
+            get
+            {
+                if (_dictionary != null)
+                {
+                    return _dictionary;
+                }
+#if HAVE_READ_ONLY_COLLECTIONS
+                else if (_readOnlyDictionary != null)
+                {
+                    return _readOnlyDictionary;
+                }
+#endif
+                else
+                {
+                    return GenericDictionary;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/DynamicProxy.cs b/Libs/Newtonsoft.Json/Utilities/DynamicProxy.cs
new file mode 100644
index 0000000..7a2ab75
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/DynamicProxy.cs
@@ -0,0 +1,109 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_DYNAMIC
+using System.Collections.Generic;
+using System.Dynamic;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class DynamicProxy<T>
+    {
+        public virtual IEnumerable<string> GetDynamicMemberNames(T instance)
+        {
+            return CollectionUtils.ArrayEmpty<string>();
+        }
+
+        public virtual bool TryBinaryOperation(T instance, BinaryOperationBinder binder, object arg, out object? result)
+        {
+            result = null;
+            return false;
+        }
+
+        public virtual bool TryConvert(T instance, ConvertBinder binder, out object? result)
+        {
+            result = null;
+            return false;
+        }
+
+        public virtual bool TryCreateInstance(T instance, CreateInstanceBinder binder, object[] args, out object? result)
+        {
+            result = null;
+            return false;
+        }
+
+        public virtual bool TryDeleteIndex(T instance, DeleteIndexBinder binder, object[] indexes)
+        {
+            return false;
+        }
+
+        public virtual bool TryDeleteMember(T instance, DeleteMemberBinder binder)
+        {
+            return false;
+        }
+
+        public virtual bool TryGetIndex(T instance, GetIndexBinder binder, object[] indexes, out object? result)
+        {
+            result = null;
+            return false;
+        }
+
+        public virtual bool TryGetMember(T instance, GetMemberBinder binder, out object? result)
+        {
+            result = null;
+            return false;
+        }
+
+        public virtual bool TryInvoke(T instance, InvokeBinder binder, object[] args, out object? result)
+        {
+            result = null;
+            return false;
+        }
+
+        public virtual bool TryInvokeMember(T instance, InvokeMemberBinder binder, object[] args, out object? result)
+        {
+            result = null;
+            return false;
+        }
+
+        public virtual bool TrySetIndex(T instance, SetIndexBinder binder, object[] indexes, object value)
+        {
+            return false;
+        }
+
+        public virtual bool TrySetMember(T instance, SetMemberBinder binder, object value)
+        {
+            return false;
+        }
+
+        public virtual bool TryUnaryOperation(T instance, UnaryOperationBinder binder, out object? result)
+        {
+            result = null;
+            return false;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/DynamicProxyMetaObject.cs b/Libs/Newtonsoft.Json/Utilities/DynamicProxyMetaObject.cs
new file mode 100644
index 0000000..7b3952e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/DynamicProxyMetaObject.cs
@@ -0,0 +1,391 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_DYNAMIC
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal sealed class DynamicProxyMetaObject<T> : DynamicMetaObject
+    {
+        private readonly DynamicProxy<T> _proxy;
+
+        internal DynamicProxyMetaObject(Expression expression, T value, DynamicProxy<T> proxy)
+            : base(expression, BindingRestrictions.Empty, value)
+        {
+            _proxy = proxy;
+        }
+
+        private bool IsOverridden(string method)
+        {
+            return ReflectionUtils.IsMethodOverridden(_proxy.GetType(), typeof(DynamicProxy<T>), method);
+        }
+
+        public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryGetMember))
+                ? CallMethodWithResult(nameof(DynamicProxy<T>.TryGetMember), binder, NoArgs, e => binder.FallbackGetMember(this, e))
+                : base.BindGetMember(binder);
+        }
+
+        public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TrySetMember))
+                ? CallMethodReturnLast(nameof(DynamicProxy<T>.TrySetMember), binder, GetArgs(value), e => binder.FallbackSetMember(this, value, e))
+                : base.BindSetMember(binder, value);
+        }
+
+        public override DynamicMetaObject BindDeleteMember(DeleteMemberBinder binder)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryDeleteMember))
+                ? CallMethodNoResult(nameof(DynamicProxy<T>.TryDeleteMember), binder, NoArgs, e => binder.FallbackDeleteMember(this, e))
+                : base.BindDeleteMember(binder);
+        }
+
+        public override DynamicMetaObject BindConvert(ConvertBinder binder)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryConvert))
+                ? CallMethodWithResult(nameof(DynamicProxy<T>.TryConvert), binder, NoArgs, e => binder.FallbackConvert(this, e))
+                : base.BindConvert(binder);
+        }
+
+        public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
+        {
+            if (!IsOverridden(nameof(DynamicProxy<T>.TryInvokeMember)))
+            {
+                return base.BindInvokeMember(binder, args);
+            }
+
+            //
+            // Generate a tree like:
+            //
+            // {
+            //   object result;
+            //   TryInvokeMember(payload, out result)
+            //      ? result
+            //      : TryGetMember(payload, out result)
+            //          ? FallbackInvoke(result)
+            //          : fallbackResult
+            // }
+            //
+            // Then it calls FallbackInvokeMember with this tree as the
+            // "error", giving the language the option of using this
+            // tree or doing .NET binding.
+            //
+            Fallback fallback = e => binder.FallbackInvokeMember(this, args, e);
+
+            return BuildCallMethodWithResult(
+                nameof(DynamicProxy<T>.TryInvokeMember),
+                binder,
+                GetArgArray(args),
+                BuildCallMethodWithResult(
+                    nameof(DynamicProxy<T>.TryGetMember),
+                    new GetBinderAdapter(binder),
+                    NoArgs,
+                    fallback(null),
+                    e => binder.FallbackInvoke(e, args, null)
+                    ),
+                null
+                );
+        }
+
+        public override DynamicMetaObject BindCreateInstance(CreateInstanceBinder binder, DynamicMetaObject[] args)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryCreateInstance))
+                ? CallMethodWithResult(nameof(DynamicProxy<T>.TryCreateInstance), binder, GetArgArray(args), e => binder.FallbackCreateInstance(this, args, e))
+                : base.BindCreateInstance(binder, args);
+        }
+
+        public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryInvoke))
+                ? CallMethodWithResult(nameof(DynamicProxy<T>.TryInvoke), binder, GetArgArray(args), e => binder.FallbackInvoke(this, args, e))
+                : base.BindInvoke(binder, args);
+        }
+
+        public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryBinaryOperation))
+                ? CallMethodWithResult(nameof(DynamicProxy<T>.TryBinaryOperation), binder, GetArgs(arg), e => binder.FallbackBinaryOperation(this, arg, e))
+                : base.BindBinaryOperation(binder, arg);
+        }
+
+        public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryUnaryOperation))
+                ? CallMethodWithResult(nameof(DynamicProxy<T>.TryUnaryOperation), binder, NoArgs, e => binder.FallbackUnaryOperation(this, e))
+                : base.BindUnaryOperation(binder);
+        }
+
+        public override DynamicMetaObject BindGetIndex(GetIndexBinder binder, DynamicMetaObject[] indexes)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryGetIndex))
+                ? CallMethodWithResult(nameof(DynamicProxy<T>.TryGetIndex), binder, GetArgArray(indexes), e => binder.FallbackGetIndex(this, indexes, e))
+                : base.BindGetIndex(binder, indexes);
+        }
+
+        public override DynamicMetaObject BindSetIndex(SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TrySetIndex))
+                ? CallMethodReturnLast(nameof(DynamicProxy<T>.TrySetIndex), binder, GetArgArray(indexes, value), e => binder.FallbackSetIndex(this, indexes, value, e))
+                : base.BindSetIndex(binder, indexes, value);
+        }
+
+        public override DynamicMetaObject BindDeleteIndex(DeleteIndexBinder binder, DynamicMetaObject[] indexes)
+        {
+            return IsOverridden(nameof(DynamicProxy<T>.TryDeleteIndex))
+                ? CallMethodNoResult(nameof(DynamicProxy<T>.TryDeleteIndex), binder, GetArgArray(indexes), e => binder.FallbackDeleteIndex(this, indexes, e))
+                : base.BindDeleteIndex(binder, indexes);
+        }
+
+        private delegate DynamicMetaObject Fallback(DynamicMetaObject? errorSuggestion);
+
+        private static Expression[] NoArgs => CollectionUtils.ArrayEmpty<Expression>();
+
+        private static IEnumerable<Expression> GetArgs(params DynamicMetaObject[] args)
+        {
+            return args.Select(arg =>
+            {
+                Expression exp = arg.Expression;
+                return exp.Type.IsValueType() ? Expression.Convert(exp, typeof(object)) : exp;
+            });
+        }
+
+        private static Expression[] GetArgArray(DynamicMetaObject[] args)
+        {
+            return new[] { Expression.NewArrayInit(typeof(object), GetArgs(args)) };
+        }
+
+        private static Expression[] GetArgArray(DynamicMetaObject[] args, DynamicMetaObject value)
+        {
+            Expression exp = value.Expression;
+            return new[]
+            {
+                Expression.NewArrayInit(typeof(object), GetArgs(args)),
+                exp.Type.IsValueType() ? Expression.Convert(exp, typeof(object)) : exp
+            };
+        }
+
+        private static ConstantExpression Constant(DynamicMetaObjectBinder binder)
+        {
+            Type t = binder.GetType();
+            while (!t.IsVisible())
+            {
+                t = t.BaseType();
+            }
+            return Expression.Constant(binder, t);
+        }
+
+        /// <summary>
+        /// Helper method for generating a MetaObject which calls a
+        /// specific method on Dynamic that returns a result
+        /// </summary>
+        private DynamicMetaObject CallMethodWithResult(string methodName, DynamicMetaObjectBinder binder, IEnumerable<Expression> args, Fallback fallback, Fallback? fallbackInvoke = null)
+        {
+            //
+            // First, call fallback to do default binding
+            // This produces either an error or a call to a .NET member
+            //
+            DynamicMetaObject fallbackResult = fallback(null);
+
+            return BuildCallMethodWithResult(methodName, binder, args, fallbackResult, fallbackInvoke);
+        }
+
+        private DynamicMetaObject BuildCallMethodWithResult(string methodName, DynamicMetaObjectBinder binder, IEnumerable<Expression> args, DynamicMetaObject fallbackResult, Fallback? fallbackInvoke)
+        {
+            //
+            // Build a new expression like:
+            // {
+            //   object result;
+            //   TryGetMember(payload, out result) ? fallbackInvoke(result) : fallbackResult
+            // }
+            //
+            ParameterExpression result = Expression.Parameter(typeof(object), null);
+
+            IList<Expression> callArgs = new List<Expression>();
+            callArgs.Add(Expression.Convert(Expression, typeof(T)));
+            callArgs.Add(Constant(binder));
+            callArgs.AddRange(args);
+            callArgs.Add(result);
+
+            DynamicMetaObject resultMetaObject = new DynamicMetaObject(result, BindingRestrictions.Empty);
+
+            // Need to add a conversion if calling TryConvert
+            if (binder.ReturnType != typeof(object))
+            {
+                UnaryExpression convert = Expression.Convert(resultMetaObject.Expression, binder.ReturnType);
+                // will always be a cast or unbox
+
+                resultMetaObject = new DynamicMetaObject(convert, resultMetaObject.Restrictions);
+            }
+
+            if (fallbackInvoke != null)
+            {
+                resultMetaObject = fallbackInvoke(resultMetaObject);
+            }
+
+            DynamicMetaObject callDynamic = new DynamicMetaObject(
+                Expression.Block(
+                    new[] { result },
+                    Expression.Condition(
+                        Expression.Call(
+                            Expression.Constant(_proxy),
+                            typeof(DynamicProxy<T>).GetMethod(methodName),
+                            callArgs
+                            ),
+                        resultMetaObject.Expression,
+                        fallbackResult.Expression,
+                        binder.ReturnType
+                        )
+                    ),
+                GetRestrictions().Merge(resultMetaObject.Restrictions).Merge(fallbackResult.Restrictions)
+                );
+
+            return callDynamic;
+        }
+
+        /// <summary>
+        /// Helper method for generating a MetaObject which calls a
+        /// specific method on Dynamic, but uses one of the arguments for
+        /// the result.
+        /// </summary>
+        private DynamicMetaObject CallMethodReturnLast(string methodName, DynamicMetaObjectBinder binder, IEnumerable<Expression> args, Fallback fallback)
+        {
+            //
+            // First, call fallback to do default binding
+            // This produces either an error or a call to a .NET member
+            //
+            DynamicMetaObject fallbackResult = fallback(null);
+
+            //
+            // Build a new expression like:
+            // {
+            //   object result;
+            //   TrySetMember(payload, result = value) ? result : fallbackResult
+            // }
+            //
+            ParameterExpression result = Expression.Parameter(typeof(object), null);
+
+            IList<Expression> callArgs = new List<Expression>();
+            callArgs.Add(Expression.Convert(Expression, typeof(T)));
+            callArgs.Add(Constant(binder));
+            callArgs.AddRange(args);
+            callArgs[callArgs.Count - 1] = Expression.Assign(result, callArgs[callArgs.Count - 1]);
+
+            return new DynamicMetaObject(
+                Expression.Block(
+                    new[] { result },
+                    Expression.Condition(
+                        Expression.Call(
+                            Expression.Constant(_proxy),
+                            typeof(DynamicProxy<T>).GetMethod(methodName),
+                            callArgs
+                            ),
+                        result,
+                        fallbackResult.Expression,
+                        typeof(object)
+                        )
+                    ),
+                GetRestrictions().Merge(fallbackResult.Restrictions)
+                );
+        }
+
+        /// <summary>
+        /// Helper method for generating a MetaObject which calls a
+        /// specific method on Dynamic, but uses one of the arguments for
+        /// the result.
+        /// </summary>
+        private DynamicMetaObject CallMethodNoResult(string methodName, DynamicMetaObjectBinder binder, Expression[] args, Fallback fallback)
+        {
+            //
+            // First, call fallback to do default binding
+            // This produces either an error or a call to a .NET member
+            //
+            DynamicMetaObject fallbackResult = fallback(null);
+
+            IList<Expression> callArgs = new List<Expression>();
+            callArgs.Add(Expression.Convert(Expression, typeof(T)));
+            callArgs.Add(Constant(binder));
+            callArgs.AddRange(args);
+
+            //
+            // Build a new expression like:
+            //   if (TryDeleteMember(payload)) { } else { fallbackResult }
+            //
+            return new DynamicMetaObject(
+                Expression.Condition(
+                    Expression.Call(
+                        Expression.Constant(_proxy),
+                        typeof(DynamicProxy<T>).GetMethod(methodName),
+                        callArgs
+                        ),
+                    Expression.Empty(),
+                    fallbackResult.Expression,
+                    typeof(void)
+                    ),
+                GetRestrictions().Merge(fallbackResult.Restrictions)
+                );
+        }
+
+        /// <summary>
+        /// Returns a Restrictions object which includes our current restrictions merged
+        /// with a restriction limiting our type
+        /// </summary>
+        private BindingRestrictions GetRestrictions()
+        {
+            return (Value == null && HasValue)
+                ? BindingRestrictions.GetInstanceRestriction(Expression, null)
+                : BindingRestrictions.GetTypeRestriction(Expression, LimitType);
+        }
+
+        public override IEnumerable<string> GetDynamicMemberNames()
+        {
+            return _proxy.GetDynamicMemberNames((T)Value);
+        }
+
+        // It is okay to throw NotSupported from this binder. This object
+        // is only used by DynamicObject.GetMember--it is not expected to
+        // (and cannot) implement binding semantics. It is just so the DO
+        // can use the Name and IgnoreCase properties.
+        private sealed class GetBinderAdapter : GetMemberBinder
+        {
+            internal GetBinderAdapter(InvokeMemberBinder binder) :
+                base(binder.Name, binder.IgnoreCase)
+            {
+            }
+
+            public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion)
+            {
+                throw new NotSupportedException();
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs b/Libs/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs
new file mode 100644
index 0000000..0006d08
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs
@@ -0,0 +1,404 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_REFLECTION_EMIT
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+using System.Reflection;
+using System.Reflection.Emit;
+using LC.Newtonsoft.Json.Serialization;
+using System.Globalization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class DynamicReflectionDelegateFactory : ReflectionDelegateFactory
+    {
+        internal static DynamicReflectionDelegateFactory Instance { get; } = new DynamicReflectionDelegateFactory();
+
+        private static DynamicMethod CreateDynamicMethod(string name, Type? returnType, Type[] parameterTypes, Type owner)
+        {
+            DynamicMethod dynamicMethod = !owner.IsInterface()
+                ? new DynamicMethod(name, returnType, parameterTypes, owner, true)
+                : new DynamicMethod(name, returnType, parameterTypes, owner.Module, true);
+
+            return dynamicMethod;
+        }
+
+        public override ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)
+        {
+            DynamicMethod dynamicMethod = CreateDynamicMethod(method.ToString(), typeof(object), new[] { typeof(object[]) }, method.DeclaringType);
+            ILGenerator generator = dynamicMethod.GetILGenerator();
+
+            GenerateCreateMethodCallIL(method, generator, 0);
+            
+            return (ObjectConstructor<object>)dynamicMethod.CreateDelegate(typeof(ObjectConstructor<object>));
+        }
+
+        public override MethodCall<T, object?> CreateMethodCall<T>(MethodBase method)
+        {
+            DynamicMethod dynamicMethod = CreateDynamicMethod(method.ToString(), typeof(object), new[] { typeof(object), typeof(object[]) }, method.DeclaringType);
+            ILGenerator generator = dynamicMethod.GetILGenerator();
+
+            GenerateCreateMethodCallIL(method, generator, 1);
+
+            return (MethodCall<T, object?>)dynamicMethod.CreateDelegate(typeof(MethodCall<T, object?>));
+        }
+
+        private void GenerateCreateMethodCallIL(MethodBase method, ILGenerator generator, int argsIndex)
+        {
+            ParameterInfo[] args = method.GetParameters();
+
+            Label argsOk = generator.DefineLabel();
+
+            // throw an error if the number of argument values doesn't match method parameters
+            generator.Emit(OpCodes.Ldarg, argsIndex);
+            generator.Emit(OpCodes.Ldlen);
+            generator.Emit(OpCodes.Ldc_I4, args.Length);
+            generator.Emit(OpCodes.Beq, argsOk);
+            generator.Emit(OpCodes.Newobj, typeof(TargetParameterCountException).GetConstructor(ReflectionUtils.EmptyTypes));
+            generator.Emit(OpCodes.Throw);
+
+            generator.MarkLabel(argsOk);
+
+            if (!method.IsConstructor && !method.IsStatic)
+            {
+                generator.PushInstance(method.DeclaringType);
+            }
+
+            LocalBuilder localConvertible = generator.DeclareLocal(typeof(IConvertible));
+            LocalBuilder localObject = generator.DeclareLocal(typeof(object));
+
+            OpCode variableAddressOpCode = args.Length < 256 ? OpCodes.Ldloca_S : OpCodes.Ldloca;
+            OpCode variableLoadOpCode = args.Length < 256 ? OpCodes.Ldloc_S : OpCodes.Ldloc;
+
+            for (int i = 0; i < args.Length; i++)
+            {
+                ParameterInfo parameter = args[i];
+                Type parameterType = parameter.ParameterType;
+
+                if (parameterType.IsByRef)
+                {
+                    parameterType = parameterType.GetElementType();
+
+                    LocalBuilder localVariable = generator.DeclareLocal(parameterType);
+
+                    // don't need to set variable for 'out' parameter
+                    if (!parameter.IsOut)
+                    {
+                        generator.PushArrayInstance(argsIndex, i);
+
+                        if (parameterType.IsValueType())
+                        {
+                            Label skipSettingDefault = generator.DefineLabel();
+                            Label finishedProcessingParameter = generator.DefineLabel();
+
+                            // check if parameter is not null
+                            generator.Emit(OpCodes.Brtrue_S, skipSettingDefault);
+
+                            // parameter has no value, initialize to default
+                            generator.Emit(variableAddressOpCode, localVariable);
+                            generator.Emit(OpCodes.Initobj, parameterType);
+                            generator.Emit(OpCodes.Br_S, finishedProcessingParameter);
+
+                            // parameter has value, get value from array again and unbox and set to variable
+                            generator.MarkLabel(skipSettingDefault);
+                            generator.PushArrayInstance(argsIndex, i);
+                            generator.UnboxIfNeeded(parameterType);
+                            generator.Emit(OpCodes.Stloc_S, localVariable);
+
+                            // parameter finished, we out!
+                            generator.MarkLabel(finishedProcessingParameter);
+                        }
+                        else
+                        {
+                            generator.UnboxIfNeeded(parameterType);
+                            generator.Emit(OpCodes.Stloc_S, localVariable);
+                        }
+                    }
+
+                    generator.Emit(variableAddressOpCode, localVariable);
+                }
+                else if (parameterType.IsValueType())
+                {
+                    generator.PushArrayInstance(argsIndex, i);
+                    generator.Emit(OpCodes.Stloc_S, localObject);
+
+                    // have to check that value type parameters aren't null
+                    // otherwise they will error when unboxed
+                    Label skipSettingDefault = generator.DefineLabel();
+                    Label finishedProcessingParameter = generator.DefineLabel();
+
+                    // check if parameter is not null
+                    generator.Emit(OpCodes.Ldloc_S, localObject);
+                    generator.Emit(OpCodes.Brtrue_S, skipSettingDefault);
+
+                    // parameter has no value, initialize to default
+                    LocalBuilder localVariable = generator.DeclareLocal(parameterType);
+                    generator.Emit(variableAddressOpCode, localVariable);
+                    generator.Emit(OpCodes.Initobj, parameterType);
+                    generator.Emit(variableLoadOpCode, localVariable);
+                    generator.Emit(OpCodes.Br_S, finishedProcessingParameter);
+
+                    // argument has value, try to convert it to parameter type
+                    generator.MarkLabel(skipSettingDefault);
+                    
+                    if (parameterType.IsPrimitive())
+                    {
+                        // for primitive types we need to handle type widening (e.g. short -> int)
+                        MethodInfo toParameterTypeMethod = typeof(IConvertible)
+                            .GetMethod("To" + parameterType.Name, new[] { typeof(IFormatProvider) });
+                        
+                        if (toParameterTypeMethod != null)
+                        {
+                            Label skipConvertible = generator.DefineLabel();
+
+                            // check if argument type is an exact match for parameter type
+                            // in this case we may use cheap unboxing instead
+                            generator.Emit(OpCodes.Ldloc_S, localObject);
+                            generator.Emit(OpCodes.Isinst, parameterType);
+                            generator.Emit(OpCodes.Brtrue_S, skipConvertible);
+
+                            // types don't match, check if argument implements IConvertible
+                            generator.Emit(OpCodes.Ldloc_S, localObject);
+                            generator.Emit(OpCodes.Isinst, typeof(IConvertible));
+                            generator.Emit(OpCodes.Stloc_S, localConvertible);
+                            generator.Emit(OpCodes.Ldloc_S, localConvertible);
+                            generator.Emit(OpCodes.Brfalse_S, skipConvertible);
+
+                            // convert argument to parameter type
+                            generator.Emit(OpCodes.Ldloc_S, localConvertible);
+                            generator.Emit(OpCodes.Ldnull);
+                            generator.Emit(OpCodes.Callvirt, toParameterTypeMethod);
+                            generator.Emit(OpCodes.Br_S, finishedProcessingParameter);
+
+                            generator.MarkLabel(skipConvertible);
+                        }
+                    }
+
+                    // we got here because either argument type matches parameter (conversion will succeed),
+                    // or argument type doesn't match parameter, but we're out of options (conversion will fail)
+                    generator.Emit(OpCodes.Ldloc_S, localObject);
+
+                    generator.UnboxIfNeeded(parameterType);
+                    
+                    // parameter finished, we out!
+                    generator.MarkLabel(finishedProcessingParameter);
+                }
+                else
+                {
+                    generator.PushArrayInstance(argsIndex, i);
+
+                    generator.UnboxIfNeeded(parameterType);
+                }
+            }
+
+            if (method.IsConstructor)
+            {
+                generator.Emit(OpCodes.Newobj, (ConstructorInfo)method);
+            }
+            else
+            {
+                generator.CallMethod((MethodInfo)method);
+            }
+
+            Type returnType = method.IsConstructor
+                ? method.DeclaringType
+                : ((MethodInfo)method).ReturnType;
+
+            if (returnType != typeof(void))
+            {
+                generator.BoxIfNeeded(returnType);
+            }
+            else
+            {
+                generator.Emit(OpCodes.Ldnull);
+            }
+
+            generator.Return();
+        }
+
+        public override Func<T> CreateDefaultConstructor<T>(Type type)
+        {
+            DynamicMethod dynamicMethod = CreateDynamicMethod("Create" + type.FullName, typeof(T), ReflectionUtils.EmptyTypes, type);
+            dynamicMethod.InitLocals = true;
+            ILGenerator generator = dynamicMethod.GetILGenerator();
+
+            GenerateCreateDefaultConstructorIL(type, generator, typeof(T));
+
+            return (Func<T>)dynamicMethod.CreateDelegate(typeof(Func<T>));
+        }
+
+        private void GenerateCreateDefaultConstructorIL(Type type, ILGenerator generator, Type delegateType)
+        {
+            if (type.IsValueType())
+            {
+                generator.DeclareLocal(type);
+                generator.Emit(OpCodes.Ldloc_0);
+
+                // only need to box if the delegate isn't returning the value type
+                if (type != delegateType)
+                {
+                    generator.Emit(OpCodes.Box, type);
+                }
+            }
+            else
+            {
+                ConstructorInfo constructorInfo =
+                    type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, ReflectionUtils.EmptyTypes, null);
+
+                if (constructorInfo == null)
+                {
+                    throw new ArgumentException("Could not get constructor for {0}.".FormatWith(CultureInfo.InvariantCulture, type));
+                }
+
+                generator.Emit(OpCodes.Newobj, constructorInfo);
+            }
+
+            generator.Return();
+        }
+
+        public override Func<T, object?> CreateGet<T>(PropertyInfo propertyInfo)
+        {
+            DynamicMethod dynamicMethod = CreateDynamicMethod("Get" + propertyInfo.Name, typeof(object), new[] { typeof(T) }, propertyInfo.DeclaringType);
+            ILGenerator generator = dynamicMethod.GetILGenerator();
+
+            GenerateCreateGetPropertyIL(propertyInfo, generator);
+
+            return (Func<T, object?>)dynamicMethod.CreateDelegate(typeof(Func<T, object?>));
+        }
+
+        private void GenerateCreateGetPropertyIL(PropertyInfo propertyInfo, ILGenerator generator)
+        {
+            MethodInfo getMethod = propertyInfo.GetGetMethod(true);
+            if (getMethod == null)
+            {
+                throw new ArgumentException("Property '{0}' does not have a getter.".FormatWith(CultureInfo.InvariantCulture, propertyInfo.Name));
+            }
+
+            if (!getMethod.IsStatic)
+            {
+                generator.PushInstance(propertyInfo.DeclaringType);
+            }
+
+            generator.CallMethod(getMethod);
+            generator.BoxIfNeeded(propertyInfo.PropertyType);
+            generator.Return();
+        }
+
+        public override Func<T, object?> CreateGet<T>(FieldInfo fieldInfo)
+        {
+            if (fieldInfo.IsLiteral)
+            {
+                object constantValue = fieldInfo.GetValue(null);
+                Func<T, object?> getter = o => constantValue;
+                return getter;
+            }
+
+            DynamicMethod dynamicMethod = CreateDynamicMethod("Get" + fieldInfo.Name, typeof(T), new[] { typeof(object) }, fieldInfo.DeclaringType);
+            ILGenerator generator = dynamicMethod.GetILGenerator();
+
+            GenerateCreateGetFieldIL(fieldInfo, generator);
+
+            return (Func<T, object?>)dynamicMethod.CreateDelegate(typeof(Func<T, object?>));
+        }
+
+        private void GenerateCreateGetFieldIL(FieldInfo fieldInfo, ILGenerator generator)
+        {
+            if (!fieldInfo.IsStatic)
+            {
+                generator.PushInstance(fieldInfo.DeclaringType);
+                generator.Emit(OpCodes.Ldfld, fieldInfo);
+            }
+            else
+            {
+                generator.Emit(OpCodes.Ldsfld, fieldInfo);
+            }
+
+            generator.BoxIfNeeded(fieldInfo.FieldType);
+            generator.Return();
+        }
+
+        public override Action<T, object?> CreateSet<T>(FieldInfo fieldInfo)
+        {
+            DynamicMethod dynamicMethod = CreateDynamicMethod("Set" + fieldInfo.Name, null, new[] { typeof(T), typeof(object) }, fieldInfo.DeclaringType);
+            ILGenerator generator = dynamicMethod.GetILGenerator();
+
+            GenerateCreateSetFieldIL(fieldInfo, generator);
+
+            return (Action<T, object?>)dynamicMethod.CreateDelegate(typeof(Action<T, object?>));
+        }
+
+        internal static void GenerateCreateSetFieldIL(FieldInfo fieldInfo, ILGenerator generator)
+        {
+            if (!fieldInfo.IsStatic)
+            {
+                generator.PushInstance(fieldInfo.DeclaringType);
+            }
+
+            generator.Emit(OpCodes.Ldarg_1);
+            generator.UnboxIfNeeded(fieldInfo.FieldType);
+
+            if (!fieldInfo.IsStatic)
+            {
+                generator.Emit(OpCodes.Stfld, fieldInfo);
+            }
+            else
+            {
+                generator.Emit(OpCodes.Stsfld, fieldInfo);
+            }
+
+            generator.Return();
+        }
+
+        public override Action<T, object?> CreateSet<T>(PropertyInfo propertyInfo)
+        {
+            DynamicMethod dynamicMethod = CreateDynamicMethod("Set" + propertyInfo.Name, null, new[] { typeof(T), typeof(object) }, propertyInfo.DeclaringType);
+            ILGenerator generator = dynamicMethod.GetILGenerator();
+
+            GenerateCreateSetPropertyIL(propertyInfo, generator);
+
+            return (Action<T, object?>)dynamicMethod.CreateDelegate(typeof(Action<T, object>));
+        }
+
+        internal static void GenerateCreateSetPropertyIL(PropertyInfo propertyInfo, ILGenerator generator)
+        {
+            MethodInfo setMethod = propertyInfo.GetSetMethod(true);
+            if (!setMethod.IsStatic)
+            {
+                generator.PushInstance(propertyInfo.DeclaringType);
+            }
+
+            generator.Emit(OpCodes.Ldarg_1);
+            generator.UnboxIfNeeded(propertyInfo.PropertyType);
+            generator.CallMethod(setMethod);
+            generator.Return();
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/DynamicUtils.cs b/Libs/Newtonsoft.Json/Utilities/DynamicUtils.cs
new file mode 100644
index 0000000..8ad9f46
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/DynamicUtils.cs
@@ -0,0 +1,215 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_DYNAMIC
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+#if !HAVE_REFLECTION_BINDER
+using System.Reflection;
+#else
+using Microsoft.CSharp.RuntimeBinder;
+#endif
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Globalization;
+using LC.Newtonsoft.Json.Serialization;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class DynamicUtils
+    {
+        internal static class BinderWrapper
+        {
+#if !HAVE_REFLECTION_BINDER
+            public const string CSharpAssemblyName = "Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";
+
+            private const string BinderTypeName = "Microsoft.CSharp.RuntimeBinder.Binder, " + CSharpAssemblyName;
+            private const string CSharpArgumentInfoTypeName = "Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo, " + CSharpAssemblyName;
+            private const string CSharpArgumentInfoFlagsTypeName = "Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags, " + CSharpAssemblyName;
+            private const string CSharpBinderFlagsTypeName = "Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags, " + CSharpAssemblyName;
+
+            private static object? _getCSharpArgumentInfoArray;
+            private static object? _setCSharpArgumentInfoArray;
+            private static MethodCall<object?, object?>? _getMemberCall;
+            private static MethodCall<object?, object?>? _setMemberCall;
+            private static bool _init;
+
+            private static void Init()
+            {
+                if (!_init)
+                {
+                    Type binderType = Type.GetType(BinderTypeName, false);
+                    if (binderType == null)
+                    {
+                        throw new InvalidOperationException("Could not resolve type '{0}'. You may need to add a reference to Microsoft.CSharp.dll to work with dynamic types.".FormatWith(CultureInfo.InvariantCulture, BinderTypeName));
+                    }
+
+                    // None
+                    _getCSharpArgumentInfoArray = CreateSharpArgumentInfoArray(0);
+                    // None, Constant | UseCompileTimeType
+                    _setCSharpArgumentInfoArray = CreateSharpArgumentInfoArray(0, 3);
+                    CreateMemberCalls();
+
+                    _init = true;
+                }
+            }
+
+            private static object CreateSharpArgumentInfoArray(params int[] values)
+            {
+                Type csharpArgumentInfoType = Type.GetType(CSharpArgumentInfoTypeName);
+                Type csharpArgumentInfoFlags = Type.GetType(CSharpArgumentInfoFlagsTypeName);
+
+                Array a = Array.CreateInstance(csharpArgumentInfoType, values.Length);
+
+                for (int i = 0; i < values.Length; i++)
+                {
+                    MethodInfo createArgumentInfoMethod = csharpArgumentInfoType.GetMethod("Create", new[] { csharpArgumentInfoFlags, typeof(string) });
+                    object arg = createArgumentInfoMethod.Invoke(null, new object?[] { 0, null });
+                    a.SetValue(arg, i);
+                }
+
+                return a;
+            }
+
+            private static void CreateMemberCalls()
+            {
+                Type csharpArgumentInfoType = Type.GetType(CSharpArgumentInfoTypeName, true);
+                Type csharpBinderFlagsType = Type.GetType(CSharpBinderFlagsTypeName, true);
+                Type binderType = Type.GetType(BinderTypeName, true);
+
+                Type csharpArgumentInfoTypeEnumerableType = typeof(IEnumerable<>).MakeGenericType(csharpArgumentInfoType);
+
+                MethodInfo getMemberMethod = binderType.GetMethod("GetMember", new[] { csharpBinderFlagsType, typeof(string), typeof(Type), csharpArgumentInfoTypeEnumerableType });
+                _getMemberCall = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object?>(getMemberMethod);
+
+                MethodInfo setMemberMethod = binderType.GetMethod("SetMember", new[] { csharpBinderFlagsType, typeof(string), typeof(Type), csharpArgumentInfoTypeEnumerableType });
+                _setMemberCall = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object?>(setMemberMethod);
+            }
+#endif
+
+            public static CallSiteBinder GetMember(string name, Type context)
+            {
+#if !HAVE_REFLECTION_BINDER
+                Init();
+                MiscellaneousUtils.Assert(_getMemberCall != null);
+                MiscellaneousUtils.Assert(_getCSharpArgumentInfoArray != null);
+                return (CallSiteBinder)_getMemberCall(null, 0, name, context, _getCSharpArgumentInfoArray)!;
+#else
+                return Binder.GetMember(
+                    CSharpBinderFlags.None, name, context, new[] {CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)});
+#endif
+            }
+
+            public static CallSiteBinder SetMember(string name, Type context)
+            {
+#if !HAVE_REFLECTION_BINDER
+                Init();
+                MiscellaneousUtils.Assert(_setMemberCall != null);
+                MiscellaneousUtils.Assert(_setCSharpArgumentInfoArray != null);
+                return (CallSiteBinder)_setMemberCall(null, 0, name, context, _setCSharpArgumentInfoArray)!;
+#else
+                return Binder.SetMember(
+                    CSharpBinderFlags.None, name, context, new[]
+                                                               {
+                                                                   CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null),
+                                                                   CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.Constant, null)
+                                                               });
+#endif
+            }
+        }
+
+        public static IEnumerable<string> GetDynamicMemberNames(this IDynamicMetaObjectProvider dynamicProvider)
+        {
+            DynamicMetaObject metaObject = dynamicProvider.GetMetaObject(Expression.Constant(dynamicProvider));
+            return metaObject.GetDynamicMemberNames();
+        }
+    }
+
+    internal class NoThrowGetBinderMember : GetMemberBinder
+    {
+        private readonly GetMemberBinder _innerBinder;
+
+        public NoThrowGetBinderMember(GetMemberBinder innerBinder)
+            : base(innerBinder.Name, innerBinder.IgnoreCase)
+        {
+            _innerBinder = innerBinder;
+        }
+
+        public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion)
+        {
+            DynamicMetaObject retMetaObject = _innerBinder.Bind(target, CollectionUtils.ArrayEmpty<DynamicMetaObject>());
+
+            NoThrowExpressionVisitor noThrowVisitor = new NoThrowExpressionVisitor();
+            Expression resultExpression = noThrowVisitor.Visit(retMetaObject.Expression);
+
+            DynamicMetaObject finalMetaObject = new DynamicMetaObject(resultExpression, retMetaObject.Restrictions);
+            return finalMetaObject;
+        }
+    }
+
+    internal class NoThrowSetBinderMember : SetMemberBinder
+    {
+        private readonly SetMemberBinder _innerBinder;
+
+        public NoThrowSetBinderMember(SetMemberBinder innerBinder)
+            : base(innerBinder.Name, innerBinder.IgnoreCase)
+        {
+            _innerBinder = innerBinder;
+        }
+
+        public override DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
+        {
+            DynamicMetaObject retMetaObject = _innerBinder.Bind(target, new DynamicMetaObject[] { value });
+
+            NoThrowExpressionVisitor noThrowVisitor = new NoThrowExpressionVisitor();
+            Expression resultExpression = noThrowVisitor.Visit(retMetaObject.Expression);
+
+            DynamicMetaObject finalMetaObject = new DynamicMetaObject(resultExpression, retMetaObject.Restrictions);
+            return finalMetaObject;
+        }
+    }
+
+    internal class NoThrowExpressionVisitor : ExpressionVisitor
+    {
+        internal static readonly object ErrorResult = new object();
+
+        protected override Expression VisitConditional(ConditionalExpression node)
+        {
+            // if the result of a test is to throw an error, rewrite to result an error result value
+            if (node.IfFalse.NodeType == ExpressionType.Throw)
+            {
+                return Expression.Condition(node.Test, node.IfTrue, Expression.Constant(ErrorResult));
+            }
+
+            return base.VisitConditional(node);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/EnumInfo.cs b/Libs/Newtonsoft.Json/Utilities/EnumInfo.cs
new file mode 100644
index 0000000..3a6d323
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/EnumInfo.cs
@@ -0,0 +1,43 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class EnumInfo
+    {
+        public EnumInfo(bool isFlags, ulong[] values, string[] names, string[] resolvedNames)
+        {
+            IsFlags = isFlags;
+            Values = values;
+            Names = names;
+            ResolvedNames = resolvedNames;
+        }
+
+        public readonly bool IsFlags;
+        public readonly ulong[] Values;
+        public readonly string[] Names;
+        public readonly string[] ResolvedNames;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/EnumUtils.cs b/Libs/Newtonsoft.Json/Utilities/EnumUtils.cs
new file mode 100644
index 0000000..ba30a67
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/EnumUtils.cs
@@ -0,0 +1,407 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.Serialization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+using System.Text;
+using LC.Newtonsoft.Json.Serialization;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class EnumUtils
+    {
+        private const char EnumSeparatorChar = ',';
+        private const string EnumSeparatorString = ", ";
+
+        private static readonly ThreadSafeStore<StructMultiKey<Type, NamingStrategy?>, EnumInfo> ValuesAndNamesPerEnum = new ThreadSafeStore<StructMultiKey<Type, NamingStrategy?>, EnumInfo>(InitializeValuesAndNames);
+
+        private static EnumInfo InitializeValuesAndNames(StructMultiKey<Type, NamingStrategy?> key)
+        {
+            Type enumType = key.Value1;
+            string[] names = Enum.GetNames(enumType);
+            string[] resolvedNames = new string[names.Length];
+            ulong[] values = new ulong[names.Length];
+            bool hasSpecifiedName;
+
+            for (int i = 0; i < names.Length; i++)
+            {
+                string name = names[i];
+                FieldInfo f = enumType.GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)!;
+                values[i] = ToUInt64(f.GetValue(null));
+
+                string resolvedName;
+#if HAVE_DATA_CONTRACTS
+                string specifiedName = f.GetCustomAttributes(typeof(EnumMemberAttribute), true)
+                         .Cast<EnumMemberAttribute>()
+                         .Select(a => a.Value)
+                         .SingleOrDefault();
+                hasSpecifiedName = specifiedName != null;
+                resolvedName = specifiedName ?? name;
+
+                if (Array.IndexOf(resolvedNames, resolvedName, 0, i) != -1)
+                {
+                    throw new InvalidOperationException("Enum name '{0}' already exists on enum '{1}'.".FormatWith(CultureInfo.InvariantCulture, resolvedName, enumType.Name));
+                }
+#else
+                resolvedName = name;
+                hasSpecifiedName = false;
+#endif
+
+                resolvedNames[i] = key.Value2 != null
+                    ? key.Value2.GetPropertyName(resolvedName, hasSpecifiedName)
+                    : resolvedName;
+            }
+
+            bool isFlags = enumType.IsDefined(typeof(FlagsAttribute), false);
+
+            return new EnumInfo(isFlags, values, names, resolvedNames);
+        }
+
+        public static IList<T> GetFlagsValues<T>(T value) where T : struct
+        {
+            Type enumType = typeof(T);
+
+            if (!enumType.IsDefined(typeof(FlagsAttribute), false))
+            {
+                throw new ArgumentException("Enum type {0} is not a set of flags.".FormatWith(CultureInfo.InvariantCulture, enumType));
+            }
+
+            Type underlyingType = Enum.GetUnderlyingType(value.GetType());
+
+            ulong num = ToUInt64(value);
+            EnumInfo enumNameValues = GetEnumValuesAndNames(enumType);
+            IList<T> selectedFlagsValues = new List<T>();
+
+            for (int i = 0; i < enumNameValues.Values.Length; i++)
+            {
+                ulong v = enumNameValues.Values[i];
+
+                if ((num & v) == v && v != 0)
+                {
+                    selectedFlagsValues.Add((T)Convert.ChangeType(v, underlyingType, CultureInfo.CurrentCulture));
+                }
+            }
+
+            if (selectedFlagsValues.Count == 0 && enumNameValues.Values.Any(v => v == 0))
+            {
+                selectedFlagsValues.Add(default);
+            }
+
+            return selectedFlagsValues;
+        }
+
+        // Used by Newtonsoft.Json.Schema
+        private static CamelCaseNamingStrategy _camelCaseNamingStrategy = new CamelCaseNamingStrategy();
+        public static bool TryToString(Type enumType, object value, bool camelCase, [NotNullWhen(true)]out string? name)
+        {
+            return TryToString(enumType, value, camelCase ? _camelCaseNamingStrategy : null, out name);
+        }
+
+        public static bool TryToString(Type enumType, object value, NamingStrategy? namingStrategy, [NotNullWhen(true)]out string? name)
+        {
+            EnumInfo enumInfo = ValuesAndNamesPerEnum.Get(new StructMultiKey<Type, NamingStrategy?>(enumType, namingStrategy));
+            ulong v = ToUInt64(value);
+
+            if (!enumInfo.IsFlags)
+            {
+                int index = Array.BinarySearch(enumInfo.Values, v);
+                if (index >= 0)
+                {
+                    name = enumInfo.ResolvedNames[index];
+                    return true;
+                }
+
+                // is number value
+                name = null;
+                return false;
+            }
+            else // These are flags OR'ed together (We treat everything as unsigned types)
+            {
+                name = InternalFlagsFormat(enumInfo, v);
+                return name != null;
+            }
+        }
+
+        private static string? InternalFlagsFormat(EnumInfo entry, ulong result)
+        {
+            string[] resolvedNames = entry.ResolvedNames;
+            ulong[] values = entry.Values;
+
+            int index = values.Length - 1;
+            StringBuilder sb = new StringBuilder();
+            bool firstTime = true;
+            ulong saveResult = result;
+
+            // We will not optimize this code further to keep it maintainable. There are some boundary checks that can be applied
+            // to minimize the comparsions required. This code works the same for the best/worst case. In general the number of
+            // items in an enum are sufficiently small and not worth the optimization.
+            while (index >= 0)
+            {
+                if (index == 0 && values[index] == 0)
+                {
+                    break;
+                }
+
+                if ((result & values[index]) == values[index])
+                {
+                    result -= values[index];
+                    if (!firstTime)
+                    {
+                        sb.Insert(0, EnumSeparatorString);
+                    }
+
+                    string resolvedName = resolvedNames[index];
+                    sb.Insert(0, resolvedName);
+                    firstTime = false;
+                }
+
+                index--;
+            }
+
+            string? returnString;
+            if (result != 0)
+            {
+                // We were unable to represent this number as a bitwise or of valid flags
+                returnString = null; // return null so the caller knows to .ToString() the input
+            }
+            else if (saveResult == 0)
+            {
+                // For the cases when we have zero
+                if (values.Length > 0 && values[0] == 0)
+                {
+                    returnString = resolvedNames[0]; // Zero was one of the enum values.
+                }
+                else
+                {
+                    returnString = null;
+                }
+            }
+            else
+            {
+                returnString = sb.ToString(); // Return the string representation
+            }
+
+            return returnString;
+        }
+
+        public static EnumInfo GetEnumValuesAndNames(Type enumType)
+        {
+            return ValuesAndNamesPerEnum.Get(new StructMultiKey<Type, NamingStrategy?>(enumType, null));
+        }
+
+        private static ulong ToUInt64(object value)
+        {
+            PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(value.GetType(), out bool _);
+
+            switch (typeCode)
+            {
+                case PrimitiveTypeCode.SByte:
+                    return (ulong)(sbyte)value;
+                case PrimitiveTypeCode.Byte:
+                    return (byte)value;
+                case PrimitiveTypeCode.Boolean:
+                    // direct cast from bool to byte is not allowed
+                    return Convert.ToByte((bool)value);
+                case PrimitiveTypeCode.Int16:
+                    return (ulong)(short)value;
+                case PrimitiveTypeCode.UInt16:
+                    return (ushort)value;
+                case PrimitiveTypeCode.Char:
+                    return (char)value;
+                case PrimitiveTypeCode.UInt32:
+                    return (uint)value;
+                case PrimitiveTypeCode.Int32:
+                    return (ulong)(int)value;
+                case PrimitiveTypeCode.UInt64:
+                    return (ulong)value;
+                case PrimitiveTypeCode.Int64:
+                    return (ulong)(long)value;
+                // All unsigned types will be directly cast
+                default:
+                    throw new InvalidOperationException("Unknown enum type.");
+            }
+        }
+
+        public static object ParseEnum(Type enumType, NamingStrategy? namingStrategy, string value, bool disallowNumber)
+        {
+            ValidationUtils.ArgumentNotNull(enumType, nameof(enumType));
+            ValidationUtils.ArgumentNotNull(value, nameof(value));
+
+            if (!enumType.IsEnum())
+            {
+                throw new ArgumentException("Type provided must be an Enum.", nameof(enumType));
+            }
+
+            EnumInfo entry = ValuesAndNamesPerEnum.Get(new StructMultiKey<Type, NamingStrategy?>(enumType, namingStrategy));
+            string[] enumNames = entry.Names;
+            string[] resolvedNames = entry.ResolvedNames;
+            ulong[] enumValues = entry.Values;
+
+            // first check if the entire text (including commas) matches a resolved name
+            int? matchingIndex = FindIndexByName(resolvedNames, value, 0, value.Length, StringComparison.Ordinal);
+            if (matchingIndex != null)
+            {
+                return Enum.ToObject(enumType, enumValues[matchingIndex.Value]);
+            }
+
+            int firstNonWhitespaceIndex = -1;
+            for (int i = 0; i < value.Length; i++)
+            {
+                if (!char.IsWhiteSpace(value[i]))
+                {
+                    firstNonWhitespaceIndex = i;
+                    break;
+                }
+            }
+            if (firstNonWhitespaceIndex == -1)
+            {
+                throw new ArgumentException("Must specify valid information for parsing in the string.");
+            }
+
+            // check whether string is a number and parse as a number value
+            char firstNonWhitespaceChar = value[firstNonWhitespaceIndex];
+            if (char.IsDigit(firstNonWhitespaceChar) || firstNonWhitespaceChar == '-' || firstNonWhitespaceChar == '+')
+            {
+                Type underlyingType = Enum.GetUnderlyingType(enumType);
+
+                value = value.Trim();
+                object? temp = null;
+
+                try
+                {
+                    temp = Convert.ChangeType(value, underlyingType, CultureInfo.InvariantCulture);
+                }
+                catch (FormatException)
+                {
+                    // We need to Parse this as a String instead. There are cases
+                    // when you tlbimp enums that can have values of the form "3D".
+                    // Don't fix this code.
+                }
+
+                if (temp != null)
+                {
+                    if (disallowNumber)
+                    {
+                        throw new FormatException("Integer string '{0}' is not allowed.".FormatWith(CultureInfo.InvariantCulture, value));
+                    }
+
+                    return Enum.ToObject(enumType, temp);
+                }
+            }
+
+            ulong result = 0;
+
+            int valueIndex = firstNonWhitespaceIndex;
+            while (valueIndex <= value.Length) // '=' is to handle invalid case of an ending comma
+            {
+                // Find the next separator, if there is one, otherwise the end of the string.
+                int endIndex = value.IndexOf(EnumSeparatorChar, valueIndex);
+                if (endIndex == -1)
+                {
+                    endIndex = value.Length;
+                }
+
+                // Shift the starting and ending indices to eliminate whitespace
+                int endIndexNoWhitespace = endIndex;
+                while (valueIndex < endIndex && char.IsWhiteSpace(value[valueIndex]))
+                {
+                    valueIndex++;
+                }
+
+                while (endIndexNoWhitespace > valueIndex && char.IsWhiteSpace(value[endIndexNoWhitespace - 1]))
+                {
+                    endIndexNoWhitespace--;
+                }
+                int valueSubstringLength = endIndexNoWhitespace - valueIndex;
+
+                // match with case sensitivity
+                matchingIndex = MatchName(value, enumNames, resolvedNames, valueIndex, valueSubstringLength, StringComparison.Ordinal);
+
+                // if no match found, attempt case insensitive search
+                if (matchingIndex == null)
+                {
+                    matchingIndex = MatchName(value, enumNames, resolvedNames, valueIndex, valueSubstringLength, StringComparison.OrdinalIgnoreCase);
+                }
+
+                if (matchingIndex == null)
+                {
+                    // still can't find a match
+                    // before we throw an error, check whether the entire string has a case insensitive match against resolve names
+                    matchingIndex = FindIndexByName(resolvedNames, value, 0, value.Length, StringComparison.OrdinalIgnoreCase);
+                    if (matchingIndex != null)
+                    {
+                        return Enum.ToObject(enumType, enumValues[matchingIndex.Value]);
+                    }
+
+                    // no match so error
+                    throw new ArgumentException("Requested value '{0}' was not found.".FormatWith(CultureInfo.InvariantCulture, value));
+                }
+
+                result |= enumValues[matchingIndex.Value];
+
+                // Move our pointer to the ending index to go again.
+                valueIndex = endIndex + 1;
+            }
+
+            return Enum.ToObject(enumType, result);
+        }
+
+        private static int? MatchName(string value, string[] enumNames, string[] resolvedNames, int valueIndex, int valueSubstringLength, StringComparison comparison)
+        {
+            int? matchingIndex = FindIndexByName(resolvedNames, value, valueIndex, valueSubstringLength, comparison);
+            if (matchingIndex == null)
+            {
+                matchingIndex = FindIndexByName(enumNames, value, valueIndex, valueSubstringLength, comparison);
+            }
+
+            return matchingIndex;
+        }
+
+        private static int? FindIndexByName(string[] enumNames, string value, int valueIndex, int valueSubstringLength, StringComparison comparison)
+        {
+            for (int i = 0; i < enumNames.Length; i++)
+            {
+                if (enumNames[i].Length == valueSubstringLength &&
+                    string.Compare(enumNames[i], 0, value, valueIndex, valueSubstringLength, comparison) == 0)
+                {
+                    return i;
+                }
+            }
+
+            return null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs b/Libs/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs
new file mode 100644
index 0000000..d267c02
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs
@@ -0,0 +1,398 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if !(NET20 || NET35)
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class ExpressionReflectionDelegateFactory : ReflectionDelegateFactory
+    {
+        private static readonly ExpressionReflectionDelegateFactory _instance = new ExpressionReflectionDelegateFactory();
+
+        internal static ReflectionDelegateFactory Instance => _instance;
+
+        public override ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)
+        {
+            ValidationUtils.ArgumentNotNull(method, nameof(method));
+
+            Type type = typeof(object);
+
+            ParameterExpression argsParameterExpression = Expression.Parameter(typeof(object[]), "args");
+
+            Expression callExpression = BuildMethodCall(method, type, null, argsParameterExpression);
+
+            LambdaExpression lambdaExpression = Expression.Lambda(typeof(ObjectConstructor<object>), callExpression, argsParameterExpression);
+
+            ObjectConstructor<object> compiled = (ObjectConstructor<object>)lambdaExpression.Compile();
+            return compiled;
+        }
+
+        public override MethodCall<T, object?> CreateMethodCall<T>(MethodBase method)
+        {
+            ValidationUtils.ArgumentNotNull(method, nameof(method));
+
+            Type type = typeof(object);
+
+            ParameterExpression targetParameterExpression = Expression.Parameter(type, "target");
+            ParameterExpression argsParameterExpression = Expression.Parameter(typeof(object[]), "args");
+
+            Expression callExpression = BuildMethodCall(method, type, targetParameterExpression, argsParameterExpression);
+
+            LambdaExpression lambdaExpression = Expression.Lambda(typeof(MethodCall<T, object>), callExpression, targetParameterExpression, argsParameterExpression);
+
+            MethodCall<T, object?> compiled = (MethodCall<T, object?>)lambdaExpression.Compile();
+            return compiled;
+        }
+
+        private class ByRefParameter
+        {
+            public Expression Value;
+            public ParameterExpression Variable;
+            public bool IsOut;
+
+            public ByRefParameter(Expression value, ParameterExpression variable, bool isOut)
+            {
+                Value = value;
+                Variable = variable;
+                IsOut = isOut;
+            }
+        }
+
+        private Expression BuildMethodCall(MethodBase method, Type type, ParameterExpression? targetParameterExpression, ParameterExpression argsParameterExpression)
+        {
+            ParameterInfo[] parametersInfo = method.GetParameters();
+
+            Expression[] argsExpression;
+            IList<ByRefParameter> refParameterMap;
+            if (parametersInfo.Length == 0)
+            {
+                argsExpression = CollectionUtils.ArrayEmpty<Expression>();
+                refParameterMap = CollectionUtils.ArrayEmpty<ByRefParameter>();
+            }
+            else
+            {
+                argsExpression = new Expression[parametersInfo.Length];
+                refParameterMap = new List<ByRefParameter>();
+
+                for (int i = 0; i < parametersInfo.Length; i++)
+                {
+                    ParameterInfo parameter = parametersInfo[i];
+                    Type parameterType = parameter.ParameterType;
+                    bool isByRef = false;
+                    if (parameterType.IsByRef)
+                    {
+                        parameterType = parameterType.GetElementType();
+                        isByRef = true;
+                    }
+
+                    Expression indexExpression = Expression.Constant(i);
+
+                    Expression paramAccessorExpression = Expression.ArrayIndex(argsParameterExpression, indexExpression);
+
+                    Expression argExpression = EnsureCastExpression(paramAccessorExpression, parameterType, !isByRef);
+
+                    if (isByRef)
+                    {
+                        ParameterExpression variable = Expression.Variable(parameterType);
+                        refParameterMap.Add(new ByRefParameter(argExpression, variable, parameter.IsOut));
+
+                        argExpression = variable;
+                    }
+
+                    argsExpression[i] = argExpression;
+                }
+            }
+
+            Expression callExpression;
+            if (method.IsConstructor)
+            {
+                callExpression = Expression.New((ConstructorInfo)method, argsExpression);
+            }
+            else if (method.IsStatic)
+            {
+                callExpression = Expression.Call((MethodInfo)method, argsExpression);
+            }
+            else
+            {
+                Expression readParameter = EnsureCastExpression(targetParameterExpression!, method.DeclaringType);
+
+                callExpression = Expression.Call(readParameter, (MethodInfo)method, argsExpression);
+            }
+
+            if (method is MethodInfo m)
+            {
+                if (m.ReturnType != typeof(void))
+                {
+                    callExpression = EnsureCastExpression(callExpression, type);
+                }
+                else
+                {
+                    callExpression = Expression.Block(callExpression, Expression.Constant(null));
+                }
+            }
+            else
+            {
+                callExpression = EnsureCastExpression(callExpression, type);
+            }
+
+            if (refParameterMap.Count > 0)
+            {
+                IList<ParameterExpression> variableExpressions = new List<ParameterExpression>();
+                IList<Expression> bodyExpressions = new List<Expression>();
+                foreach (ByRefParameter p in refParameterMap)
+                {
+                    if (!p.IsOut)
+                    {
+                        bodyExpressions.Add(Expression.Assign(p.Variable, p.Value));
+                    }
+
+                    variableExpressions.Add(p.Variable);
+                }
+
+                bodyExpressions.Add(callExpression);
+
+                callExpression = Expression.Block(variableExpressions, bodyExpressions);
+            }
+
+            return callExpression;
+        }
+
+        public override Func<T> CreateDefaultConstructor<T>(Type type)
+        {
+            ValidationUtils.ArgumentNotNull(type, "type");
+
+            // avoid error from expressions compiler because of abstract class
+            if (type.IsAbstract())
+            {
+                return () => (T)Activator.CreateInstance(type);
+            }
+
+            try
+            {
+                Type resultType = typeof(T);
+
+                Expression expression = Expression.New(type);
+
+                expression = EnsureCastExpression(expression, resultType);
+
+                LambdaExpression lambdaExpression = Expression.Lambda(typeof(Func<T>), expression);
+
+                Func<T> compiled = (Func<T>)lambdaExpression.Compile();
+                return compiled;
+            }
+            catch
+            {
+                // an error can be thrown if constructor is not valid on Win8
+                // will have INVOCATION_FLAGS_NON_W8P_FX_API invocation flag
+                return () => (T)Activator.CreateInstance(type);
+            }
+        }
+
+        public override Func<T, object?> CreateGet<T>(PropertyInfo propertyInfo)
+        {
+            ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
+
+            Type instanceType = typeof(T);
+            Type resultType = typeof(object);
+
+            ParameterExpression parameterExpression = Expression.Parameter(instanceType, "instance");
+            Expression resultExpression;
+
+            MethodInfo? getMethod = propertyInfo.GetGetMethod(true);
+            if (getMethod == null)
+            {
+                throw new ArgumentException("Property does not have a getter.");
+            }
+
+            if (getMethod.IsStatic)
+            {
+                resultExpression = Expression.MakeMemberAccess(null, propertyInfo);
+            }
+            else
+            {
+                Expression readParameter = EnsureCastExpression(parameterExpression, propertyInfo.DeclaringType);
+
+                resultExpression = Expression.MakeMemberAccess(readParameter, propertyInfo);
+            }
+
+            resultExpression = EnsureCastExpression(resultExpression, resultType);
+
+            LambdaExpression lambdaExpression = Expression.Lambda(typeof(Func<T, object>), resultExpression, parameterExpression);
+
+            Func<T, object?> compiled = (Func<T, object?>)lambdaExpression.Compile();
+            return compiled;
+        }
+
+        public override Func<T, object?> CreateGet<T>(FieldInfo fieldInfo)
+        {
+            ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
+
+            ParameterExpression sourceParameter = Expression.Parameter(typeof(T), "source");
+
+            Expression fieldExpression;
+            if (fieldInfo.IsStatic)
+            {
+                fieldExpression = Expression.Field(null, fieldInfo);
+            }
+            else
+            {
+                Expression sourceExpression = EnsureCastExpression(sourceParameter, fieldInfo.DeclaringType);
+
+                fieldExpression = Expression.Field(sourceExpression, fieldInfo);
+            }
+
+            fieldExpression = EnsureCastExpression(fieldExpression, typeof(object));
+
+            Func<T, object?> compiled = Expression.Lambda<Func<T, object?>>(fieldExpression, sourceParameter).Compile();
+            return compiled;
+        }
+
+        public override Action<T, object?> CreateSet<T>(FieldInfo fieldInfo)
+        {
+            ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
+
+            // use reflection for structs
+            // expression doesn't correctly set value
+            if (fieldInfo.DeclaringType.IsValueType() || fieldInfo.IsInitOnly)
+            {
+                return LateBoundReflectionDelegateFactory.Instance.CreateSet<T>(fieldInfo);
+            }
+
+            ParameterExpression sourceParameterExpression = Expression.Parameter(typeof(T), "source");
+            ParameterExpression valueParameterExpression = Expression.Parameter(typeof(object), "value");
+
+            Expression fieldExpression;
+            if (fieldInfo.IsStatic)
+            {
+                fieldExpression = Expression.Field(null, fieldInfo);
+            }
+            else
+            {
+                Expression sourceExpression = EnsureCastExpression(sourceParameterExpression, fieldInfo.DeclaringType);
+
+                fieldExpression = Expression.Field(sourceExpression, fieldInfo);
+            }
+
+            Expression valueExpression = EnsureCastExpression(valueParameterExpression, fieldExpression.Type);
+
+            BinaryExpression assignExpression = Expression.Assign(fieldExpression, valueExpression);
+
+            LambdaExpression lambdaExpression = Expression.Lambda(typeof(Action<T, object>), assignExpression, sourceParameterExpression, valueParameterExpression);
+
+            Action<T, object?> compiled = (Action<T, object?>)lambdaExpression.Compile();
+            return compiled;
+        }
+
+        public override Action<T, object?> CreateSet<T>(PropertyInfo propertyInfo)
+        {
+            ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
+
+            // use reflection for structs
+            // expression doesn't correctly set value
+            if (propertyInfo.DeclaringType.IsValueType())
+            {
+                return LateBoundReflectionDelegateFactory.Instance.CreateSet<T>(propertyInfo);
+            }
+
+            Type instanceType = typeof(T);
+            Type valueType = typeof(object);
+
+            ParameterExpression instanceParameter = Expression.Parameter(instanceType, "instance");
+
+            ParameterExpression valueParameter = Expression.Parameter(valueType, "value");
+            Expression readValueParameter = EnsureCastExpression(valueParameter, propertyInfo.PropertyType);
+
+            MethodInfo? setMethod = propertyInfo.GetSetMethod(true);
+            if (setMethod == null)
+            {
+                throw new ArgumentException("Property does not have a setter.");
+            }
+
+            Expression setExpression;
+            if (setMethod.IsStatic)
+            {
+                setExpression = Expression.Call(setMethod, readValueParameter);
+            }
+            else
+            {
+                Expression readInstanceParameter = EnsureCastExpression(instanceParameter, propertyInfo.DeclaringType);
+
+                setExpression = Expression.Call(readInstanceParameter, setMethod, readValueParameter);
+            }
+
+            LambdaExpression lambdaExpression = Expression.Lambda(typeof(Action<T, object?>), setExpression, instanceParameter, valueParameter);
+
+            Action<T, object?> compiled = (Action<T, object?>)lambdaExpression.Compile();
+            return compiled;
+        }
+        
+        private Expression EnsureCastExpression(Expression expression, Type targetType, bool allowWidening = false)
+        {
+            Type expressionType = expression.Type;
+            
+            // check if a cast or conversion is required
+            if (expressionType == targetType || (!expressionType.IsValueType() && targetType.IsAssignableFrom(expressionType)))
+            {
+                return expression;
+            }
+
+            if (targetType.IsValueType())
+            {
+                Expression convert = Expression.Unbox(expression, targetType);
+
+                if (allowWidening && targetType.IsPrimitive())
+                {
+                    MethodInfo toTargetTypeMethod = typeof(Convert)
+                        .GetMethod("To" + targetType.Name, new[] { typeof(object) });
+
+                    if (toTargetTypeMethod != null)
+                    {
+                        convert = Expression.Condition(
+                            Expression.TypeIs(expression, targetType),
+                            convert,
+                            Expression.Call(toTargetTypeMethod, expression));
+                    }
+                }
+                
+                return Expression.Condition(
+                    Expression.Equal(expression, Expression.Constant(null, typeof(object))),
+                    Expression.Default(targetType), 
+                    convert);
+            }
+
+            return Expression.Convert(expression, targetType);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/FSharpUtils.cs b/Libs/Newtonsoft.Json/Utilities/FSharpUtils.cs
new file mode 100644
index 0000000..ad66c34
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/FSharpUtils.cs
@@ -0,0 +1,205 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_FSHARP_TYPES
+using System.Threading;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using LC.Newtonsoft.Json.Serialization;
+using System.Diagnostics;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class FSharpFunction
+    {
+        private readonly object? _instance;
+        private readonly MethodCall<object?, object> _invoker;
+
+        public FSharpFunction(object? instance, MethodCall<object?, object> invoker)
+        {
+            _instance = instance;
+            _invoker = invoker;
+        }
+
+        public object Invoke(params object[] args)
+        {
+            object o = _invoker(_instance, args);
+
+            return o;
+        }
+    }
+
+    internal class FSharpUtils
+    {
+        private FSharpUtils(Assembly fsharpCoreAssembly)
+        {
+            FSharpCoreAssembly = fsharpCoreAssembly;
+
+            Type fsharpType = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.FSharpType");
+
+            MethodInfo isUnionMethodInfo = GetMethodWithNonPublicFallback(fsharpType, "IsUnion", BindingFlags.Public | BindingFlags.Static);
+            IsUnion = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object?>(isUnionMethodInfo)!;
+
+            MethodInfo getUnionCasesMethodInfo = GetMethodWithNonPublicFallback(fsharpType, "GetUnionCases", BindingFlags.Public | BindingFlags.Static);
+            GetUnionCases = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object?>(getUnionCasesMethodInfo)!;
+
+            Type fsharpValue = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.FSharpValue");
+
+            PreComputeUnionTagReader = CreateFSharpFuncCall(fsharpValue, "PreComputeUnionTagReader");
+            PreComputeUnionReader = CreateFSharpFuncCall(fsharpValue, "PreComputeUnionReader");
+            PreComputeUnionConstructor = CreateFSharpFuncCall(fsharpValue, "PreComputeUnionConstructor");
+
+            Type unionCaseInfo = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.UnionCaseInfo");
+
+            GetUnionCaseInfoName = JsonTypeReflector.ReflectionDelegateFactory.CreateGet<object>(unionCaseInfo.GetProperty("Name")!)!;
+            GetUnionCaseInfoTag = JsonTypeReflector.ReflectionDelegateFactory.CreateGet<object>(unionCaseInfo.GetProperty("Tag")!)!;
+            GetUnionCaseInfoDeclaringType = JsonTypeReflector.ReflectionDelegateFactory.CreateGet<object>(unionCaseInfo.GetProperty("DeclaringType")!)!;
+            GetUnionCaseInfoFields = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object>(unionCaseInfo.GetMethod("GetFields"));
+
+            Type listModule = fsharpCoreAssembly.GetType("Microsoft.FSharp.Collections.ListModule");
+            _ofSeq = listModule.GetMethod("OfSeq");
+
+            _mapType = fsharpCoreAssembly.GetType("Microsoft.FSharp.Collections.FSharpMap`2");
+        }
+
+        private static readonly object Lock = new object();
+        private static FSharpUtils? _instance;
+
+        public static FSharpUtils Instance
+        {
+            get
+            {
+                MiscellaneousUtils.Assert(_instance != null);
+                return _instance;
+            }
+        }
+
+        private MethodInfo _ofSeq;
+        private Type _mapType;
+
+        public Assembly FSharpCoreAssembly { get; private set; }
+        public MethodCall<object?, object> IsUnion { get; private set; }
+        public MethodCall<object?, object> GetUnionCases { get; private set; }
+        public MethodCall<object?, object> PreComputeUnionTagReader { get; private set; }
+        public MethodCall<object?, object> PreComputeUnionReader { get; private set; }
+        public MethodCall<object?, object> PreComputeUnionConstructor { get; private set; }
+        public Func<object, object> GetUnionCaseInfoDeclaringType { get; private set; }
+        public Func<object, object> GetUnionCaseInfoName { get; private set; }
+        public Func<object, object> GetUnionCaseInfoTag { get; private set; }
+        public MethodCall<object, object?> GetUnionCaseInfoFields { get; private set; }
+
+        public const string FSharpSetTypeName = "FSharpSet`1";
+        public const string FSharpListTypeName = "FSharpList`1";
+        public const string FSharpMapTypeName = "FSharpMap`2";
+
+        public static void EnsureInitialized(Assembly fsharpCoreAssembly)
+        {
+            if (_instance == null)
+            {
+                lock (Lock)
+                {
+                    if (_instance == null)
+                    {
+                        _instance = new FSharpUtils(fsharpCoreAssembly);
+                    }
+                }
+            }
+        }
+
+        private static MethodInfo GetMethodWithNonPublicFallback(Type type, string methodName, BindingFlags bindingFlags)
+        {
+            MethodInfo methodInfo = type.GetMethod(methodName, bindingFlags);
+
+            // if no matching method then attempt to find with nonpublic flag
+            // this is required because in WinApps some methods are private but always using NonPublic breaks medium trust
+            // https://github.com/JamesNK/Newtonsoft.Json/pull/649
+            // https://github.com/JamesNK/Newtonsoft.Json/issues/821
+            if (methodInfo == null && (bindingFlags & BindingFlags.NonPublic) != BindingFlags.NonPublic)
+            {
+                methodInfo = type.GetMethod(methodName, bindingFlags | BindingFlags.NonPublic);
+            }
+
+            return methodInfo!;
+        }
+
+        private static MethodCall<object?, object> CreateFSharpFuncCall(Type type, string methodName)
+        {
+            MethodInfo innerMethodInfo = GetMethodWithNonPublicFallback(type, methodName, BindingFlags.Public | BindingFlags.Static);
+            MethodInfo invokeFunc = innerMethodInfo.ReturnType.GetMethod("Invoke", BindingFlags.Public | BindingFlags.Instance);
+
+            MethodCall<object?, object?> call = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object?>(innerMethodInfo);
+            MethodCall<object?, object> invoke = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object?>(invokeFunc)!;
+
+            MethodCall<object?, object> createFunction = (target, args) =>
+            {
+                object? result = call(target, args);
+
+                FSharpFunction f = new FSharpFunction(result, invoke);
+                return f;
+            };
+
+            return createFunction;
+        }
+
+        public ObjectConstructor<object> CreateSeq(Type t)
+        {
+            MethodInfo seqType = _ofSeq.MakeGenericMethod(t);
+
+            return JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(seqType);
+        }
+
+        public ObjectConstructor<object> CreateMap(Type keyType, Type valueType)
+        {
+            MethodInfo creatorDefinition = typeof(FSharpUtils).GetMethod("BuildMapCreator");
+
+            MethodInfo creatorGeneric = creatorDefinition.MakeGenericMethod(keyType, valueType);
+
+            return (ObjectConstructor<object>)creatorGeneric.Invoke(this, null);
+        }
+
+        public ObjectConstructor<object> BuildMapCreator<TKey, TValue>()
+        {
+            Type genericMapType = _mapType.MakeGenericType(typeof(TKey), typeof(TValue));
+            ConstructorInfo ctor = genericMapType.GetConstructor(new[] { typeof(IEnumerable<Tuple<TKey, TValue>>) });
+            ObjectConstructor<object> ctorDelegate = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(ctor);
+
+            ObjectConstructor<object> creator = args =>
+            {
+                // convert dictionary KeyValuePairs to Tuples
+                IEnumerable<KeyValuePair<TKey, TValue>> values = (IEnumerable<KeyValuePair<TKey, TValue>>)args[0]!;
+                IEnumerable<Tuple<TKey, TValue>> tupleValues = values.Select(kv => new Tuple<TKey, TValue>(kv.Key, kv.Value));
+
+                return ctorDelegate(tupleValues);
+            };
+
+            return creator;
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ILGeneratorExtensions.cs b/Libs/Newtonsoft.Json/Utilities/ILGeneratorExtensions.cs
new file mode 100644
index 0000000..a25b646
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ILGeneratorExtensions.cs
@@ -0,0 +1,98 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if HAVE_REFLECTION_EMIT
+using System;
+using System.Reflection.Emit;
+using System.Reflection;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class ILGeneratorExtensions
+    {
+        public static void PushInstance(this ILGenerator generator, Type type)
+        {
+            generator.Emit(OpCodes.Ldarg_0);
+            if (type.IsValueType())
+            {
+                generator.Emit(OpCodes.Unbox, type);
+            }
+            else
+            {
+                generator.Emit(OpCodes.Castclass, type);
+            }
+        }
+
+        public static void PushArrayInstance(this ILGenerator generator, int argsIndex, int arrayIndex)
+        {
+            generator.Emit(OpCodes.Ldarg, argsIndex);
+            generator.Emit(OpCodes.Ldc_I4, arrayIndex);
+            generator.Emit(OpCodes.Ldelem_Ref);
+        }
+
+        public static void BoxIfNeeded(this ILGenerator generator, Type type)
+        {
+            if (type.IsValueType())
+            {
+                generator.Emit(OpCodes.Box, type);
+            }
+            else
+            {
+                generator.Emit(OpCodes.Castclass, type);
+            }
+        }
+
+        public static void UnboxIfNeeded(this ILGenerator generator, Type type)
+        {
+            if (type.IsValueType())
+            {
+                generator.Emit(OpCodes.Unbox_Any, type);
+            }
+            else
+            {
+                generator.Emit(OpCodes.Castclass, type);
+            }
+        }
+
+        public static void CallMethod(this ILGenerator generator, MethodInfo methodInfo)
+        {
+            if (methodInfo.IsFinal || !methodInfo.IsVirtual)
+            {
+                generator.Emit(OpCodes.Call, methodInfo);
+            }
+            else
+            {
+                generator.Emit(OpCodes.Callvirt, methodInfo);
+            }
+        }
+
+        public static void Return(this ILGenerator generator)
+        {
+            generator.Emit(OpCodes.Ret);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs b/Libs/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs
new file mode 100644
index 0000000..ecbab85
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs
@@ -0,0 +1,183 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    /// <summary>
+    /// Helper class for serializing immutable collections.
+    /// Note that this is used by all builds, even those that don't support immutable collections, in case the DLL is GACed
+    /// https://github.com/JamesNK/Newtonsoft.Json/issues/652
+    /// </summary>
+    internal static class ImmutableCollectionsUtils
+    {
+        internal class ImmutableCollectionTypeInfo
+        {
+            public ImmutableCollectionTypeInfo(string contractTypeName, string createdTypeName, string builderTypeName)
+            {
+                ContractTypeName = contractTypeName;
+                CreatedTypeName = createdTypeName;
+                BuilderTypeName = builderTypeName;
+            }
+
+            public string ContractTypeName { get; set; }
+            public string CreatedTypeName { get; set; }
+            public string BuilderTypeName { get; set; }
+        }
+
+        private const string ImmutableListGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableList`1";
+        private const string ImmutableQueueGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableQueue`1";
+        private const string ImmutableStackGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableStack`1";
+        private const string ImmutableSetGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableSet`1";
+
+        private const string ImmutableArrayTypeName = "System.Collections.Immutable.ImmutableArray";
+        private const string ImmutableArrayGenericTypeName = "System.Collections.Immutable.ImmutableArray`1";
+
+        private const string ImmutableListTypeName = "System.Collections.Immutable.ImmutableList";
+        private const string ImmutableListGenericTypeName = "System.Collections.Immutable.ImmutableList`1";
+
+        private const string ImmutableQueueTypeName = "System.Collections.Immutable.ImmutableQueue";
+        private const string ImmutableQueueGenericTypeName = "System.Collections.Immutable.ImmutableQueue`1";
+
+        private const string ImmutableStackTypeName = "System.Collections.Immutable.ImmutableStack";
+        private const string ImmutableStackGenericTypeName = "System.Collections.Immutable.ImmutableStack`1";
+
+        private const string ImmutableSortedSetTypeName = "System.Collections.Immutable.ImmutableSortedSet";
+        private const string ImmutableSortedSetGenericTypeName = "System.Collections.Immutable.ImmutableSortedSet`1";
+
+        private const string ImmutableHashSetTypeName = "System.Collections.Immutable.ImmutableHashSet";
+        private const string ImmutableHashSetGenericTypeName = "System.Collections.Immutable.ImmutableHashSet`1";
+
+        private static readonly IList<ImmutableCollectionTypeInfo> ArrayContractImmutableCollectionDefinitions = new List<ImmutableCollectionTypeInfo>
+        {
+            new ImmutableCollectionTypeInfo(ImmutableListGenericInterfaceTypeName, ImmutableListGenericTypeName, ImmutableListTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableListGenericTypeName, ImmutableListGenericTypeName, ImmutableListTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableQueueGenericInterfaceTypeName, ImmutableQueueGenericTypeName, ImmutableQueueTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableQueueGenericTypeName, ImmutableQueueGenericTypeName, ImmutableQueueTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableStackGenericInterfaceTypeName, ImmutableStackGenericTypeName, ImmutableStackTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableStackGenericTypeName, ImmutableStackGenericTypeName, ImmutableStackTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableSetGenericInterfaceTypeName, ImmutableHashSetGenericTypeName, ImmutableHashSetTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableSortedSetGenericTypeName, ImmutableSortedSetGenericTypeName, ImmutableSortedSetTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableHashSetGenericTypeName, ImmutableHashSetGenericTypeName, ImmutableHashSetTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableArrayGenericTypeName, ImmutableArrayGenericTypeName, ImmutableArrayTypeName)
+        };
+
+        private const string ImmutableDictionaryGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableDictionary`2";
+
+        private const string ImmutableDictionaryTypeName = "System.Collections.Immutable.ImmutableDictionary";
+        private const string ImmutableDictionaryGenericTypeName = "System.Collections.Immutable.ImmutableDictionary`2";
+
+        private const string ImmutableSortedDictionaryTypeName = "System.Collections.Immutable.ImmutableSortedDictionary";
+        private const string ImmutableSortedDictionaryGenericTypeName = "System.Collections.Immutable.ImmutableSortedDictionary`2";
+
+        private static readonly IList<ImmutableCollectionTypeInfo> DictionaryContractImmutableCollectionDefinitions = new List<ImmutableCollectionTypeInfo>
+        {
+            new ImmutableCollectionTypeInfo(ImmutableDictionaryGenericInterfaceTypeName, ImmutableDictionaryGenericTypeName, ImmutableDictionaryTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableDictionaryGenericTypeName, ImmutableDictionaryGenericTypeName, ImmutableDictionaryTypeName)
+        };
+
+        internal static bool TryBuildImmutableForArrayContract(Type underlyingType, Type collectionItemType, [NotNullWhen(true)]out Type? createdType, [NotNullWhen(true)]out ObjectConstructor<object>? parameterizedCreator)
+        {
+            if (underlyingType.IsGenericType())
+            {
+                Type underlyingTypeDefinition = underlyingType.GetGenericTypeDefinition();
+                string name = underlyingTypeDefinition.FullName;
+
+                ImmutableCollectionTypeInfo definition = ArrayContractImmutableCollectionDefinitions.FirstOrDefault(d => d.ContractTypeName == name);
+                if (definition != null)
+                {
+                    Type createdTypeDefinition = underlyingTypeDefinition.Assembly().GetType(definition.CreatedTypeName);
+                    Type builderTypeDefinition = underlyingTypeDefinition.Assembly().GetType(definition.BuilderTypeName);
+
+                    if (createdTypeDefinition != null && builderTypeDefinition != null)
+                    {
+                        MethodInfo mb = builderTypeDefinition.GetMethods().FirstOrDefault(m => m.Name == "CreateRange" && m.GetParameters().Length == 1);
+                        if (mb != null)
+                        {
+                            createdType = createdTypeDefinition.MakeGenericType(collectionItemType);
+                            MethodInfo method = mb.MakeGenericMethod(collectionItemType);
+                            parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(method);
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            createdType = null;
+            parameterizedCreator = null;
+            return false;
+        }
+
+        internal static bool TryBuildImmutableForDictionaryContract(Type underlyingType, Type keyItemType, Type valueItemType, [NotNullWhen(true)]out Type? createdType, [NotNullWhen(true)]out ObjectConstructor<object>? parameterizedCreator)
+        {
+            if (underlyingType.IsGenericType())
+            {
+                Type underlyingTypeDefinition = underlyingType.GetGenericTypeDefinition();
+                string name = underlyingTypeDefinition.FullName;
+
+                ImmutableCollectionTypeInfo definition = DictionaryContractImmutableCollectionDefinitions.FirstOrDefault(d => d.ContractTypeName == name);
+                if (definition != null)
+                {
+                    Type createdTypeDefinition = underlyingTypeDefinition.Assembly().GetType(definition.CreatedTypeName);
+                    Type builderTypeDefinition = underlyingTypeDefinition.Assembly().GetType(definition.BuilderTypeName);
+
+                    if (createdTypeDefinition != null && builderTypeDefinition != null)
+                    {
+                        MethodInfo mb = builderTypeDefinition.GetMethods().FirstOrDefault(m =>
+                        {
+                            ParameterInfo[] parameters = m.GetParameters();
+
+                            return m.Name == "CreateRange" && parameters.Length == 1 && parameters[0].ParameterType.IsGenericType() && parameters[0].ParameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>);
+                        });
+                        if (mb != null)
+                        {
+                            createdType = createdTypeDefinition.MakeGenericType(keyItemType, valueItemType);
+                            MethodInfo method = mb.MakeGenericMethod(keyItemType, valueItemType);
+                            parameterizedCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(method);
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            createdType = null;
+            parameterizedCreator = null;
+            return false;
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Utilities/JavaScriptUtils.cs b/Libs/Newtonsoft.Json/Utilities/JavaScriptUtils.cs
new file mode 100644
index 0000000..0efa3aa
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/JavaScriptUtils.cs
@@ -0,0 +1,656 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.IO;
+#if HAVE_ASYNC
+using System.Threading;
+using System.Threading.Tasks;
+#endif
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class BufferUtils
+    {
+        public static char[] RentBuffer(IArrayPool<char>? bufferPool, int minSize)
+        {
+            if (bufferPool == null)
+            {
+                return new char[minSize];
+            }
+
+            char[] buffer = bufferPool.Rent(minSize);
+            return buffer;
+        }
+
+        public static void ReturnBuffer(IArrayPool<char>? bufferPool, char[]? buffer)
+        {
+            bufferPool?.Return(buffer);
+        }
+
+        public static char[] EnsureBufferSize(IArrayPool<char>? bufferPool, int size, char[]? buffer)
+        {
+            if (bufferPool == null)
+            {
+                return new char[size];
+            }
+
+            if (buffer != null)
+            {
+                bufferPool.Return(buffer);
+            }
+
+            return bufferPool.Rent(size);
+        }
+    }
+
+    internal static class JavaScriptUtils
+    {
+        internal static readonly bool[] SingleQuoteCharEscapeFlags = new bool[128];
+        internal static readonly bool[] DoubleQuoteCharEscapeFlags = new bool[128];
+        internal static readonly bool[] HtmlCharEscapeFlags = new bool[128];
+
+        private const int UnicodeTextLength = 6;
+
+        static JavaScriptUtils()
+        {
+            IList<char> escapeChars = new List<char>
+            {
+                '\n', '\r', '\t', '\\', '\f', '\b',
+            };
+            for (int i = 0; i < ' '; i++)
+            {
+                escapeChars.Add((char)i);
+            }
+
+            foreach (char escapeChar in escapeChars.Union(new[] { '\'' }))
+            {
+                SingleQuoteCharEscapeFlags[escapeChar] = true;
+            }
+            foreach (char escapeChar in escapeChars.Union(new[] { '"' }))
+            {
+                DoubleQuoteCharEscapeFlags[escapeChar] = true;
+            }
+            foreach (char escapeChar in escapeChars.Union(new[] { '"', '\'', '<', '>', '&' }))
+            {
+                HtmlCharEscapeFlags[escapeChar] = true;
+            }
+        }
+
+        private const string EscapedUnicodeText = "!";
+
+        public static bool[] GetCharEscapeFlags(StringEscapeHandling stringEscapeHandling, char quoteChar)
+        {
+            if (stringEscapeHandling == StringEscapeHandling.EscapeHtml)
+            {
+                return HtmlCharEscapeFlags;
+            }
+
+            if (quoteChar == '"')
+            {
+                return DoubleQuoteCharEscapeFlags;
+            }
+
+            return SingleQuoteCharEscapeFlags;
+        }
+
+        public static bool ShouldEscapeJavaScriptString(string? s, bool[] charEscapeFlags)
+        {
+            if (s == null)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < s.Length; i++)
+            {
+                char c = s[i];
+                if (c >= charEscapeFlags.Length || charEscapeFlags[c])
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static void WriteEscapedJavaScriptString(TextWriter writer, string? s, char delimiter, bool appendDelimiters,
+            bool[] charEscapeFlags, StringEscapeHandling stringEscapeHandling, IArrayPool<char>? bufferPool, ref char[]? writeBuffer)
+        {
+            // leading delimiter
+            if (appendDelimiters)
+            {
+                writer.Write(delimiter);
+            }
+
+            if (!StringUtils.IsNullOrEmpty(s))
+            {
+                int lastWritePosition = FirstCharToEscape(s, charEscapeFlags, stringEscapeHandling);
+                if (lastWritePosition == -1)
+                {
+                    writer.Write(s);
+                }
+                else
+                {
+                    if (lastWritePosition != 0)
+                    {
+                        if (writeBuffer == null || writeBuffer.Length < lastWritePosition)
+                        {
+                            writeBuffer = BufferUtils.EnsureBufferSize(bufferPool, lastWritePosition, writeBuffer);
+                        }
+
+                        // write unchanged chars at start of text.
+                        s.CopyTo(0, writeBuffer, 0, lastWritePosition);
+                        writer.Write(writeBuffer, 0, lastWritePosition);
+                    }
+
+                    int length;
+                    for (int i = lastWritePosition; i < s.Length; i++)
+                    {
+                        char c = s[i];
+
+                        if (c < charEscapeFlags.Length && !charEscapeFlags[c])
+                        {
+                            continue;
+                        }
+
+                        string? escapedValue;
+
+                        switch (c)
+                        {
+                            case '\t':
+                                escapedValue = @"\t";
+                                break;
+                            case '\n':
+                                escapedValue = @"\n";
+                                break;
+                            case '\r':
+                                escapedValue = @"\r";
+                                break;
+                            case '\f':
+                                escapedValue = @"\f";
+                                break;
+                            case '\b':
+                                escapedValue = @"\b";
+                                break;
+                            case '\\':
+                                escapedValue = @"\\";
+                                break;
+                            case '\u0085': // Next Line
+                                escapedValue = @"\u0085";
+                                break;
+                            case '\u2028': // Line Separator
+                                escapedValue = @"\u2028";
+                                break;
+                            case '\u2029': // Paragraph Separator
+                                escapedValue = @"\u2029";
+                                break;
+                            default:
+                                if (c < charEscapeFlags.Length || stringEscapeHandling == StringEscapeHandling.EscapeNonAscii)
+                                {
+                                    if (c == '\'' && stringEscapeHandling != StringEscapeHandling.EscapeHtml)
+                                    {
+                                        escapedValue = @"\'";
+                                    }
+                                    else if (c == '"' && stringEscapeHandling != StringEscapeHandling.EscapeHtml)
+                                    {
+                                        escapedValue = @"\""";
+                                    }
+                                    else
+                                    {
+                                        if (writeBuffer == null || writeBuffer.Length < UnicodeTextLength)
+                                        {
+                                            writeBuffer = BufferUtils.EnsureBufferSize(bufferPool, UnicodeTextLength, writeBuffer);
+                                        }
+
+                                        StringUtils.ToCharAsUnicode(c, writeBuffer!);
+
+                                        // slightly hacky but it saves multiple conditions in if test
+                                        escapedValue = EscapedUnicodeText;
+                                    }
+                                }
+                                else
+                                {
+                                    escapedValue = null;
+                                }
+                                break;
+                        }
+
+                        if (escapedValue == null)
+                        {
+                            continue;
+                        }
+
+                        bool isEscapedUnicodeText = string.Equals(escapedValue, EscapedUnicodeText, StringComparison.Ordinal);
+
+                        if (i > lastWritePosition)
+                        {
+                            length = i - lastWritePosition + ((isEscapedUnicodeText) ? UnicodeTextLength : 0);
+                            int start = (isEscapedUnicodeText) ? UnicodeTextLength : 0;
+
+                            if (writeBuffer == null || writeBuffer.Length < length)
+                            {
+                                char[] newBuffer = BufferUtils.RentBuffer(bufferPool, length);
+
+                                // the unicode text is already in the buffer
+                                // copy it over when creating new buffer
+                                if (isEscapedUnicodeText)
+                                {
+                                    MiscellaneousUtils.Assert(writeBuffer != null, "Write buffer should never be null because it is set when the escaped unicode text is encountered.");
+
+                                    Array.Copy(writeBuffer, newBuffer, UnicodeTextLength);
+                                }
+
+                                BufferUtils.ReturnBuffer(bufferPool, writeBuffer);
+
+                                writeBuffer = newBuffer;
+                            }
+
+                            s.CopyTo(lastWritePosition, writeBuffer, start, length - start);
+
+                            // write unchanged chars before writing escaped text
+                            writer.Write(writeBuffer, start, length - start);
+                        }
+
+                        lastWritePosition = i + 1;
+                        if (!isEscapedUnicodeText)
+                        {
+                            writer.Write(escapedValue);
+                        }
+                        else
+                        {
+                            writer.Write(writeBuffer, 0, UnicodeTextLength);
+                        }
+                    }
+
+                    MiscellaneousUtils.Assert(lastWritePosition != 0);
+                    length = s.Length - lastWritePosition;
+                    if (length > 0)
+                    {
+                        if (writeBuffer == null || writeBuffer.Length < length)
+                        {
+                            writeBuffer = BufferUtils.EnsureBufferSize(bufferPool, length, writeBuffer);
+                        }
+
+                        s.CopyTo(lastWritePosition, writeBuffer, 0, length);
+
+                        // write remaining text
+                        writer.Write(writeBuffer, 0, length);
+                    }
+                }
+            }
+
+            // trailing delimiter
+            if (appendDelimiters)
+            {
+                writer.Write(delimiter);
+            }
+        }
+
+        public static string ToEscapedJavaScriptString(string? value, char delimiter, bool appendDelimiters, StringEscapeHandling stringEscapeHandling)
+        {
+            bool[] charEscapeFlags = GetCharEscapeFlags(stringEscapeHandling, delimiter);
+
+            using (StringWriter w = StringUtils.CreateStringWriter(value?.Length ?? 16))
+            {
+                char[]? buffer = null;
+                WriteEscapedJavaScriptString(w, value, delimiter, appendDelimiters, charEscapeFlags, stringEscapeHandling, null, ref buffer);
+                return w.ToString();
+            }
+        }
+        
+        private static int FirstCharToEscape(string s, bool[] charEscapeFlags, StringEscapeHandling stringEscapeHandling)
+        {
+            for (int i = 0; i != s.Length; i++)
+            {
+                char c = s[i];
+
+                if (c < charEscapeFlags.Length)
+                {
+                    if (charEscapeFlags[c])
+                    {
+                        return i;
+                    }
+                }
+                else if (stringEscapeHandling == StringEscapeHandling.EscapeNonAscii)
+                {
+                    return i;
+                }
+                else
+                {
+                    switch (c)
+                    {
+                        case '\u0085':
+                        case '\u2028':
+                        case '\u2029':
+                            return i;
+                    }
+                }
+            }
+
+            return -1;
+        }
+
+#if HAVE_ASYNC
+        public static Task WriteEscapedJavaScriptStringAsync(TextWriter writer, string s, char delimiter, bool appendDelimiters, bool[] charEscapeFlags, StringEscapeHandling stringEscapeHandling, JsonTextWriter client, char[] writeBuffer, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return cancellationToken.FromCanceled();
+            }
+
+            if (appendDelimiters)
+            {
+                return WriteEscapedJavaScriptStringWithDelimitersAsync(writer, s, delimiter, charEscapeFlags, stringEscapeHandling, client, writeBuffer, cancellationToken);
+            }
+
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                return cancellationToken.CancelIfRequestedAsync() ?? AsyncUtils.CompletedTask;
+            }
+
+            return WriteEscapedJavaScriptStringWithoutDelimitersAsync(writer, s, charEscapeFlags, stringEscapeHandling, client, writeBuffer, cancellationToken);
+        }
+
+        private static Task WriteEscapedJavaScriptStringWithDelimitersAsync(TextWriter writer, string s, char delimiter,
+            bool[] charEscapeFlags, StringEscapeHandling stringEscapeHandling, JsonTextWriter client, char[] writeBuffer, CancellationToken cancellationToken)
+        {
+            Task task = writer.WriteAsync(delimiter, cancellationToken);
+            if (!task.IsCompletedSucessfully())
+            {
+                return WriteEscapedJavaScriptStringWithDelimitersAsync(task, writer, s, delimiter, charEscapeFlags, stringEscapeHandling, client, writeBuffer, cancellationToken);
+            }
+
+            if (!StringUtils.IsNullOrEmpty(s))
+            {
+                task = WriteEscapedJavaScriptStringWithoutDelimitersAsync(writer, s, charEscapeFlags, stringEscapeHandling, client, writeBuffer, cancellationToken);
+                if (task.IsCompletedSucessfully())
+                {
+                    return writer.WriteAsync(delimiter, cancellationToken);
+                }
+            }
+
+            return WriteCharAsync(task, writer, delimiter, cancellationToken);
+            
+        }
+
+        private static async Task WriteEscapedJavaScriptStringWithDelimitersAsync(Task task, TextWriter writer, string s, char delimiter,
+            bool[] charEscapeFlags, StringEscapeHandling stringEscapeHandling, JsonTextWriter client, char[] writeBuffer, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+
+            if (!StringUtils.IsNullOrEmpty(s))
+            {
+                await WriteEscapedJavaScriptStringWithoutDelimitersAsync(writer, s, charEscapeFlags, stringEscapeHandling, client, writeBuffer, cancellationToken).ConfigureAwait(false);
+            }
+
+            await writer.WriteAsync(delimiter).ConfigureAwait(false);
+        }
+
+        public static async Task WriteCharAsync(Task task, TextWriter writer, char c, CancellationToken cancellationToken)
+        {
+            await task.ConfigureAwait(false);
+            await writer.WriteAsync(c, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static Task WriteEscapedJavaScriptStringWithoutDelimitersAsync(
+            TextWriter writer, string s, bool[] charEscapeFlags, StringEscapeHandling stringEscapeHandling,
+            JsonTextWriter client, char[] writeBuffer, CancellationToken cancellationToken)
+        {
+            int i = FirstCharToEscape(s, charEscapeFlags, stringEscapeHandling);
+            return i == -1
+                ? writer.WriteAsync(s, cancellationToken)
+                : WriteDefinitelyEscapedJavaScriptStringWithoutDelimitersAsync(writer, s, i, charEscapeFlags, stringEscapeHandling, client, writeBuffer, cancellationToken);
+        }
+
+        private static async Task WriteDefinitelyEscapedJavaScriptStringWithoutDelimitersAsync(
+            TextWriter writer, string s, int lastWritePosition, bool[] charEscapeFlags,
+            StringEscapeHandling stringEscapeHandling, JsonTextWriter client, char[] writeBuffer,
+            CancellationToken cancellationToken)
+        {
+            if (writeBuffer == null || writeBuffer.Length < lastWritePosition)
+            {
+                writeBuffer = client.EnsureWriteBuffer(lastWritePosition, UnicodeTextLength);
+            }
+
+            if (lastWritePosition != 0)
+            {
+                s.CopyTo(0, writeBuffer, 0, lastWritePosition);
+
+                // write unchanged chars at start of text.
+                await writer.WriteAsync(writeBuffer, 0, lastWritePosition, cancellationToken).ConfigureAwait(false);
+            }
+
+            int length;
+            bool isEscapedUnicodeText = false;
+            string? escapedValue = null;
+
+            for (int i = lastWritePosition; i < s.Length; i++)
+            {
+                char c = s[i];
+
+                if (c < charEscapeFlags.Length && !charEscapeFlags[c])
+                {
+                    continue;
+                }
+
+                switch (c)
+                {
+                    case '\t':
+                        escapedValue = @"\t";
+                        break;
+                    case '\n':
+                        escapedValue = @"\n";
+                        break;
+                    case '\r':
+                        escapedValue = @"\r";
+                        break;
+                    case '\f':
+                        escapedValue = @"\f";
+                        break;
+                    case '\b':
+                        escapedValue = @"\b";
+                        break;
+                    case '\\':
+                        escapedValue = @"\\";
+                        break;
+                    case '\u0085': // Next Line
+                        escapedValue = @"\u0085";
+                        break;
+                    case '\u2028': // Line Separator
+                        escapedValue = @"\u2028";
+                        break;
+                    case '\u2029': // Paragraph Separator
+                        escapedValue = @"\u2029";
+                        break;
+                    default:
+                        if (c < charEscapeFlags.Length || stringEscapeHandling == StringEscapeHandling.EscapeNonAscii)
+                        {
+                            if (c == '\'' && stringEscapeHandling != StringEscapeHandling.EscapeHtml)
+                            {
+                                escapedValue = @"\'";
+                            }
+                            else if (c == '"' && stringEscapeHandling != StringEscapeHandling.EscapeHtml)
+                            {
+                                escapedValue = @"\""";
+                            }
+                            else
+                            {
+                                if (writeBuffer.Length < UnicodeTextLength)
+                                {
+                                    writeBuffer = client.EnsureWriteBuffer(UnicodeTextLength, 0);
+                                }
+
+                                StringUtils.ToCharAsUnicode(c, writeBuffer);
+
+                                isEscapedUnicodeText = true;
+                            }
+                        }
+                        else
+                        {
+                            continue;
+                        }
+                        break;
+                }
+
+                if (i > lastWritePosition)
+                {
+                    length = i - lastWritePosition + (isEscapedUnicodeText ? UnicodeTextLength : 0);
+                    int start = isEscapedUnicodeText ? UnicodeTextLength : 0;
+
+                    if (writeBuffer.Length < length)
+                    {
+                        writeBuffer = client.EnsureWriteBuffer(length, UnicodeTextLength);
+                    }
+
+                    s.CopyTo(lastWritePosition, writeBuffer, start, length - start);
+
+                    // write unchanged chars before writing escaped text
+                    await writer.WriteAsync(writeBuffer, start, length - start, cancellationToken).ConfigureAwait(false);
+                }
+
+                lastWritePosition = i + 1;
+                if (!isEscapedUnicodeText)
+                {
+                    await writer.WriteAsync(escapedValue!, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    await writer.WriteAsync(writeBuffer, 0, UnicodeTextLength, cancellationToken).ConfigureAwait(false);
+                    isEscapedUnicodeText = false;
+                }
+            }
+
+            length = s.Length - lastWritePosition;
+
+            if (length != 0)
+            {
+                if (writeBuffer.Length < length)
+                {
+                    writeBuffer = client.EnsureWriteBuffer(length, 0);
+                }
+
+                s.CopyTo(lastWritePosition, writeBuffer, 0, length);
+
+                // write remaining text
+                await writer.WriteAsync(writeBuffer, 0, length, cancellationToken).ConfigureAwait(false);
+            }
+        }
+#endif
+
+        public static bool TryGetDateFromConstructorJson(JsonReader reader, out DateTime dateTime, [NotNullWhen(false)]out string? errorMessage)
+        {
+            dateTime = default;
+            errorMessage = null;
+
+            if (!TryGetDateConstructorValue(reader, out long? t1, out errorMessage) || t1 == null)
+            {
+                errorMessage = errorMessage ?? "Date constructor has no arguments.";
+                return false;
+            }
+            if (!TryGetDateConstructorValue(reader, out long? t2, out errorMessage))
+            {
+                return false;
+            }
+            else if (t2 != null)
+            {
+                // Only create a list when there is more than one argument
+                List<long> dateArgs = new List<long>
+                {
+                    t1.Value,
+                    t2.Value
+                };
+                while (true)
+                {
+                    if (!TryGetDateConstructorValue(reader, out long? integer, out errorMessage))
+                    {
+                        return false;
+                    }
+                    else if (integer != null)
+                    {
+                        dateArgs.Add(integer.Value);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+
+                if (dateArgs.Count > 7)
+                {
+                    errorMessage = "Unexpected number of arguments when reading date constructor.";
+                    return false;
+                }
+
+                // Pad args out to the number used by the ctor
+                while (dateArgs.Count < 7)
+                {
+                    dateArgs.Add(0);
+                }
+
+                dateTime = new DateTime((int)dateArgs[0], (int)dateArgs[1] + 1, dateArgs[2] == 0 ? 1 : (int)dateArgs[2],
+                    (int)dateArgs[3], (int)dateArgs[4], (int)dateArgs[5], (int)dateArgs[6]);
+            }
+            else
+            {
+                dateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(t1.Value);
+            }
+
+            return true;
+        }
+
+        private static bool TryGetDateConstructorValue(JsonReader reader, out long? integer, [NotNullWhen(false)] out string? errorMessage)
+        {
+            integer = null;
+            errorMessage = null;
+
+            if (!reader.Read())
+            {
+                errorMessage = "Unexpected end when reading date constructor.";
+                return false;
+            }
+            if (reader.TokenType == JsonToken.EndConstructor)
+            {
+                return true;
+            }
+            if (reader.TokenType != JsonToken.Integer)
+            {
+                errorMessage = "Unexpected token when reading date constructor. Expected Integer, got " + reader.TokenType;
+                return false;
+            }
+
+            integer = (long)reader.Value!;
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/JsonTokenUtils.cs b/Libs/Newtonsoft.Json/Utilities/JsonTokenUtils.cs
new file mode 100644
index 0000000..5bf7148
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/JsonTokenUtils.cs
@@ -0,0 +1,74 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class JsonTokenUtils
+    {
+        internal static bool IsEndToken(JsonToken token)
+        {
+            switch (token)
+            {
+                case JsonToken.EndObject:
+                case JsonToken.EndArray:
+                case JsonToken.EndConstructor:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        internal static bool IsStartToken(JsonToken token)
+        {
+            switch (token)
+            {
+                case JsonToken.StartObject:
+                case JsonToken.StartArray:
+                case JsonToken.StartConstructor:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        internal static bool IsPrimitiveToken(JsonToken token)
+        {
+            switch (token)
+            {
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                case JsonToken.String:
+                case JsonToken.Boolean:
+                case JsonToken.Undefined:
+                case JsonToken.Null:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs b/Libs/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs
new file mode 100644
index 0000000..533cbd6
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs
@@ -0,0 +1,110 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using LC.Newtonsoft.Json.Serialization;
+using System.Reflection;
+
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class LateBoundReflectionDelegateFactory : ReflectionDelegateFactory
+    {
+        private static readonly LateBoundReflectionDelegateFactory _instance = new LateBoundReflectionDelegateFactory();
+
+        internal static ReflectionDelegateFactory Instance => _instance;
+
+        public override ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)
+        {
+            ValidationUtils.ArgumentNotNull(method, nameof(method));
+
+            if (method is ConstructorInfo c)
+            {
+                // don't convert to method group to avoid medium trust issues
+                // https://github.com/JamesNK/Newtonsoft.Json/issues/476
+                return a => c.Invoke(a);
+            }
+
+            return a => method.Invoke(null, a);
+        }
+
+        public override MethodCall<T, object?> CreateMethodCall<T>(MethodBase method)
+        {
+            ValidationUtils.ArgumentNotNull(method, nameof(method));
+
+            if (method is ConstructorInfo c)
+            {
+                return (o, a) => c.Invoke(a);
+            }
+
+            return (o, a) => method.Invoke(o, a);
+        }
+
+        public override Func<T> CreateDefaultConstructor<T>(Type type)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+
+            if (type.IsValueType())
+            {
+                return () => (T)Activator.CreateInstance(type);
+            }
+
+            ConstructorInfo constructorInfo = ReflectionUtils.GetDefaultConstructor(type, true);
+
+            return () => (T)constructorInfo.Invoke(null);
+        }
+
+        public override Func<T, object?> CreateGet<T>(PropertyInfo propertyInfo)
+        {
+            ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
+
+            return o => propertyInfo.GetValue(o, null);
+        }
+
+        public override Func<T, object?> CreateGet<T>(FieldInfo fieldInfo)
+        {
+            ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
+
+            return o => fieldInfo.GetValue(o);
+        }
+
+        public override Action<T, object?> CreateSet<T>(FieldInfo fieldInfo)
+        {
+            ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
+
+            return (o, v) => fieldInfo.SetValue(o, v);
+        }
+
+        public override Action<T, object?> CreateSet<T>(PropertyInfo propertyInfo)
+        {
+            ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
+
+            return (o, v) => propertyInfo.SetValue(o, v, null);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/LinqBridge.cs b/Libs/Newtonsoft.Json/Utilities/LinqBridge.cs
new file mode 100644
index 0000000..ff0749a
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/LinqBridge.cs
@@ -0,0 +1,3073 @@
+
+#if !HAVE_LINQ
+
+#region License, Terms and Author(s)
+//
+// LINQBridge
+// Copyright (c) 2007-9 Atif Aziz, Joseph Albahari. All rights reserved.
+//
+//  Author(s):
+//
+//      Atif Aziz, http://www.raboof.com
+//
+// This library is free software; you can redistribute it and/or modify it 
+// under the terms of the New BSD License, a copy of which should have 
+// been delivered along with this distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using LC.Newtonsoft.Json.Serialization;
+
+#nullable disable
+
+namespace LC.Newtonsoft.Json.Utilities.LinqBridge
+{
+  /// <summary>
+  /// Provides a set of static (Shared in Visual Basic) methods for 
+  /// querying objects that implement <see cref="IEnumerable{T}" />.
+  /// </summary>
+  internal static partial class Enumerable
+  {
+    /// <summary>
+    /// Returns the input typed as <see cref="IEnumerable{T}"/>.
+    /// </summary>
+
+    public static IEnumerable<TSource> AsEnumerable<TSource>(IEnumerable<TSource> source)
+    {
+      return source;
+    }
+
+    /// <summary>
+    /// Returns an empty <see cref="IEnumerable{T}"/> that has the 
+    /// specified type argument.
+    /// </summary>
+
+    public static IEnumerable<TResult> Empty<TResult>()
+    {
+      return Sequence<TResult>.Empty;
+    }
+
+    /// <summary>
+    /// Converts the elements of an <see cref="IEnumerable"/> to the 
+    /// specified type.
+    /// </summary>
+
+    public static IEnumerable<TResult> Cast<TResult>(
+      this IEnumerable source)
+    {
+      CheckNotNull(source, "source");
+
+        var servesItself = source as IEnumerable<TResult>;
+        if (servesItself != null
+            && (!(servesItself is TResult[]) || servesItself.GetType().GetElementType() == typeof(TResult)))
+        {
+            return servesItself;
+        }
+
+        return CastYield<TResult>(source);
+    }
+
+    private static IEnumerable<TResult> CastYield<TResult>(
+      IEnumerable source)
+    {
+      foreach (var item in source)
+        yield return (TResult) item;
+    }
+
+    /// <summary>
+    /// Filters the elements of an <see cref="IEnumerable"/> based on a specified type.
+    /// </summary>
+
+    public static IEnumerable<TResult> OfType<TResult>(
+      this IEnumerable source)
+    {
+      CheckNotNull(source, "source");
+
+      return OfTypeYield<TResult>(source);
+    }
+
+    private static IEnumerable<TResult> OfTypeYield<TResult>(
+      IEnumerable source)
+    {
+      foreach (var item in source)
+        if (item is TResult)
+          yield return (TResult) item;
+    }
+
+    /// <summary>
+    /// Generates a sequence of integral numbers within a specified range.
+    /// </summary>
+    /// <param name="start">The value of the first integer in the sequence.</param>
+    /// <param name="count">The number of sequential integers to generate.</param>
+
+    public static IEnumerable<int> Range(int start, int count)
+    {
+      if (count < 0)
+        throw new ArgumentOutOfRangeException("count", count, null);
+
+      var end = (long) start + count;
+      if (end - 1 >= int.MaxValue)
+        throw new ArgumentOutOfRangeException("count", count, null);
+
+      return RangeYield(start, end);
+    }
+
+    private static IEnumerable<int> RangeYield(int start, long end)
+    {
+      for (var i = start; i < end; i++)
+        yield return i;
+    }
+
+    /// <summary>
+    /// Generates a sequence that contains one repeated value.
+    /// </summary>
+
+    public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
+    {
+      if (count < 0) throw new ArgumentOutOfRangeException("count", count, null);
+
+      return RepeatYield(element, count);
+    }
+
+    private static IEnumerable<TResult> RepeatYield<TResult>(TResult element, int count)
+    {
+      for (var i = 0; i < count; i++)
+        yield return element;
+    }
+
+    /// <summary>
+    /// Filters a sequence of values based on a predicate.
+    /// </summary>
+
+    public static IEnumerable<TSource> Where<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      return WhereYield(source, predicate);
+    }
+
+    private static IEnumerable<TSource> WhereYield<TSource>(
+      IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      foreach (var item in source)
+        if (predicate(item))
+          yield return item;
+    }
+    /// <summary>
+    /// Filters a sequence of values based on a predicate. 
+    /// Each element's index is used in the logic of the predicate function.
+    /// </summary>
+
+    public static IEnumerable<TSource> Where<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      return WhereYield(source, predicate);
+    }
+
+    private static IEnumerable<TSource> WhereYield<TSource>(
+      IEnumerable<TSource> source,
+      Func<TSource, int, bool> predicate)
+    {
+      var i = 0;
+      foreach (var item in source)
+        if (predicate(item, i++))
+          yield return item;
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence into a new form.
+    /// </summary>
+
+    public static IEnumerable<TResult> Select<TSource, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TResult> selector)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(selector, "selector");
+
+      return SelectYield(source, selector);
+    }
+
+    private static IEnumerable<TResult> SelectYield<TSource, TResult>(
+      IEnumerable<TSource> source,
+      Func<TSource, TResult> selector)
+    {
+      foreach (var item in source)
+        yield return selector(item);
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence into a new form by 
+    /// incorporating the element's index.
+    /// </summary>
+
+    public static IEnumerable<TResult> Select<TSource, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, TResult> selector)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(selector, "selector");
+
+      return SelectYield(source, selector);
+    }
+
+    private static IEnumerable<TResult> SelectYield<TSource, TResult>(
+      IEnumerable<TSource> source,
+      Func<TSource, int, TResult> selector)
+    {
+      var i = 0;
+      foreach (var item in source)
+        yield return selector(item, i++);
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence to an <see cref="IEnumerable{T}" /> 
+    /// and flattens the resulting sequences into one sequence.
+    /// </summary>
+
+    public static IEnumerable<TResult> SelectMany<TSource, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, IEnumerable<TResult>> selector)
+    {
+      CheckNotNull(selector, "selector");
+
+      return source.SelectMany((item, i) => selector(item));
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence to an <see cref="IEnumerable{T}" />, 
+    /// and flattens the resulting sequences into one sequence. The 
+    /// index of each source element is used in the projected form of 
+    /// that element.
+    /// </summary>
+
+    public static IEnumerable<TResult> SelectMany<TSource, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, IEnumerable<TResult>> selector)
+    {
+      CheckNotNull(selector, "selector");
+
+      return source.SelectMany(selector, (item, subitem) => subitem);
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence to an <see cref="IEnumerable{T}" />, 
+    /// flattens the resulting sequences into one sequence, and invokes 
+    /// a result selector function on each element therein.
+    /// </summary>
+
+    public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, IEnumerable<TCollection>> collectionSelector,
+      Func<TSource, TCollection, TResult> resultSelector)
+    {
+      CheckNotNull(collectionSelector, "collectionSelector");
+
+      return source.SelectMany((item, i) => collectionSelector(item), resultSelector);
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence to an <see cref="IEnumerable{T}" />, 
+    /// flattens the resulting sequences into one sequence, and invokes 
+    /// a result selector function on each element therein. The index of 
+    /// each source element is used in the intermediate projected form 
+    /// of that element.
+    /// </summary>
+
+    public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, IEnumerable<TCollection>> collectionSelector,
+      Func<TSource, TCollection, TResult> resultSelector)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(collectionSelector, "collectionSelector");
+      CheckNotNull(resultSelector, "resultSelector");
+
+      return SelectManyYield(source, collectionSelector, resultSelector);
+    }
+
+    private static IEnumerable<TResult> SelectManyYield<TSource, TCollection, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, IEnumerable<TCollection>> collectionSelector,
+      Func<TSource, TCollection, TResult> resultSelector)
+    {
+      var i = 0;
+      foreach (var item in source)
+        foreach (var subitem in collectionSelector(item, i++))
+          yield return resultSelector(item, subitem);
+    }
+
+    /// <summary>
+    /// Returns elements from a sequence as long as a specified condition is true.
+    /// </summary>
+
+    public static IEnumerable<TSource> TakeWhile<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      CheckNotNull(predicate, "predicate");
+
+      return source.TakeWhile((item, i) => predicate(item));
+    }
+
+    /// <summary>
+    /// Returns elements from a sequence as long as a specified condition is true.
+    /// The element's index is used in the logic of the predicate function.
+    /// </summary>
+
+    public static IEnumerable<TSource> TakeWhile<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      return TakeWhileYield(source, predicate);
+    }
+
+    private static IEnumerable<TSource> TakeWhileYield<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, bool> predicate)
+    {
+      var i = 0;
+      foreach (var item in source)
+        if (predicate(item, i++))
+          yield return item;
+        else
+          break;
+    }
+
+    private static class Futures<T>
+    {
+      public static readonly Func<T> Default = () => default(T);
+      public static readonly Func<T> Undefined = () => { throw new InvalidOperationException(); };
+    }
+
+    /// <summary>
+    /// Base implementation of First operator.
+    /// </summary>
+
+    private static TSource FirstImpl<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource> empty)
+    {
+      CheckNotNull(source, "source");
+      MiscellaneousUtils.Assert(empty != null);
+
+      var list = source as IList<TSource>; // optimized case for lists
+      if (list != null)
+        return list.Count > 0 ? list[0] : empty();
+
+      using (var e = source.GetEnumerator()) // fallback for enumeration
+        return e.MoveNext() ? e.Current : empty();
+    }
+
+    /// <summary>
+    /// Returns the first element of a sequence.
+    /// </summary>
+
+    public static TSource First<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return source.FirstImpl(Futures<TSource>.Undefined);
+    }
+
+    /// <summary>
+    /// Returns the first element in a sequence that satisfies a specified condition.
+    /// </summary>
+
+    public static TSource First<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return First(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Returns the first element of a sequence, or a default value if 
+    /// the sequence contains no elements.
+    /// </summary>
+
+    public static TSource FirstOrDefault<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return source.FirstImpl(Futures<TSource>.Default);
+    }
+
+    /// <summary>
+    /// Returns the first element of the sequence that satisfies a 
+    /// condition or a default value if no such element is found.
+    /// </summary>
+
+    public static TSource FirstOrDefault<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return FirstOrDefault(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Base implementation of Last operator.
+    /// </summary>
+
+    private static TSource LastImpl<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource> empty)
+    {
+      CheckNotNull(source, "source");
+
+      var list = source as IList<TSource>; // optimized case for lists
+      if (list != null)
+        return list.Count > 0 ? list[list.Count - 1] : empty();
+
+      using (var e = source.GetEnumerator())
+      {
+        if (!e.MoveNext())
+          return empty();
+
+        var last = e.Current;
+        while (e.MoveNext())
+          last = e.Current;
+
+        return last;
+      }
+    }
+
+    /// <summary>
+    /// Returns the last element of a sequence.
+    /// </summary>
+    public static TSource Last<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return source.LastImpl(Futures<TSource>.Undefined);
+    }
+
+    /// <summary>
+    /// Returns the last element of a sequence that satisfies a 
+    /// specified condition.
+    /// </summary>
+
+    public static TSource Last<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return Last(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Returns the last element of a sequence, or a default value if 
+    /// the sequence contains no elements.
+    /// </summary>
+
+    public static TSource LastOrDefault<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return source.LastImpl(Futures<TSource>.Default);
+    }
+
+    /// <summary>
+    /// Returns the last element of a sequence that satisfies a 
+    /// condition or a default value if no such element is found.
+    /// </summary>
+
+    public static TSource LastOrDefault<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return LastOrDefault(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Base implementation of Single operator.
+    /// </summary>
+
+    private static TSource SingleImpl<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource> empty)
+    {
+      CheckNotNull(source, "source");
+
+      using (var e = source.GetEnumerator())
+      {
+        if (e.MoveNext())
+        {
+          var single = e.Current;
+          if (!e.MoveNext())
+            return single;
+
+          throw new InvalidOperationException();
+        }
+
+        return empty();
+      }
+    }
+
+    /// <summary>
+    /// Returns the only element of a sequence, and throws an exception 
+    /// if there is not exactly one element in the sequence.
+    /// </summary>
+
+    public static TSource Single<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return source.SingleImpl(Futures<TSource>.Undefined);
+    }
+
+    /// <summary>
+    /// Returns the only element of a sequence that satisfies a 
+    /// specified condition, and throws an exception if more than one 
+    /// such element exists.
+    /// </summary>
+
+    public static TSource Single<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return Single(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Returns the only element of a sequence, or a default value if 
+    /// the sequence is empty; this method throws an exception if there 
+    /// is more than one element in the sequence.
+    /// </summary>
+
+    public static TSource SingleOrDefault<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return source.SingleImpl(Futures<TSource>.Default);
+    }
+
+    /// <summary>
+    /// Returns the only element of a sequence that satisfies a 
+    /// specified condition or a default value if no such element 
+    /// exists; this method throws an exception if more than one element 
+    /// satisfies the condition.
+    /// </summary>
+
+    public static TSource SingleOrDefault<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return SingleOrDefault(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Returns the element at a specified index in a sequence.
+    /// </summary>
+
+    public static TSource ElementAt<TSource>(
+      this IEnumerable<TSource> source,
+      int index)
+    {
+      CheckNotNull(source, "source");
+
+      if (index < 0)
+        throw new ArgumentOutOfRangeException("index", index, null);
+
+      var list = source as IList<TSource>;
+      if (list != null)
+        return list[index];
+
+      try
+      {
+        return source.SkipWhile((item, i) => i < index).First();
+      }
+      catch (InvalidOperationException) // if thrown by First
+      {
+        throw new ArgumentOutOfRangeException("index", index, null);
+      }
+    }
+
+    /// <summary>
+    /// Returns the element at a specified index in a sequence or a 
+    /// default value if the index is out of range.
+    /// </summary>
+
+    public static TSource ElementAtOrDefault<TSource>(
+      this IEnumerable<TSource> source,
+      int index)
+    {
+      CheckNotNull(source, "source");
+
+      if (index < 0)
+        return default(TSource);
+
+      var list = source as IList<TSource>;
+      if (list != null)
+        return index < list.Count ? list[index] : default(TSource);
+
+      return source.SkipWhile((item, i) => i < index).FirstOrDefault();
+    }
+
+    /// <summary>
+    /// Inverts the order of the elements in a sequence.
+    /// </summary>
+
+    public static IEnumerable<TSource> Reverse<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      CheckNotNull(source, "source");
+
+      return ReverseYield(source);
+    }
+
+    private static IEnumerable<TSource> ReverseYield<TSource>(IEnumerable<TSource> source)
+    {
+      var stack = new Stack<TSource>(source);
+
+      foreach (var item in stack)
+        yield return item;
+    }
+
+    /// <summary>
+    /// Returns a specified number of contiguous elements from the start 
+    /// of a sequence.
+    /// </summary>
+
+    public static IEnumerable<TSource> Take<TSource>(
+      this IEnumerable<TSource> source,
+      int count)
+    {
+      return source.Where((item, i) => i < count);
+    }
+
+    /// <summary>
+    /// Bypasses a specified number of elements in a sequence and then 
+    /// returns the remaining elements.
+    /// </summary>
+
+    public static IEnumerable<TSource> Skip<TSource>(
+      this IEnumerable<TSource> source,
+      int count)
+    {
+      return source.Where((item, i) => i >= count);
+    }
+
+    /// <summary>
+    /// Bypasses elements in a sequence as long as a specified condition 
+    /// is true and then returns the remaining elements.
+    /// </summary>
+
+    public static IEnumerable<TSource> SkipWhile<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      CheckNotNull(predicate, "predicate");
+
+      return source.SkipWhile((item, i) => predicate(item));
+    }
+
+    /// <summary>
+    /// Bypasses elements in a sequence as long as a specified condition 
+    /// is true and then returns the remaining elements. The element's 
+    /// index is used in the logic of the predicate function.
+    /// </summary>
+
+    public static IEnumerable<TSource> SkipWhile<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      return SkipWhileYield(source, predicate);
+    }
+
+    private static IEnumerable<TSource> SkipWhileYield<TSource>(
+      IEnumerable<TSource> source,
+      Func<TSource, int, bool> predicate)
+    {
+      using (var e = source.GetEnumerator())
+      {
+        for (var i = 0;; i++)
+        {
+          if (!e.MoveNext())
+            yield break;
+
+          if (!predicate(e.Current, i))
+            break;
+        }
+
+        do
+        {
+          yield return e.Current;
+        } while (e.MoveNext());
+      }
+    }
+
+    /// <summary>
+    /// Returns the number of elements in a sequence.
+    /// </summary>
+
+    public static int Count<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      CheckNotNull(source, "source");
+
+      var collection = source as ICollection;
+      if (collection != null)
+      {
+        return collection.Count;
+      }
+
+      using (var en = source.GetEnumerator())
+      {
+        int count = 0;
+        while (en.MoveNext())
+        {
+          ++count;
+        }
+
+        return count;
+      }
+    }
+
+    /// <summary>
+    /// Returns a number that represents how many elements in the 
+    /// specified sequence satisfy a condition.
+    /// </summary>
+
+    public static int Count<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return Count(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Returns a <see cref="Int64"/> that represents the total number
+    /// of elements in a sequence.
+    /// </summary>
+
+    public static long LongCount<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      CheckNotNull(source, "source");
+
+      var array = source as Array;
+      return array != null
+               ? array.LongLength
+               : source.Aggregate(0L, (count, item) => count + 1);
+    }
+
+    /// <summary>
+    /// Returns a <see cref="Int64"/> that represents how many elements
+    /// in a sequence satisfy a condition.
+    /// </summary>
+
+    public static long LongCount<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      return LongCount(source.Where(predicate));
+    }
+
+    /// <summary>
+    /// Concatenates two sequences.
+    /// </summary>
+
+    public static IEnumerable<TSource> Concat<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second)
+    {
+      CheckNotNull(first, "first");
+      CheckNotNull(second, "second");
+
+      return ConcatYield(first, second);
+    }
+
+    private static IEnumerable<TSource> ConcatYield<TSource>(
+      IEnumerable<TSource> first,
+      IEnumerable<TSource> second)
+    {
+      foreach (var item in first)
+        yield return item;
+
+      foreach (var item in second)
+        yield return item;
+    }
+
+    /// <summary>
+    /// Creates a <see cref="List{T}"/> from an <see cref="IEnumerable{T}"/>.
+    /// </summary>
+
+    public static List<TSource> ToList<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      CheckNotNull(source, "source");
+
+      return new List<TSource>(source);
+    }
+
+      /// <summary>
+      /// Creates an array from an <see cref="IEnumerable{T}"/>.
+      /// </summary>
+
+      public static TSource[] ToArray<TSource>(
+        this IEnumerable<TSource> source)
+      {
+          IList<TSource> ilist = source as IList<TSource>;
+          if (ilist != null)
+          {
+              TSource[] array = new TSource[ilist.Count];
+              ilist.CopyTo(array, 0);
+              return array;
+          }
+
+          return source.ToList().ToArray();
+      }
+
+      /// <summary>
+    /// Returns distinct elements from a sequence by using the default 
+    /// equality comparer to compare values.
+    /// </summary>
+
+    public static IEnumerable<TSource> Distinct<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return Distinct(source, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Returns distinct elements from a sequence by using a specified 
+    /// <see cref="IEqualityComparer{T}"/> to compare values.
+    /// </summary>
+
+    public static IEnumerable<TSource> Distinct<TSource>(
+      this IEnumerable<TSource> source,
+      IEqualityComparer<TSource> comparer)
+    {
+      CheckNotNull(source, "source");
+
+      return DistinctYield(source, comparer);
+    }
+
+    private static IEnumerable<TSource> DistinctYield<TSource>(
+      IEnumerable<TSource> source,
+      IEqualityComparer<TSource> comparer)
+    {
+      var set = new Dictionary<TSource, object>(comparer);
+      var gotNull = false;
+
+      foreach (var item in source)
+      {
+        if (item == null)
+        {
+          if (gotNull)
+            continue;
+          gotNull = true;
+        }
+        else
+        {
+          if (set.ContainsKey(item))
+            continue;
+          set.Add(item, null);
+        }
+
+        yield return item;
+      }
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Lookup{TKey,TElement}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to a specified key 
+    /// selector function.
+    /// </summary>
+
+    public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector)
+    {
+      return ToLookup(source, keySelector, e => e, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Lookup{TKey,TElement}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to a specified key 
+    /// selector function and a key comparer.
+    /// </summary>
+
+    public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      return ToLookup(source, keySelector, e => e, comparer);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Lookup{TKey,TElement}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to specified key 
+    /// and element selector functions.
+    /// </summary>
+
+    public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector)
+    {
+      return ToLookup(source, keySelector, elementSelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Lookup{TKey,TElement}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to a specified key 
+    /// selector function, a comparer and an element selector function.
+    /// </summary>
+
+    public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(keySelector, "keySelector");
+      CheckNotNull(elementSelector, "elementSelector");
+
+      var lookup = new Lookup<TKey, TElement>(comparer);
+
+      foreach (var item in source)
+      {
+        var key = keySelector(item);
+
+        var grouping = (Grouping<TKey, TElement>) lookup.Find(key);
+        if (grouping == null)
+        {
+          grouping = new Grouping<TKey, TElement>(key);
+          lookup.Add(grouping);
+        }
+
+        grouping.Add(elementSelector(item));
+      }
+
+      return lookup;
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a specified key 
+    /// selector function.
+    /// </summary>
+
+    public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector)
+    {
+      return GroupBy(source, keySelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a specified key 
+    /// selector function and compares the keys by using a specified 
+    /// comparer.
+    /// </summary>
+
+    public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      return GroupBy(source, keySelector, e => e, comparer);
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a specified key 
+    /// selector function and projects the elements for each group by 
+    /// using a specified function.
+    /// </summary>
+
+    public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector)
+    {
+      return GroupBy(source, keySelector, elementSelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a specified key 
+    /// selector function and creates a result value from each group and 
+    /// its key.
+    /// </summary>
+
+    public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(keySelector, "keySelector");
+      CheckNotNull(elementSelector, "elementSelector");
+
+      return ToLookup(source, keySelector, elementSelector, comparer);
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a key selector 
+    /// function. The keys are compared by using a comparer and each 
+    /// group's elements are projected by using a specified function.
+    /// </summary>
+
+    public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TKey, IEnumerable<TSource>, TResult> resultSelector)
+    {
+      return GroupBy(source, keySelector, resultSelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a specified key 
+    /// selector function and creates a result value from each group and 
+    /// its key. The elements of each group are projected by using a 
+    /// specified function.
+    /// </summary>
+
+    public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TKey, IEnumerable<TSource>, TResult> resultSelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(keySelector, "keySelector");
+      CheckNotNull(resultSelector, "resultSelector");
+
+      return ToLookup(source, keySelector, comparer).Select(g => resultSelector(g.Key, g));
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a specified key 
+    /// selector function and creates a result value from each group and 
+    /// its key. The keys are compared by using a specified comparer.
+    /// </summary>
+
+    public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector,
+      Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
+    {
+      return GroupBy(source, keySelector, elementSelector, resultSelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Groups the elements of a sequence according to a specified key 
+    /// selector function and creates a result value from each group and 
+    /// its key. Key values are compared by using a specified comparer, 
+    /// and the elements of each group are projected by using a 
+    /// specified function.
+    /// </summary>
+
+    public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector,
+      Func<TKey, IEnumerable<TElement>, TResult> resultSelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(keySelector, "keySelector");
+      CheckNotNull(elementSelector, "elementSelector");
+      CheckNotNull(resultSelector, "resultSelector");
+
+      return ToLookup(source, keySelector, elementSelector, comparer)
+        .Select(g => resultSelector(g.Key, g));
+    }
+
+    /// <summary>
+    /// Applies an accumulator function over a sequence.
+    /// </summary>
+
+    public static TSource Aggregate<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TSource, TSource> func)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(func, "func");
+
+      using (var e = source.GetEnumerator())
+      {
+        if (!e.MoveNext())
+          throw new InvalidOperationException();
+
+        return e.Renumerable().Skip(1).Aggregate(e.Current, func);
+      }
+    }
+
+    /// <summary>
+    /// Applies an accumulator function over a sequence. The specified 
+    /// seed value is used as the initial accumulator value.
+    /// </summary>
+
+    public static TAccumulate Aggregate<TSource, TAccumulate>(
+      this IEnumerable<TSource> source,
+      TAccumulate seed,
+      Func<TAccumulate, TSource, TAccumulate> func)
+    {
+      return Aggregate(source, seed, func, r => r);
+    }
+
+    /// <summary>
+    /// Applies an accumulator function over a sequence. The specified 
+    /// seed value is used as the initial accumulator value, and the 
+    /// specified function is used to select the result value.
+    /// </summary>
+
+    public static TResult Aggregate<TSource, TAccumulate, TResult>(
+      this IEnumerable<TSource> source,
+      TAccumulate seed,
+      Func<TAccumulate, TSource, TAccumulate> func,
+      Func<TAccumulate, TResult> resultSelector)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(func, "func");
+      CheckNotNull(resultSelector, "resultSelector");
+
+      var result = seed;
+
+      foreach (var item in source)
+        result = func(result, item);
+
+      return resultSelector(result);
+    }
+
+    /// <summary>
+    /// Produces the set union of two sequences by using the default 
+    /// equality comparer.
+    /// </summary>
+
+    public static IEnumerable<TSource> Union<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second)
+    {
+      return Union(first, second, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Produces the set union of two sequences by using a specified 
+    /// <see cref="IEqualityComparer{T}" />.
+    /// </summary>
+
+    public static IEnumerable<TSource> Union<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second,
+      IEqualityComparer<TSource> comparer)
+    {
+      return first.Concat(second).Distinct(comparer);
+    }
+
+    /// <summary>
+    /// Returns the elements of the specified sequence or the type 
+    /// parameter's default value in a singleton collection if the 
+    /// sequence is empty.
+    /// </summary>
+
+    public static IEnumerable<TSource> DefaultIfEmpty<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      return source.DefaultIfEmpty(default(TSource));
+    }
+
+    /// <summary>
+    /// Returns the elements of the specified sequence or the specified 
+    /// value in a singleton collection if the sequence is empty.
+    /// </summary>
+
+    public static IEnumerable<TSource> DefaultIfEmpty<TSource>(
+      this IEnumerable<TSource> source,
+      TSource defaultValue)
+    {
+      CheckNotNull(source, "source");
+
+      return DefaultIfEmptyYield(source, defaultValue);
+    }
+
+    private static IEnumerable<TSource> DefaultIfEmptyYield<TSource>(
+      IEnumerable<TSource> source,
+      TSource defaultValue)
+    {
+      using (var e = source.GetEnumerator())
+      {
+        if (!e.MoveNext())
+          yield return defaultValue;
+        else
+          do
+          {
+            yield return e.Current;
+          } while (e.MoveNext());
+      }
+    }
+
+    /// <summary>
+    /// Determines whether all elements of a sequence satisfy a condition.
+    /// </summary>
+
+    public static bool All<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      foreach (var item in source)
+        if (!predicate(item))
+          return false;
+
+      return true;
+    }
+
+    /// <summary>
+    /// Determines whether a sequence contains any elements.
+    /// </summary>
+
+    public static bool Any<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      CheckNotNull(source, "source");
+
+      using (var e = source.GetEnumerator())
+        return e.MoveNext();
+    }
+
+    /// <summary>
+    /// Determines whether any element of a sequence satisfies a 
+    /// condition.
+    /// </summary>
+
+    public static bool Any<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, bool> predicate)
+    {
+      foreach (TSource item in source)
+      {
+        if (predicate(item))
+        {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    /// <summary>
+    /// Determines whether a sequence contains a specified element by 
+    /// using the default equality comparer.
+    /// </summary>
+
+    public static bool Contains<TSource>(
+      this IEnumerable<TSource> source,
+      TSource value)
+    {
+      return source.Contains(value, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Determines whether a sequence contains a specified element by 
+    /// using a specified <see cref="IEqualityComparer{T}" />.
+    /// </summary>
+
+    public static bool Contains<TSource>(
+      this IEnumerable<TSource> source,
+      TSource value,
+      IEqualityComparer<TSource> comparer)
+    {
+      CheckNotNull(source, "source");
+
+      if (comparer == null)
+      {
+        var collection = source as ICollection<TSource>;
+        if (collection != null)
+          return collection.Contains(value);
+      }
+
+      comparer = comparer ?? EqualityComparer<TSource>.Default;
+      return source.Any(item => comparer.Equals(item, value));
+    }
+
+    /// <summary>
+    /// Determines whether two sequences are equal by comparing the 
+    /// elements by using the default equality comparer for their type.
+    /// </summary>
+
+    public static bool SequenceEqual<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second)
+    {
+      return first.SequenceEqual(second, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Determines whether two sequences are equal by comparing their 
+    /// elements by using a specified <see cref="IEqualityComparer{T}" />.
+    /// </summary>
+
+    public static bool SequenceEqual<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second,
+      IEqualityComparer<TSource> comparer)
+    {
+      CheckNotNull(first, "first");
+      CheckNotNull(second, "second");
+
+      comparer = comparer ?? EqualityComparer<TSource>.Default;
+
+      using (IEnumerator<TSource> lhs = first.GetEnumerator(),
+                                  rhs = second.GetEnumerator())
+      {
+        do
+        {
+          if (!lhs.MoveNext())
+            return !rhs.MoveNext();
+
+          if (!rhs.MoveNext())
+            return false;
+        } while (comparer.Equals(lhs.Current, rhs.Current));
+      }
+
+      return false;
+    }
+
+    /// <summary>
+    /// Base implementation for Min/Max operator.
+    /// </summary>
+
+    private static TSource MinMaxImpl<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TSource, bool> lesser)
+    {
+      CheckNotNull(source, "source");
+      MiscellaneousUtils.Assert(lesser != null);
+
+      return source.Aggregate((a, item) => lesser(a, item) ? a : item);
+    }
+
+    /// <summary>
+    /// Base implementation for Min/Max operator for nullable types.
+    /// </summary>
+
+    private static TSource? MinMaxImpl<TSource>(
+      this IEnumerable<TSource?> source,
+      TSource? seed, Func<TSource?, TSource?, bool> lesser) where TSource : struct
+    {
+      CheckNotNull(source, "source");
+      MiscellaneousUtils.Assert(lesser != null);
+
+      return source.Aggregate(seed, (a, item) => lesser(a, item) ? a : item);
+      //  == MinMaxImpl(Repeat<TSource?>(null, 1).Concat(source), lesser);
+    }
+
+    /// <summary>
+    /// Returns the minimum value in a generic sequence.
+    /// </summary>
+
+    public static TSource Min<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      var comparer = Comparer<TSource>.Default;
+      return source.MinMaxImpl((x, y) => comparer.Compare(x, y) < 0);
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a generic 
+    /// sequence and returns the minimum resulting value.
+    /// </summary>
+
+    public static TResult Min<TSource, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TResult> selector)
+    {
+      return source.Select(selector).Min();
+    }
+
+    /// <summary>
+    /// Returns the maximum value in a generic sequence.
+    /// </summary>
+
+    public static TSource Max<TSource>(
+      this IEnumerable<TSource> source)
+    {
+      var comparer = Comparer<TSource>.Default;
+      return source.MinMaxImpl((x, y) => comparer.Compare(x, y) > 0);
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a generic 
+    /// sequence and returns the maximum resulting value.
+    /// </summary>
+
+    public static TResult Max<TSource, TResult>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TResult> selector)
+    {
+      return source.Select(selector).Max();
+    }
+
+    /// <summary>
+    /// Makes an enumerator seen as enumerable once more.
+    /// </summary>
+    /// <remarks>
+    /// The supplied enumerator must have been started. The first element
+    /// returned is the element the enumerator was on when passed in.
+    /// DO NOT use this method if the caller must be a generator. It is
+    /// mostly safe among aggregate operations.
+    /// </remarks>
+
+    private static IEnumerable<T> Renumerable<T>(this IEnumerator<T> e)
+    {
+      MiscellaneousUtils.Assert(e != null);
+
+      do
+      {
+        yield return e.Current;
+      } while (e.MoveNext());
+    }
+
+    /// <summary>
+    /// Sorts the elements of a sequence in ascending order according to a key.
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector)
+    {
+      return source.OrderBy(keySelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Sorts the elements of a sequence in ascending order by using a 
+    /// specified comparer.
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(keySelector, "keySelector");
+
+      return new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, /* descending */ false);
+    }
+
+    /// <summary>
+    /// Sorts the elements of a sequence in descending order according to a key.
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector)
+    {
+      return source.OrderByDescending(keySelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    ///  Sorts the elements of a sequence in descending order by using a 
+    /// specified comparer. 
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(source, "keySelector");
+
+      return new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, /* descending */ true);
+    }
+
+    /// <summary>
+    /// Performs a subsequent ordering of the elements in a sequence in 
+    /// ascending order according to a key.
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(
+      this IOrderedEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector)
+    {
+      return source.ThenBy(keySelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Performs a subsequent ordering of the elements in a sequence in 
+    /// ascending order by using a specified comparer.
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(
+      this IOrderedEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+
+      return source.CreateOrderedEnumerable(keySelector, comparer, /* descending */ false);
+    }
+
+    /// <summary>
+    /// Performs a subsequent ordering of the elements in a sequence in 
+    /// descending order, according to a key.
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(
+      this IOrderedEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector)
+    {
+      return source.ThenByDescending(keySelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Performs a subsequent ordering of the elements in a sequence in 
+    /// descending order by using a specified comparer.
+    /// </summary>
+
+    public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(
+      this IOrderedEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+
+      return source.CreateOrderedEnumerable(keySelector, comparer, /* descending */ true);
+    }
+
+    /// <summary>
+    /// Base implementation for Intersect and Except operators.
+    /// </summary>
+
+    private static IEnumerable<TSource> IntersectExceptImpl<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second,
+      IEqualityComparer<TSource> comparer,
+      bool flag)
+    {
+      CheckNotNull(first, "first");
+      CheckNotNull(second, "second");
+
+      var keys = new List<TSource>();
+      var flags = new Dictionary<TSource, bool>(comparer);
+
+      foreach (var item in first.Where(k => !flags.ContainsKey(k)))
+      {
+        flags.Add(item, !flag);
+        keys.Add(item);
+      }
+
+      foreach (var item in second.Where(flags.ContainsKey))
+        flags[item] = flag;
+
+      //
+      // As per docs, "the marked elements are yielded in the order in 
+      // which they were collected.
+      //
+
+      return keys.Where(item => flags[item]);
+    }
+
+    /// <summary>
+    /// Produces the set intersection of two sequences by using the 
+    /// default equality comparer to compare values.
+    /// </summary>
+
+    public static IEnumerable<TSource> Intersect<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second)
+    {
+      return first.Intersect(second, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Produces the set intersection of two sequences by using the 
+    /// specified <see cref="IEqualityComparer{T}" /> to compare values.
+    /// </summary>
+
+    public static IEnumerable<TSource> Intersect<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second,
+      IEqualityComparer<TSource> comparer)
+    {
+      return IntersectExceptImpl(first, second, comparer, /* flag */ true);
+    }
+
+    /// <summary>
+    /// Produces the set difference of two sequences by using the 
+    /// default equality comparer to compare values.
+    /// </summary>
+
+    public static IEnumerable<TSource> Except<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second)
+    {
+      return first.Except(second, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Produces the set difference of two sequences by using the 
+    /// specified <see cref="IEqualityComparer{T}" /> to compare values.
+    /// </summary>
+
+    public static IEnumerable<TSource> Except<TSource>(
+      this IEnumerable<TSource> first,
+      IEnumerable<TSource> second,
+      IEqualityComparer<TSource> comparer)
+    {
+      return IntersectExceptImpl(first, second, comparer, /* flag */ false);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey,TValue}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to a specified key 
+    /// selector function.
+    /// </summary>
+
+    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector)
+    {
+      return source.ToDictionary(keySelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey,TValue}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to a specified key 
+    /// selector function and key comparer.
+    /// </summary>
+
+    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      return source.ToDictionary(keySelector, e => e);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey,TValue}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to specified key 
+    /// selector and element selector functions.
+    /// </summary>
+
+    public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector)
+    {
+      return source.ToDictionary(keySelector, elementSelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey,TValue}" /> from an 
+    /// <see cref="IEnumerable{T}" /> according to a specified key 
+    /// selector function, a comparer, and an element selector function.
+    /// </summary>
+
+    public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TElement> elementSelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(keySelector, "keySelector");
+      CheckNotNull(elementSelector, "elementSelector");
+
+      var dict = new Dictionary<TKey, TElement>(comparer);
+
+      foreach (var item in source)
+      {
+        //
+        // ToDictionary is meant to throw ArgumentNullException if
+        // keySelector produces a key that is null and 
+        // Argument exception if keySelector produces duplicate keys 
+        // for two elements. Incidentally, the documentation for
+        // IDictionary<TKey, TValue>.Add says that the Add method
+        // throws the same exceptions under the same circumstances
+        // so we don't need to do any additional checking or work
+        // here and let the Add implementation do all the heavy
+        // lifting.
+        //
+
+        dict.Add(keySelector(item), elementSelector(item));
+      }
+
+      return dict;
+    }
+
+    /// <summary>
+    /// Correlates the elements of two sequences based on matching keys. 
+    /// The default equality comparer is used to compare keys.
+    /// </summary>
+
+    public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
+      this IEnumerable<TOuter> outer,
+      IEnumerable<TInner> inner,
+      Func<TOuter, TKey> outerKeySelector,
+      Func<TInner, TKey> innerKeySelector,
+      Func<TOuter, TInner, TResult> resultSelector)
+    {
+      return outer.Join(inner, outerKeySelector, innerKeySelector, resultSelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Correlates the elements of two sequences based on matching keys. 
+    /// The default equality comparer is used to compare keys. A 
+    /// specified <see cref="IEqualityComparer{T}" /> is used to compare keys.
+    /// </summary>
+
+    public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
+      this IEnumerable<TOuter> outer,
+      IEnumerable<TInner> inner,
+      Func<TOuter, TKey> outerKeySelector,
+      Func<TInner, TKey> innerKeySelector,
+      Func<TOuter, TInner, TResult> resultSelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      CheckNotNull(outer, "outer");
+      CheckNotNull(inner, "inner");
+      CheckNotNull(outerKeySelector, "outerKeySelector");
+      CheckNotNull(innerKeySelector, "innerKeySelector");
+      CheckNotNull(resultSelector, "resultSelector");
+
+      var lookup = inner.ToLookup(innerKeySelector, comparer);
+
+      return
+        from o in outer
+        from i in lookup[outerKeySelector(o)]
+        select resultSelector(o, i);
+    }
+
+    /// <summary>
+    /// Correlates the elements of two sequences based on equality of 
+    /// keys and groups the results. The default equality comparer is 
+    /// used to compare keys.
+    /// </summary>
+
+    public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
+      this IEnumerable<TOuter> outer,
+      IEnumerable<TInner> inner,
+      Func<TOuter, TKey> outerKeySelector,
+      Func<TInner, TKey> innerKeySelector,
+      Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
+    {
+      return outer.GroupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, /* comparer */ null);
+    }
+
+    /// <summary>
+    /// Correlates the elements of two sequences based on equality of 
+    /// keys and groups the results. The default equality comparer is 
+    /// used to compare keys. A specified <see cref="IEqualityComparer{T}" /> 
+    /// is used to compare keys.
+    /// </summary>
+
+    public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
+      this IEnumerable<TOuter> outer,
+      IEnumerable<TInner> inner,
+      Func<TOuter, TKey> outerKeySelector,
+      Func<TInner, TKey> innerKeySelector,
+      Func<TOuter, IEnumerable<TInner>, TResult> resultSelector,
+      IEqualityComparer<TKey> comparer)
+    {
+      CheckNotNull(outer, "outer");
+      CheckNotNull(inner, "inner");
+      CheckNotNull(outerKeySelector, "outerKeySelector");
+      CheckNotNull(innerKeySelector, "innerKeySelector");
+      CheckNotNull(resultSelector, "resultSelector");
+
+      var lookup = inner.ToLookup(innerKeySelector, comparer);
+      return outer.Select(o => resultSelector(o, lookup[outerKeySelector(o)]));
+    }
+
+    [DebuggerStepThrough]
+    private static void CheckNotNull<T>(T value, string name) where T : class
+    {
+      if (value == null)
+        throw new ArgumentNullException(name);
+    }
+
+    private static class Sequence<T>
+    {
+      public static readonly IEnumerable<T> Empty = new T[0];
+    }
+
+    private sealed class Grouping<K, V> : List<V>, IGrouping<K, V>
+    {
+      internal Grouping(K key)
+      {
+        Key = key;
+      }
+
+      public K Key { get; private set; }
+    }
+  }
+
+  internal partial class Enumerable
+  {
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Int32" /> values.
+    /// </summary>
+
+    public static int Sum(
+      this IEnumerable<int> source)
+    {
+      CheckNotNull(source, "source");
+
+      int sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + num);
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Int32" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static int Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Int32" /> values.
+    /// </summary>
+
+    public static double Average(
+      this IEnumerable<int> source)
+    {
+      CheckNotNull(source, "source");
+
+      long sum = 0;
+      long count = 0;
+
+      foreach (var num in source)
+        checked
+        {
+          sum += (int) num;
+          count++;
+        }
+
+      if (count == 0)
+        throw new InvalidOperationException();
+
+      return (double) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Int32" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static double Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Int32" /> values.
+    /// </summary>
+
+    public static int? Sum(
+      this IEnumerable<int?> source)
+    {
+      CheckNotNull(source, "source");
+
+      int sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + (num ?? 0));
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Int32" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static int? Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int?> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Int32" /> values.
+    /// </summary>
+
+    public static double? Average(
+      this IEnumerable<int?> source)
+    {
+      CheckNotNull(source, "source");
+
+      long sum = 0;
+      long count = 0;
+
+      foreach (var num in source.Where(n => n != null))
+        checked
+        {
+          sum += (int) num;
+          count++;
+        }
+
+      if (count == 0)
+        return null;
+
+      return (double?) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Int32" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static double? Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int?> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+    /// <summary>
+    /// Returns the minimum value in a sequence of nullable 
+    /// <see cref="System.Int32" /> values.
+    /// </summary>
+
+    public static int? Min(
+      this IEnumerable<int?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null), null, (min, x) => min < x);
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the minimum nullable <see cref="System.Int32" /> value.
+    /// </summary>
+
+    public static int? Min<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int?> selector)
+    {
+      return source.Select(selector).Min();
+    }
+
+    /// <summary>
+    /// Returns the maximum value in a sequence of nullable 
+    /// <see cref="System.Int32" /> values.
+    /// </summary>
+
+    public static int? Max(
+      this IEnumerable<int?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null),
+                        null, (max, x) => x == null || (max != null && x.Value < max.Value));
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the maximum nullable <see cref="System.Int32" /> value.
+    /// </summary>
+
+    public static int? Max<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, int?> selector)
+    {
+      return source.Select(selector).Max();
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Int64" /> values.
+    /// </summary>
+
+    public static long Sum(
+      this IEnumerable<long> source)
+    {
+      CheckNotNull(source, "source");
+
+      long sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + num);
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Int64" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static long Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, long> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Int64" /> values.
+    /// </summary>
+
+    public static double Average(
+      this IEnumerable<long> source)
+    {
+      CheckNotNull(source, "source");
+
+      long sum = 0;
+      long count = 0;
+
+      foreach (var num in source)
+        checked
+        {
+          sum += (long) num;
+          count++;
+        }
+
+      if (count == 0)
+        throw new InvalidOperationException();
+
+      return (double) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Int64" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static double Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, long> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Int64" /> values.
+    /// </summary>
+
+    public static long? Sum(
+      this IEnumerable<long?> source)
+    {
+      CheckNotNull(source, "source");
+
+      long sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + (num ?? 0));
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Int64" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static long? Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, long?> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Int64" /> values.
+    /// </summary>
+
+    public static double? Average(
+      this IEnumerable<long?> source)
+    {
+      CheckNotNull(source, "source");
+
+      long sum = 0;
+      long count = 0;
+
+      foreach (var num in source.Where(n => n != null))
+        checked
+        {
+          sum += (long) num;
+          count++;
+        }
+
+      if (count == 0)
+        return null;
+
+      return (double?) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Int64" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static double? Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, long?> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+    /// <summary>
+    /// Returns the minimum value in a sequence of nullable 
+    /// <see cref="System.Int64" /> values.
+    /// </summary>
+
+    public static long? Min(
+      this IEnumerable<long?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null), null, (min, x) => min < x);
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the minimum nullable <see cref="System.Int64" /> value.
+    /// </summary>
+
+    public static long? Min<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, long?> selector)
+    {
+      return source.Select(selector).Min();
+    }
+
+    /// <summary>
+    /// Returns the maximum value in a sequence of nullable 
+    /// <see cref="System.Int64" /> values.
+    /// </summary>
+
+    public static long? Max(
+      this IEnumerable<long?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null),
+                        null, (max, x) => x == null || (max != null && x.Value < max.Value));
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the maximum nullable <see cref="System.Int64" /> value.
+    /// </summary>
+
+    public static long? Max<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, long?> selector)
+    {
+      return source.Select(selector).Max();
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Single" /> values.
+    /// </summary>
+
+    public static float Sum(
+      this IEnumerable<float> source)
+    {
+      CheckNotNull(source, "source");
+
+      float sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + num);
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Single" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static float Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, float> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Single" /> values.
+    /// </summary>
+
+    public static float Average(
+      this IEnumerable<float> source)
+    {
+      CheckNotNull(source, "source");
+
+      float sum = 0;
+      long count = 0;
+
+      foreach (var num in source)
+        checked
+        {
+          sum += (float) num;
+          count++;
+        }
+
+      if (count == 0)
+        throw new InvalidOperationException();
+
+      return (float) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Single" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static float Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, float> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Single" /> values.
+    /// </summary>
+
+    public static float? Sum(
+      this IEnumerable<float?> source)
+    {
+      CheckNotNull(source, "source");
+
+      float sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + (num ?? 0));
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Single" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static float? Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, float?> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Single" /> values.
+    /// </summary>
+
+    public static float? Average(
+      this IEnumerable<float?> source)
+    {
+      CheckNotNull(source, "source");
+
+      float sum = 0;
+      long count = 0;
+
+      foreach (var num in source.Where(n => n != null))
+        checked
+        {
+          sum += (float) num;
+          count++;
+        }
+
+      if (count == 0)
+        return null;
+
+      return (float?) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Single" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static float? Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, float?> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+    /// <summary>
+    /// Returns the minimum value in a sequence of nullable 
+    /// <see cref="System.Single" /> values.
+    /// </summary>
+
+    public static float? Min(
+      this IEnumerable<float?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null), null, (min, x) => min < x);
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the minimum nullable <see cref="System.Single" /> value.
+    /// </summary>
+
+    public static float? Min<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, float?> selector)
+    {
+      return source.Select(selector).Min();
+    }
+
+    /// <summary>
+    /// Returns the maximum value in a sequence of nullable 
+    /// <see cref="System.Single" /> values.
+    /// </summary>
+
+    public static float? Max(
+      this IEnumerable<float?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null),
+                        null, (max, x) => x == null || (max != null && x.Value < max.Value));
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the maximum nullable <see cref="System.Single" /> value.
+    /// </summary>
+
+    public static float? Max<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, float?> selector)
+    {
+      return source.Select(selector).Max();
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Double" /> values.
+    /// </summary>
+
+    public static double Sum(
+      this IEnumerable<double> source)
+    {
+      CheckNotNull(source, "source");
+
+      double sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + num);
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Double" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static double Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, double> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Double" /> values.
+    /// </summary>
+
+    public static double Average(
+      this IEnumerable<double> source)
+    {
+      CheckNotNull(source, "source");
+
+      double sum = 0;
+      long count = 0;
+
+      foreach (var num in source)
+        checked
+        {
+          sum += (double) num;
+          count++;
+        }
+
+      if (count == 0)
+        throw new InvalidOperationException();
+
+      return (double) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Double" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static double Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, double> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Double" /> values.
+    /// </summary>
+
+    public static double? Sum(
+      this IEnumerable<double?> source)
+    {
+      CheckNotNull(source, "source");
+
+      double sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + (num ?? 0));
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Double" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static double? Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, double?> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Double" /> values.
+    /// </summary>
+
+    public static double? Average(
+      this IEnumerable<double?> source)
+    {
+      CheckNotNull(source, "source");
+
+      double sum = 0;
+      long count = 0;
+
+      foreach (var num in source.Where(n => n != null))
+        checked
+        {
+          sum += (double) num;
+          count++;
+        }
+
+      if (count == 0)
+        return null;
+
+      return (double?) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Double" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static double? Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, double?> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+    /// <summary>
+    /// Returns the minimum value in a sequence of nullable 
+    /// <see cref="System.Double" /> values.
+    /// </summary>
+
+    public static double? Min(
+      this IEnumerable<double?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null), null, (min, x) => min < x);
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the minimum nullable <see cref="System.Double" /> value.
+    /// </summary>
+
+    public static double? Min<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, double?> selector)
+    {
+      return source.Select(selector).Min();
+    }
+
+    /// <summary>
+    /// Returns the maximum value in a sequence of nullable 
+    /// <see cref="System.Double" /> values.
+    /// </summary>
+
+    public static double? Max(
+      this IEnumerable<double?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null),
+                        null, (max, x) => x == null || (max != null && x.Value < max.Value));
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the maximum nullable <see cref="System.Double" /> value.
+    /// </summary>
+
+    public static double? Max<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, double?> selector)
+    {
+      return source.Select(selector).Max();
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Decimal" /> values.
+    /// </summary>
+
+    public static decimal Sum(
+      this IEnumerable<decimal> source)
+    {
+      CheckNotNull(source, "source");
+
+      decimal sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + num);
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of <see cref="System.Decimal" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static decimal Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, decimal> selector)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(selector, "selector");
+
+      decimal sum = 0;
+      foreach (TSource item in source)
+      {
+        sum += selector(item);
+      }
+
+        return sum;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Decimal" /> values.
+    /// </summary>
+
+    public static decimal Average(
+      this IEnumerable<decimal> source)
+    {
+      CheckNotNull(source, "source");
+
+      decimal sum = 0;
+      long count = 0;
+
+      foreach (var num in source)
+        checked
+        {
+          sum += (decimal) num;
+          count++;
+        }
+
+      if (count == 0)
+        throw new InvalidOperationException();
+
+      return (decimal) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of <see cref="System.Decimal" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static decimal Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, decimal> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Decimal" /> values.
+    /// </summary>
+
+    public static decimal? Sum(
+      this IEnumerable<decimal?> source)
+    {
+      CheckNotNull(source, "source");
+
+      decimal sum = 0;
+      foreach (var num in source)
+        sum = checked(sum + (num ?? 0));
+
+      return sum;
+    }
+
+    /// <summary>
+    /// Computes the sum of a sequence of nullable <see cref="System.Decimal" />
+    /// values that are obtained by invoking a transform function on 
+    /// each element of the input sequence.
+    /// </summary>
+
+    public static decimal? Sum<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, decimal?> selector)
+    {
+      return source.Select(selector).Sum();
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Decimal" /> values.
+    /// </summary>
+
+    public static decimal? Average(
+      this IEnumerable<decimal?> source)
+    {
+      CheckNotNull(source, "source");
+
+      decimal sum = 0;
+      long count = 0;
+
+      foreach (var num in source.Where(n => n != null))
+        checked
+        {
+          sum += (decimal) num;
+          count++;
+        }
+
+      if (count == 0)
+        return null;
+
+      return (decimal?) sum/count;
+    }
+
+    /// <summary>
+    /// Computes the average of a sequence of nullable <see cref="System.Decimal" /> values
+    /// that are obtained by invoking a transform function on each 
+    /// element of the input sequence.
+    /// </summary>
+
+    public static decimal? Average<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, decimal?> selector)
+    {
+      return source.Select(selector).Average();
+    }
+
+    /// <summary>
+    /// Returns the minimum value in a sequence of nullable 
+    /// <see cref="System.Decimal" /> values.
+    /// </summary>
+
+    public static decimal? Min(
+      this IEnumerable<decimal?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null), null, (min, x) => min < x);
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the minimum nullable <see cref="System.Decimal" /> value.
+    /// </summary>
+
+    public static decimal? Min<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, decimal?> selector)
+    {
+      return source.Select(selector).Min();
+    }
+
+    /// <summary>
+    /// Returns the maximum value in a sequence of nullable 
+    /// <see cref="System.Decimal" /> values.
+    /// </summary>
+
+    public static decimal? Max(
+      this IEnumerable<decimal?> source)
+    {
+      CheckNotNull(source, "source");
+
+      return MinMaxImpl(source.Where(x => x != null),
+                        null, (max, x) => x == null || (max != null && x.Value < max.Value));
+    }
+
+    /// <summary>
+    /// Invokes a transform function on each element of a sequence and 
+    /// returns the maximum nullable <see cref="System.Decimal" /> value.
+    /// </summary>
+
+    public static decimal? Max<TSource>(
+      this IEnumerable<TSource> source,
+      Func<TSource, decimal?> selector)
+    {
+      return source.Select(selector).Max();
+    }
+  }
+
+  /// <summary>
+  /// Represents a collection of objects that have a common key.
+  /// </summary>
+  internal partial interface IGrouping<TKey, TElement> : IEnumerable<TElement>
+  {
+    /// <summary>
+    /// Gets the key of the <see cref="IGrouping{TKey,TElement}" />.
+    /// </summary>
+
+    TKey Key { get; }
+  }
+
+  /// <summary>
+  /// Defines an indexer, size property, and Boolean search method for 
+  /// data structures that map keys to <see cref="IEnumerable{T}"/> 
+  /// sequences of values.
+  /// </summary>
+  internal partial interface ILookup<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
+  {
+    bool Contains(TKey key);
+    int Count { get; }
+    IEnumerable<TElement> this[TKey key] { get; }
+  }
+
+  /// <summary>
+  /// Represents a sorted sequence.
+  /// </summary>
+  internal partial interface IOrderedEnumerable<TElement> : IEnumerable<TElement>
+  {
+    /// <summary>
+    /// Performs a subsequent ordering on the elements of an 
+    /// <see cref="IOrderedEnumerable{T}"/> according to a key.
+    /// </summary>
+
+    IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey>(
+      Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);
+  }
+
+  /// <summary>
+  /// Represents a collection of keys each mapped to one or more values.
+  /// </summary>
+  internal sealed class Lookup<TKey, TElement> : ILookup<TKey, TElement>
+  {
+    private readonly Dictionary<TKey, IGrouping<TKey, TElement>> _map;
+
+    internal Lookup(IEqualityComparer<TKey> comparer)
+    {
+      _map = new Dictionary<TKey, IGrouping<TKey, TElement>>(comparer);
+    }
+
+    internal void Add(IGrouping<TKey, TElement> item)
+    {
+      _map.Add(item.Key, item);
+    }
+
+    internal IEnumerable<TElement> Find(TKey key)
+    {
+      IGrouping<TKey, TElement> grouping;
+      return _map.TryGetValue(key, out grouping) ? grouping : null;
+    }
+
+    /// <summary>
+    /// Gets the number of key/value collection pairs in the <see cref="Lookup{TKey,TElement}" />.
+    /// </summary>
+
+    public int Count => _map.Count;
+
+      /// <summary>
+    /// Gets the collection of values indexed by the specified key.
+    /// </summary>
+
+    public IEnumerable<TElement> this[TKey key]
+    {
+      get
+      {
+        IGrouping<TKey, TElement> result;
+        return _map.TryGetValue(key, out result) ? result : Enumerable.Empty<TElement>();
+      }
+    }
+
+    /// <summary>
+    /// Determines whether a specified key is in the <see cref="Lookup{TKey,TElement}" />.
+    /// </summary>
+
+    public bool Contains(TKey key)
+    {
+      return _map.ContainsKey(key);
+    }
+
+    /// <summary>
+    /// Applies a transform function to each key and its associated 
+    /// values and returns the results.
+    /// </summary>
+
+    public IEnumerable<TResult> ApplyResultSelector<TResult>(
+      Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
+    {
+      if (resultSelector == null)
+        throw new ArgumentNullException("resultSelector");
+
+      foreach (var pair in _map)
+        yield return resultSelector(pair.Key, pair.Value);
+    }
+
+    /// <summary>
+    /// Returns a generic enumerator that iterates through the <see cref="Lookup{TKey,TElement}" />.
+    /// </summary>
+
+    public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
+    {
+      return _map.Values.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+      return GetEnumerator();
+    }
+  }
+
+  internal sealed class OrderedEnumerable<T, K> : IOrderedEnumerable<T>
+  {
+    private readonly IEnumerable<T> _source;
+    private readonly List<Comparison<T>> _comparisons;
+
+    public OrderedEnumerable(IEnumerable<T> source,
+                             Func<T, K> keySelector, IComparer<K> comparer, bool descending) :
+                               this(source, null, keySelector, comparer, descending)
+    {
+    }
+
+    private OrderedEnumerable(IEnumerable<T> source, List<Comparison<T>> comparisons,
+                              Func<T, K> keySelector, IComparer<K> comparer, bool descending)
+    {
+      if (source == null) throw new ArgumentNullException("source");
+      if (keySelector == null) throw new ArgumentNullException("keySelector");
+
+      _source = source;
+
+      comparer = comparer ?? Comparer<K>.Default;
+
+      if (comparisons == null)
+        comparisons = new List<Comparison<T>>( /* capacity */ 4);
+
+      comparisons.Add((x, y)
+                      => (descending ? -1 : 1)*comparer.Compare(keySelector(x), keySelector(y)));
+
+      _comparisons = comparisons;
+    }
+
+    public IOrderedEnumerable<T> CreateOrderedEnumerable<KK>(
+      Func<T, KK> keySelector, IComparer<KK> comparer, bool descending)
+    {
+      return new OrderedEnumerable<T, KK>(_source, _comparisons, keySelector, comparer, descending);
+    }
+
+    public IEnumerator<T> GetEnumerator()
+    {
+      //
+      // We sort using List<T>.Sort, but docs say that it performs an 
+      // unstable sort. LINQ, on the other hand, says OrderBy performs 
+      // a stable sort. So convert the source sequence into a sequence 
+      // of tuples where the second element tags the position of the 
+      // element from the source sequence (First). The position is 
+      // then used as a tie breaker when all keys compare equal,
+      // thus making the sort stable.
+      //
+
+      var list = _source.Select(new Func<T, int, Tuple<T, int>>(TagPosition)).ToList();
+
+      list.Sort((x, y) =>
+        {
+          //
+          // Compare keys from left to right.
+          //
+
+          var comparisons = _comparisons;
+          for (var i = 0; i < comparisons.Count; i++)
+          {
+            var result = comparisons[i](x.First, y.First);
+            if (result != 0)
+              return result;
+          }
+
+          //
+          // All keys compared equal so now break the tie by their
+          // position in the original sequence, making the sort stable.
+          //
+
+          return x.Second.CompareTo(y.Second);
+        });
+
+      return list.Select(new Func<Tuple<T, int>, T>(GetFirst)).GetEnumerator();
+
+    }
+
+    /// <remarks>
+    /// See <a href="http://code.google.com/p/linqbridge/issues/detail?id=11">issue #11</a>
+    /// for why this method is needed and cannot be expressed as a 
+    /// lambda at the call site.
+    /// </remarks>
+
+    private static Tuple<T, int> TagPosition(T e, int i)
+    {
+      return new Tuple<T, int>(e, i);
+    }
+
+    /// <remarks>
+    /// See <a href="http://code.google.com/p/linqbridge/issues/detail?id=11">issue #11</a>
+    /// for why this method is needed and cannot be expressed as a 
+    /// lambda at the call site.
+    /// </remarks>
+
+    private static T GetFirst(Tuple<T, int> pv)
+    {
+      return pv.First;
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+      return GetEnumerator();
+    }
+  }
+
+  [Serializable]
+  internal readonly struct Tuple<TFirst, TSecond> : IEquatable<Tuple<TFirst, TSecond>>
+  {
+    public TFirst First { get; }
+    public TSecond Second { get; }
+
+    public Tuple(TFirst first, TSecond second)
+      : this()
+    {
+      First = first;
+      Second = second;
+    }
+
+    public override bool Equals(object obj)
+    {
+      return obj != null
+             && obj is Tuple<TFirst, TSecond>
+             && base.Equals((Tuple<TFirst, TSecond>) obj);
+    }
+
+    public bool Equals(Tuple<TFirst, TSecond> other)
+    {
+      return EqualityComparer<TFirst>.Default.Equals(other.First, First)
+             && EqualityComparer<TSecond>.Default.Equals(other.Second, Second);
+    }
+
+    public override int GetHashCode()
+    {
+      var num = 0x7a2f0b42;
+      num = (-1521134295*num) + EqualityComparer<TFirst>.Default.GetHashCode(First);
+      return (-1521134295*num) + EqualityComparer<TSecond>.Default.GetHashCode(Second);
+    }
+
+    public override string ToString()
+    {
+      return string.Format(CultureInfo.InvariantCulture, @"{{ First = {0}, Second = {1} }}", First, Second);
+    }
+  }
+}
+
+namespace LC.Newtonsoft.Json.Serialization
+{
+#pragma warning disable 1591
+  public delegate TResult Func<TResult>();
+
+  public delegate TResult Func<T, TResult>(T a);
+
+  public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);
+
+  public delegate TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3);
+
+  public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+
+  public delegate void Action();
+
+  public delegate void Action<T1, T2>(T1 arg1, T2 arg2);
+
+  public delegate void Action<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3);
+
+  public delegate void Action<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+#pragma warning restore 1591
+}
+
+namespace System.Runtime.CompilerServices
+{
+  /// <remarks>
+  /// This attribute allows us to define extension methods without 
+  /// requiring .NET Framework 3.5. For more information, see the section,
+  /// <a href="http://msdn.microsoft.com/en-us/magazine/cc163317.aspx#S7">Extension Methods in .NET Framework 2.0 Apps</a>,
+  /// of <a href="http://msdn.microsoft.com/en-us/magazine/cc163317.aspx">Basic Instincts: Extension Methods</a>
+  /// column in <a href="http://msdn.microsoft.com/msdnmag/">MSDN Magazine</a>, 
+  /// issue <a href="http://msdn.microsoft.com/en-us/magazine/cc135410.aspx">Nov 2007</a>.
+  /// </remarks>
+
+  [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class | AttributeTargets.Assembly)]
+  internal sealed class ExtensionAttribute : Attribute { }
+}
+
+#endif
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/MathUtils.cs b/Libs/Newtonsoft.Json/Utilities/MathUtils.cs
new file mode 100644
index 0000000..695fe95
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/MathUtils.cs
@@ -0,0 +1,187 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class MathUtils
+    {
+        public static int IntLength(ulong i)
+        {
+            if (i < 10000000000)
+            {
+                if (i < 10)
+                {
+                    return 1;
+                }
+                if (i < 100)
+                {
+                    return 2;
+                }
+                if (i < 1000)
+                {
+                    return 3;
+                }
+                if (i < 10000)
+                {
+                    return 4;
+                }
+                if (i < 100000)
+                {
+                    return 5;
+                }
+                if (i < 1000000)
+                {
+                    return 6;
+                }
+                if (i < 10000000)
+                {
+                    return 7;
+                }
+                if (i < 100000000)
+                {
+                    return 8;
+                }
+                if (i < 1000000000)
+                {
+                    return 9;
+                }
+
+                return 10;
+            }
+            else
+            {
+                if (i < 100000000000)
+                {
+                    return 11;
+                }
+                if (i < 1000000000000)
+                {
+                    return 12;
+                }
+                if (i < 10000000000000)
+                {
+                    return 13;
+                }
+                if (i < 100000000000000)
+                {
+                    return 14;
+                }
+                if (i < 1000000000000000)
+                {
+                    return 15;
+                }
+                if (i < 10000000000000000)
+                {
+                    return 16;
+                }
+                if (i < 100000000000000000)
+                {
+                    return 17;
+                }
+                if (i < 1000000000000000000)
+                {
+                    return 18;
+                }
+                if (i < 10000000000000000000)
+                {
+                    return 19;
+                }
+
+                return 20;
+            }
+        }
+
+        public static char IntToHex(int n)
+        {
+            if (n <= 9)
+            {
+                return (char)(n + 48);
+            }
+
+            return (char)((n - 10) + 97);
+        }
+
+        public static int? Min(int? val1, int? val2)
+        {
+            if (val1 == null)
+            {
+                return val2;
+            }
+            if (val2 == null)
+            {
+                return val1;
+            }
+
+            return Math.Min(val1.GetValueOrDefault(), val2.GetValueOrDefault());
+        }
+
+        public static int? Max(int? val1, int? val2)
+        {
+            if (val1 == null)
+            {
+                return val2;
+            }
+            if (val2 == null)
+            {
+                return val1;
+            }
+
+            return Math.Max(val1.GetValueOrDefault(), val2.GetValueOrDefault());
+        }
+
+        public static double? Max(double? val1, double? val2)
+        {
+            if (val1 == null)
+            {
+                return val2;
+            }
+            if (val2 == null)
+            {
+                return val1;
+            }
+
+            return Math.Max(val1.GetValueOrDefault(), val2.GetValueOrDefault());
+        }
+
+        public static bool ApproxEquals(double d1, double d2)
+        {
+            const double epsilon = 2.2204460492503131E-16;
+
+            if (d1 == d2)
+            {
+                return true;
+            }
+
+            double tolerance = ((Math.Abs(d1) + Math.Abs(d2)) + 10.0) * epsilon;
+            double difference = d1 - d2;
+
+            return (-tolerance < difference && tolerance > difference);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/MethodBinder.cs b/Libs/Newtonsoft.Json/Utilities/MethodBinder.cs
new file mode 100644
index 0000000..a92244b
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/MethodBinder.cs
@@ -0,0 +1,346 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+#if PORTABLE
+    internal static class MethodBinder
+    {
+        
+        /// <summary>
+        /// List of primitive types which can be widened.
+        /// </summary>
+        private static readonly Type[] PrimitiveTypes = new Type[]
+        {
+            typeof(bool),  typeof(char),   typeof(sbyte), typeof(byte),
+            typeof(short), typeof(ushort), typeof(int),   typeof(uint),
+            typeof(long),  typeof(ulong),  typeof(float), typeof(double)
+        };
+
+        /// <summary>
+        /// Widening masks for primitive types above.
+        /// Index of the value in this array defines a type we're widening,
+        /// while the bits in mask define types it can be widened to (including itself).
+        /// 
+        /// For example, value at index 0 defines a bool type, and it only has bit 0 set, 
+        /// i.e. bool values can be assigned only to bool.
+        /// </summary>
+        private static readonly int[] WideningMasks = new int[]
+        {
+            0x0001,        0x0FE2,         0x0D54,        0x0FFA,
+            0x0D50,        0x0FE2,         0x0D40,        0x0F80,
+            0x0D00,        0x0E00,         0x0C00,        0x0800
+        };
+
+        /// <summary>
+        /// Checks if value of primitive type <paramref name="from"/> can be  
+        /// assigned to parameter of primitive type <paramref name="to"/>.
+        /// </summary>
+        /// <param name="from">Source primitive type.</param>
+        /// <param name="to">Target primitive type.</param>
+        /// <returns><c>true</c> if source type can be widened to target type, <c>false</c> otherwise.</returns>
+        private static bool CanConvertPrimitive(Type from, Type to)
+        {
+            if (from == to)
+            {
+                // same type
+                return true;
+            }
+
+            int fromMask = 0;
+            int toMask = 0;
+
+            for (int i = 0; i < PrimitiveTypes.Length; i++)
+            {
+                if (PrimitiveTypes[i] == from)
+                {
+                    fromMask = WideningMasks[i];
+                }
+                else if (PrimitiveTypes[i] == to)
+                {
+                    toMask = 1 << i;
+                }
+
+                if (fromMask != 0 && toMask != 0)
+                {
+                    break;
+                }
+            }
+
+            return (fromMask & toMask) != 0;
+        }
+
+        /// <summary>
+        /// Checks if a set of values with given <paramref name="types"/> can be used
+        /// to invoke a method with specified <paramref name="parameters"/>. 
+        /// </summary>
+        /// <param name="parameters">Method parameters.</param>
+        /// <param name="types">Argument types.</param>
+        /// <param name="enableParamArray">Try to pack extra arguments into the last parameter when it is marked up with <see cref="ParamArrayAttribute"/>.</param>
+        /// <returns><c>true</c> if method can be called with given arguments, <c>false</c> otherwise.</returns>
+        private static bool FilterParameters(ParameterInfo[] parameters, IList<Type> types, bool enableParamArray)
+        {
+            ValidationUtils.ArgumentNotNull(parameters, nameof(parameters));
+            ValidationUtils.ArgumentNotNull(types, nameof(types));
+
+            if (parameters.Length == 0)
+            {
+                // fast check for parameterless methods
+                return types.Count == 0;
+            }
+            if (parameters.Length > types.Count)
+            {
+                // not all declared parameters were specified (optional parameters are not supported)
+                return false;
+            }
+
+            // check if the last parameter is ParamArray
+            Type? paramArrayType = null;
+
+            if (enableParamArray)
+            {
+                ParameterInfo lastParam = parameters[parameters.Length - 1];
+                if (lastParam.ParameterType.IsArray && lastParam.IsDefined(typeof(ParamArrayAttribute)))
+                {
+                    paramArrayType = lastParam.ParameterType.GetElementType();
+                }
+            }
+
+            if (paramArrayType == null && parameters.Length != types.Count)
+            {
+                // when there's no ParamArray, number of parameters should match
+                return false;
+            }
+
+            for (int i = 0; i < types.Count; i++)
+            {
+                Type paramType = (paramArrayType != null && i >= parameters.Length - 1) ? paramArrayType : parameters[i].ParameterType;
+
+                if (paramType == types[i])
+                {
+                    // exact match with provided type
+                    continue;
+                }
+
+                if (paramType == typeof(object))
+                {
+                    // parameter of type object matches anything
+                    continue;
+                }
+
+                if (paramType.IsPrimitive())
+                {
+                    if (!types[i].IsPrimitive() || !CanConvertPrimitive(types[i], paramType))
+                    {
+                        // primitive parameter can only be assigned from compatible primitive type
+                        return false;
+                    }
+                }
+                else
+                {
+                    if (!paramType.IsAssignableFrom(types[i]))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Compares two sets of parameters to determine 
+        /// which one suits better for given argument types.
+        /// </summary>
+        private class ParametersMatchComparer : IComparer<ParameterInfo[]>
+        {
+            private readonly IList<Type> _types;
+            private readonly bool _enableParamArray;
+
+            public ParametersMatchComparer(IList<Type> types, bool enableParamArray)
+            {
+                ValidationUtils.ArgumentNotNull(types, nameof(types));
+
+                _types = types;
+                _enableParamArray = enableParamArray;
+            }
+
+            public int Compare(ParameterInfo[] parameters1, ParameterInfo[] parameters2)
+            {
+                ValidationUtils.ArgumentNotNull(parameters1, nameof(parameters1));
+                ValidationUtils.ArgumentNotNull(parameters2, nameof(parameters2));
+
+                // parameterless method wins
+                if (parameters1.Length == 0)
+                {
+                    return -1;
+                }
+                if (parameters2.Length == 0)
+                {
+                    return 1;
+                }
+
+                Type? paramArrayType1 = null, paramArrayType2 = null;
+
+                if (_enableParamArray)
+                {
+                    ParameterInfo lastParam1 = parameters1[parameters1.Length - 1];
+                    if (lastParam1.ParameterType.IsArray && lastParam1.IsDefined(typeof(ParamArrayAttribute)))
+                    {
+                        paramArrayType1 = lastParam1.ParameterType.GetElementType();
+                    }
+
+                    ParameterInfo lastParam2 = parameters2[parameters2.Length - 1];
+                    if (lastParam2.ParameterType.IsArray && lastParam2.IsDefined(typeof(ParamArrayAttribute)))
+                    {
+                        paramArrayType2 = lastParam2.ParameterType.GetElementType();
+                    }
+
+                    // A method using params always loses to one not using params
+                    if (paramArrayType1 != null && paramArrayType2 == null)
+                    {
+                        return 1;
+                    }
+                    if (paramArrayType2 != null && paramArrayType1 == null)
+                    {
+                        return -1;
+                    }
+                }
+
+                for (int i = 0; i < _types.Count; i++)
+                {
+                    Type type1 = (paramArrayType1 != null && i >= parameters1.Length - 1) ? paramArrayType1 : parameters1[i].ParameterType;
+                    Type type2 = (paramArrayType2 != null && i >= parameters2.Length - 1) ? paramArrayType2 : parameters2[i].ParameterType;
+
+                    if (type1 == type2)
+                    {
+                        // exact match between parameter types doesn't change score
+                        continue;
+                    }
+
+                    // exact match with source type decides winner immediately
+                    if (type1 == _types[i])
+                    {
+                        return -1;
+                    }
+                    if (type2 == _types[i])
+                    {
+                        return 1;
+                    }
+
+                    int r = ChooseMorePreciseType(type1, type2);
+                    if (r != 0)
+                    {
+                        // winner decided 
+                        return r;
+                    }
+                }
+
+                return 0;
+            }
+
+            private static int ChooseMorePreciseType(Type type1, Type type2)
+            {
+                if (type1.IsByRef || type2.IsByRef)
+                {
+                    if (type1.IsByRef && type2.IsByRef)
+                    {
+                        type1 = type1.GetElementType();
+                        type2 = type2.GetElementType();
+                    }
+                    else if (type1.IsByRef)
+                    {
+                        type1 = type1.GetElementType();
+                        if (type1 == type2)
+                        {
+                            return 1;
+                        }
+                    }
+                    else
+                    {
+                        type2 = type2.GetElementType();
+                        if (type2 == type1)
+                        {
+                            return -1;
+                        }
+                    }
+                }
+
+                bool c1FromC2, c2FromC1;
+
+                if (type1.IsPrimitive() && type2.IsPrimitive())
+                {
+                    c1FromC2 = CanConvertPrimitive(type2, type1);
+                    c2FromC1 = CanConvertPrimitive(type1, type2);
+                }
+                else
+                {
+                    c1FromC2 = type1.IsAssignableFrom(type2);
+                    c2FromC1 = type2.IsAssignableFrom(type1);
+                }
+
+                if (c1FromC2 == c2FromC1)
+                {
+                    return 0;
+                }
+
+                return c1FromC2 ? 1 : -1;
+            }
+
+        }
+
+        /// <summary>
+        /// Returns a best method overload for given argument <paramref name="types"/>.
+        /// </summary>
+        /// <param name="candidates">List of method candidates.</param>
+        /// <param name="types">Argument types.</param>
+        /// <returns>Best method overload, or <c>null</c> if none matched.</returns>
+        public static TMethod SelectMethod<TMethod>(IEnumerable<TMethod> candidates, IList<Type> types) where TMethod : MethodBase
+        {
+            ValidationUtils.ArgumentNotNull(candidates, nameof(candidates));
+            ValidationUtils.ArgumentNotNull(types, nameof(types));
+
+            // ParamArrays are not supported by ReflectionDelegateFactory
+            // They will be treated like ordinary array arguments
+            const bool enableParamArray = false;
+
+            return candidates
+                .Where(m => FilterParameters(m.GetParameters(), types, enableParamArray))
+                .OrderBy(m => m.GetParameters(), new ParametersMatchComparer(types, enableParamArray))
+                .FirstOrDefault();
+        }
+
+    }
+#endif
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/MethodCall.cs b/Libs/Newtonsoft.Json/Utilities/MethodCall.cs
new file mode 100644
index 0000000..69714d5
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/MethodCall.cs
@@ -0,0 +1,29 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal delegate TResult MethodCall<T, TResult>(T target, params object?[] args);
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/MiscellaneousUtils.cs b/Libs/Newtonsoft.Json/Utilities/MiscellaneousUtils.cs
new file mode 100644
index 0000000..ce2b8e0
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/MiscellaneousUtils.cs
@@ -0,0 +1,174 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reflection;
+using System.Text;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal delegate T Creator<T>();
+
+    internal static class MiscellaneousUtils
+    {
+        [Conditional("DEBUG")]
+        public static void Assert([DoesNotReturnIf(false)] bool condition, string? message = null)
+        {
+            Debug.Assert(condition, message);
+        }
+
+        public static bool ValueEquals(object? objA, object? objB)
+        {
+            if (objA == objB)
+            {
+                return true;
+            }
+            if (objA == null || objB == null)
+            {
+                return false;
+            }
+
+            // comparing an Int32 and Int64 both of the same value returns false
+            // make types the same then compare
+            if (objA.GetType() != objB.GetType())
+            {
+                if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
+                {
+                    return Convert.ToDecimal(objA, CultureInfo.CurrentCulture).Equals(Convert.ToDecimal(objB, CultureInfo.CurrentCulture));
+                }
+                else if ((objA is double || objA is float || objA is decimal) && (objB is double || objB is float || objB is decimal))
+                {
+                    return MathUtils.ApproxEquals(Convert.ToDouble(objA, CultureInfo.CurrentCulture), Convert.ToDouble(objB, CultureInfo.CurrentCulture));
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            return objA.Equals(objB);
+        }
+
+        public static ArgumentOutOfRangeException CreateArgumentOutOfRangeException(string paramName, object actualValue, string message)
+        {
+            string newMessage = message + Environment.NewLine + @"Actual value was {0}.".FormatWith(CultureInfo.InvariantCulture, actualValue);
+
+            return new ArgumentOutOfRangeException(paramName, newMessage);
+        }
+
+        public static string ToString(object? value)
+        {
+            if (value == null)
+            {
+                return "{null}";
+            }
+
+            return (value is string s) ? @"""" + s + @"""" : value!.ToString();
+        }
+
+        public static int ByteArrayCompare(byte[] a1, byte[] a2)
+        {
+            int lengthCompare = a1.Length.CompareTo(a2.Length);
+            if (lengthCompare != 0)
+            {
+                return lengthCompare;
+            }
+
+            for (int i = 0; i < a1.Length; i++)
+            {
+                int valueCompare = a1[i].CompareTo(a2[i]);
+                if (valueCompare != 0)
+                {
+                    return valueCompare;
+                }
+            }
+
+            return 0;
+        }
+
+        public static string? GetPrefix(string qualifiedName)
+        {
+            GetQualifiedNameParts(qualifiedName, out string? prefix, out _);
+
+            return prefix;
+        }
+
+        public static string GetLocalName(string qualifiedName)
+        {
+            GetQualifiedNameParts(qualifiedName, out _, out string localName);
+
+            return localName;
+        }
+
+        public static void GetQualifiedNameParts(string qualifiedName, out string? prefix, out string localName)
+        {
+            int colonPosition = qualifiedName.IndexOf(':');
+
+            if ((colonPosition == -1 || colonPosition == 0) || (qualifiedName.Length - 1) == colonPosition)
+            {
+                prefix = null;
+                localName = qualifiedName;
+            }
+            else
+            {
+                prefix = qualifiedName.Substring(0, colonPosition);
+                localName = qualifiedName.Substring(colonPosition + 1);
+            }
+        }
+
+        internal static RegexOptions GetRegexOptions(string optionsText)
+        {
+            RegexOptions options = RegexOptions.None;
+
+            for (int i = 0; i < optionsText.Length; i++)
+            {
+                switch (optionsText[i])
+                {
+                    case 'i':
+                        options |= RegexOptions.IgnoreCase;
+                        break;
+                    case 'm':
+                        options |= RegexOptions.Multiline;
+                        break;
+                    case 's':
+                        options |= RegexOptions.Singleline;
+                        break;
+                    case 'x':
+                        options |= RegexOptions.ExplicitCapture;
+                        break;
+                }
+            }
+
+            return options;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/NullableAttributes.cs b/Libs/Newtonsoft.Json/Utilities/NullableAttributes.cs
new file mode 100644
index 0000000..fa1f55e
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/NullableAttributes.cs
@@ -0,0 +1,74 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>Specifies that an output will not be null even if the corresponding type allows it.</summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true)]
+    internal sealed class NotNullAttribute : Attribute { }
+
+    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
+    [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+        /// <summary>Initializes the attribute with the specified return value condition.</summary>
+        /// <param name="returnValue">
+        /// The return value condition. If the method returns this value, the associated parameter will not be null.
+        /// </param>
+        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+        /// <summary>Gets the return value condition.</summary>
+        public bool ReturnValue { get; }
+    }
+
+    /// <summary>Specifies that an output may be null even if the corresponding type disallows it.</summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
+    internal sealed class MaybeNullAttribute : Attribute
+    { }
+
+    /// <summary>Specifies that null is allowed as an input even if the corresponding type disallows it.</summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
+    internal sealed class AllowNullAttribute : Attribute
+    { }
+
+    /// <summary>
+    /// Specifies that the method will not return if the associated Boolean parameter is passed the specified value.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    internal class DoesNotReturnIfAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DoesNotReturnIfAttribute"/> class.
+        /// </summary>
+        /// <param name="parameterValue">
+        /// The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to
+        /// the associated parameter matches this value.
+        /// </param>
+        public DoesNotReturnIfAttribute(bool parameterValue) => this.ParameterValue = parameterValue;
+
+        /// <summary>Gets the condition parameter value.</summary>
+        public bool ParameterValue { get; }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs b/Libs/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs
new file mode 100644
index 0000000..25ee493
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs
@@ -0,0 +1,83 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Globalization;
+using System.Reflection;
+using LC.Newtonsoft.Json.Serialization;
+
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal abstract class ReflectionDelegateFactory
+    {
+        public Func<T, object?> CreateGet<T>(MemberInfo memberInfo)
+        {
+            if (memberInfo is PropertyInfo propertyInfo)
+            {
+                // https://github.com/dotnet/corefx/issues/26053
+                if (propertyInfo.PropertyType.IsByRef)
+                {
+                    throw new InvalidOperationException("Could not create getter for {0}. ByRef return values are not supported.".FormatWith(CultureInfo.InvariantCulture, propertyInfo));
+                }
+
+                return CreateGet<T>(propertyInfo);
+            }
+
+            if (memberInfo is FieldInfo fieldInfo)
+            {
+                return CreateGet<T>(fieldInfo);
+            }
+
+            throw new Exception("Could not create getter for {0}.".FormatWith(CultureInfo.InvariantCulture, memberInfo));
+        }
+
+        public Action<T, object?> CreateSet<T>(MemberInfo memberInfo)
+        {
+            if (memberInfo is PropertyInfo propertyInfo)
+            {
+                return CreateSet<T>(propertyInfo);
+            }
+
+            if (memberInfo is FieldInfo fieldInfo)
+            {
+                return CreateSet<T>(fieldInfo);
+            }
+
+            throw new Exception("Could not create setter for {0}.".FormatWith(CultureInfo.InvariantCulture, memberInfo));
+        }
+
+        public abstract MethodCall<T, object?> CreateMethodCall<T>(MethodBase method);
+        public abstract ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method);
+        public abstract Func<T> CreateDefaultConstructor<T>(Type type);
+        public abstract Func<T, object?> CreateGet<T>(PropertyInfo propertyInfo);
+        public abstract Func<T, object?> CreateGet<T>(FieldInfo fieldInfo);
+        public abstract Action<T, object?> CreateSet<T>(FieldInfo fieldInfo);
+        public abstract Action<T, object?> CreateSet<T>(PropertyInfo propertyInfo);
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ReflectionObject.cs b/Libs/Newtonsoft.Json/Utilities/ReflectionObject.cs
new file mode 100644
index 0000000..79ad388
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ReflectionObject.cs
@@ -0,0 +1,156 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using LC.Newtonsoft.Json.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Globalization;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class ReflectionMember
+    {
+        public Type? MemberType { get; set; }
+        public Func<object, object?>? Getter { get; set; }
+        public Action<object, object?>? Setter { get; set; }
+    }
+
+    internal class ReflectionObject
+    {
+        public ObjectConstructor<object>? Creator { get; }
+        public IDictionary<string, ReflectionMember> Members { get; }
+
+        private ReflectionObject(ObjectConstructor<object>? creator)
+        {
+            Members = new Dictionary<string, ReflectionMember>();
+            Creator = creator;
+        }
+
+        public object? GetValue(object target, string member)
+        {
+            Func<object, object?> getter = Members[member].Getter!;
+            return getter(target);
+        }
+
+        public void SetValue(object target, string member, object? value)
+        {
+            Action<object, object?> setter = Members[member].Setter!;
+            setter(target, value);
+        }
+
+        public Type GetType(string member)
+        {
+            return Members[member].MemberType!;
+        }
+
+        public static ReflectionObject Create(Type t, params string[] memberNames)
+        {
+            return Create(t, null, memberNames);
+        }
+
+        public static ReflectionObject Create(Type t, MethodBase? creator, params string[] memberNames)
+        {
+            ReflectionDelegateFactory delegateFactory = JsonTypeReflector.ReflectionDelegateFactory;
+
+            ObjectConstructor<object>? creatorConstructor = null;
+            if (creator != null)
+            {
+                creatorConstructor = delegateFactory.CreateParameterizedConstructor(creator);
+            }
+            else
+            {
+                if (ReflectionUtils.HasDefaultConstructor(t, false))
+                {
+                    Func<object> ctor = delegateFactory.CreateDefaultConstructor<object>(t);
+
+                    creatorConstructor = args => ctor();
+                }
+            }
+
+            ReflectionObject d = new ReflectionObject(creatorConstructor);
+
+            foreach (string memberName in memberNames)
+            {
+                MemberInfo[] members = t.GetMember(memberName, BindingFlags.Instance | BindingFlags.Public);
+                if (members.Length != 1)
+                {
+                    throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, memberName));
+                }
+
+                MemberInfo member = members.Single();
+
+                ReflectionMember reflectionMember = new ReflectionMember();
+
+                switch (member.MemberType())
+                {
+                    case MemberTypes.Field:
+                    case MemberTypes.Property:
+                        if (ReflectionUtils.CanReadMemberValue(member, false))
+                        {
+                            reflectionMember.Getter = delegateFactory.CreateGet<object>(member);
+                        }
+
+                        if (ReflectionUtils.CanSetMemberValue(member, false, false))
+                        {
+                            reflectionMember.Setter = delegateFactory.CreateSet<object>(member);
+                        }
+                        break;
+                    case MemberTypes.Method:
+                        MethodInfo method = (MethodInfo)member;
+                        if (method.IsPublic)
+                        {
+                            ParameterInfo[] parameters = method.GetParameters();
+                            if (parameters.Length == 0 && method.ReturnType != typeof(void))
+                            {
+                                MethodCall<object, object?> call = delegateFactory.CreateMethodCall<object>(method);
+                                reflectionMember.Getter = target => call(target);
+                            }
+                            else if (parameters.Length == 1 && method.ReturnType == typeof(void))
+                            {
+                                MethodCall<object, object?> call = delegateFactory.CreateMethodCall<object>(method);
+                                reflectionMember.Setter = (target, arg) => call(target, arg);
+                            }
+                        }
+                        break;
+                    default:
+                        throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith(CultureInfo.InvariantCulture, member.MemberType(), member.Name));
+                }
+
+                reflectionMember.MemberType = ReflectionUtils.GetMemberUnderlyingType(member);
+
+                d.Members[memberName] = reflectionMember;
+            }
+
+            return d;
+        }
+    }
+}
diff --git a/Libs/Newtonsoft.Json/Utilities/ReflectionUtils.cs b/Libs/Newtonsoft.Json/Utilities/ReflectionUtils.cs
new file mode 100644
index 0000000..c4e4ced
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ReflectionUtils.cs
@@ -0,0 +1,1096 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using System.Reflection;
+using System.Collections;
+using System.Globalization;
+using System.Text;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+#if (DOTNET || PORTABLE || PORTABLE40) && !NETSTANDARD2_0
+    [Flags]
+    internal enum MemberTypes
+    {
+        Event = 2,
+        Field = 4,
+        Method = 8,
+        Property = 16
+    }
+#endif
+
+#if PORTABLE && !NETSTANDARD2_0
+    [Flags]
+    internal enum BindingFlags
+    {
+        Default = 0,
+        IgnoreCase = 1,
+        DeclaredOnly = 2,
+        Instance = 4,
+        Static = 8,
+        Public = 16,
+        NonPublic = 32,
+        FlattenHierarchy = 64,
+        InvokeMethod = 256,
+        CreateInstance = 512,
+        GetField = 1024,
+        SetField = 2048,
+        GetProperty = 4096,
+        SetProperty = 8192,
+        PutDispProperty = 16384,
+        ExactBinding = 65536,
+        PutRefDispProperty = 32768,
+        SuppressChangeType = 131072,
+        OptionalParamBinding = 262144,
+        IgnoreReturn = 16777216
+    }
+#endif
+
+    internal static class ReflectionUtils
+    {
+        public static readonly Type[] EmptyTypes;
+
+        static ReflectionUtils()
+        {
+#if HAVE_EMPTY_TYPES
+            EmptyTypes = Type.EmptyTypes;
+#else
+            EmptyTypes = CollectionUtils.ArrayEmpty<Type>();
+#endif
+        }
+
+        public static bool IsVirtual(this PropertyInfo propertyInfo)
+        {
+            ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
+
+            MethodInfo? m = propertyInfo.GetGetMethod(true);
+            if (m != null && m.IsVirtual)
+            {
+                return true;
+            }
+
+            m = propertyInfo.GetSetMethod(true);
+            if (m != null && m.IsVirtual)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public static MethodInfo? GetBaseDefinition(this PropertyInfo propertyInfo)
+        {
+            ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
+
+            MethodInfo? m = propertyInfo.GetGetMethod(true);
+            if (m != null)
+            {
+                return m.GetBaseDefinition();
+            }
+
+            return propertyInfo.GetSetMethod(true)?.GetBaseDefinition();
+        }
+
+        public static bool IsPublic(PropertyInfo property)
+        {
+            var getMethod = property.GetGetMethod();
+            if (getMethod != null && getMethod.IsPublic)
+            {
+                return true;
+            }
+            var setMethod = property.GetSetMethod();
+            if (setMethod != null && setMethod.IsPublic)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public static Type? GetObjectType(object? v)
+        {
+            return v?.GetType();
+        }
+
+        public static string GetTypeName(Type t, TypeNameAssemblyFormatHandling assemblyFormat, ISerializationBinder? binder)
+        {
+            string fullyQualifiedTypeName = GetFullyQualifiedTypeName(t, binder);
+
+            switch (assemblyFormat)
+            {
+                case TypeNameAssemblyFormatHandling.Simple:
+                    return RemoveAssemblyDetails(fullyQualifiedTypeName);
+                case TypeNameAssemblyFormatHandling.Full:
+                    return fullyQualifiedTypeName;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        private static string GetFullyQualifiedTypeName(Type t, ISerializationBinder? binder)
+        {
+            if (binder != null)
+            {
+                binder.BindToName(t, out string? assemblyName, out string? typeName);
+#if (NET20 || NET35)
+                // for older SerializationBinder implementations that didn't have BindToName
+                if (assemblyName == null & typeName == null)
+                {
+                    return t.AssemblyQualifiedName;
+                }
+#endif
+                return typeName + (assemblyName == null ? "" : ", " + assemblyName);
+            }
+
+            return t.AssemblyQualifiedName;
+        }
+
+        private static string RemoveAssemblyDetails(string fullyQualifiedTypeName)
+        {
+            StringBuilder builder = new StringBuilder();
+
+            // loop through the type name and filter out qualified assembly details from nested type names
+            bool writingAssemblyName = false;
+            bool skippingAssemblyDetails = false;
+            for (int i = 0; i < fullyQualifiedTypeName.Length; i++)
+            {
+                char current = fullyQualifiedTypeName[i];
+                switch (current)
+                {
+                    case '[':
+                    case ']':
+                        writingAssemblyName = false;
+                        skippingAssemblyDetails = false;
+                        builder.Append(current);
+                        break;
+                    case ',':
+                        if (!writingAssemblyName)
+                        {
+                            writingAssemblyName = true;
+                            builder.Append(current);
+                        }
+                        else
+                        {
+                            skippingAssemblyDetails = true;
+                        }
+                        break;
+                    default:
+                        if (!skippingAssemblyDetails)
+                        {
+                            builder.Append(current);
+                        }
+                        break;
+                }
+            }
+
+            return builder.ToString();
+        }
+
+        public static bool HasDefaultConstructor(Type t, bool nonPublic)
+        {
+            ValidationUtils.ArgumentNotNull(t, nameof(t));
+
+            if (t.IsValueType())
+            {
+                return true;
+            }
+
+            return (GetDefaultConstructor(t, nonPublic) != null);
+        }
+
+        public static ConstructorInfo GetDefaultConstructor(Type t)
+        {
+            return GetDefaultConstructor(t, false);
+        }
+
+        public static ConstructorInfo GetDefaultConstructor(Type t, bool nonPublic)
+        {
+            BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
+            if (nonPublic)
+            {
+                bindingFlags = bindingFlags | BindingFlags.NonPublic;
+            }
+
+            return t.GetConstructors(bindingFlags).SingleOrDefault(c => !c.GetParameters().Any());
+        }
+
+        public static bool IsNullable(Type t)
+        {
+            ValidationUtils.ArgumentNotNull(t, nameof(t));
+
+            if (t.IsValueType())
+            {
+                return IsNullableType(t);
+            }
+
+            return true;
+        }
+
+        public static bool IsNullableType(Type t)
+        {
+            ValidationUtils.ArgumentNotNull(t, nameof(t));
+
+            return (t.IsGenericType() && t.GetGenericTypeDefinition() == typeof(Nullable<>));
+        }
+
+        public static Type EnsureNotNullableType(Type t)
+        {
+            return (IsNullableType(t))
+                ? Nullable.GetUnderlyingType(t)
+                : t;
+        }
+
+        public static Type EnsureNotByRefType(Type t)
+        {
+            return (t.IsByRef && t.HasElementType)
+                ? t.GetElementType()
+                : t;
+        }
+
+        public static bool IsGenericDefinition(Type type, Type genericInterfaceDefinition)
+        {
+            if (!type.IsGenericType())
+            {
+                return false;
+            }
+
+            Type t = type.GetGenericTypeDefinition();
+            return (t == genericInterfaceDefinition);
+        }
+
+        public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition)
+        {
+            return ImplementsGenericDefinition(type, genericInterfaceDefinition, out _);
+        }
+
+        public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition, [NotNullWhen(true)]out Type? implementingType)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+            ValidationUtils.ArgumentNotNull(genericInterfaceDefinition, nameof(genericInterfaceDefinition));
+
+            if (!genericInterfaceDefinition.IsInterface() || !genericInterfaceDefinition.IsGenericTypeDefinition())
+            {
+                throw new ArgumentNullException("'{0}' is not a generic interface definition.".FormatWith(CultureInfo.InvariantCulture, genericInterfaceDefinition));
+            }
+
+            if (type.IsInterface())
+            {
+                if (type.IsGenericType())
+                {
+                    Type interfaceDefinition = type.GetGenericTypeDefinition();
+
+                    if (genericInterfaceDefinition == interfaceDefinition)
+                    {
+                        implementingType = type;
+                        return true;
+                    }
+                }
+            }
+
+            foreach (Type i in type.GetInterfaces())
+            {
+                if (i.IsGenericType())
+                {
+                    Type interfaceDefinition = i.GetGenericTypeDefinition();
+
+                    if (genericInterfaceDefinition == interfaceDefinition)
+                    {
+                        implementingType = i;
+                        return true;
+                    }
+                }
+            }
+
+            implementingType = null;
+            return false;
+        }
+
+        public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition)
+        {
+            return InheritsGenericDefinition(type, genericClassDefinition, out _);
+        }
+
+        public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition, out Type? implementingType)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+            ValidationUtils.ArgumentNotNull(genericClassDefinition, nameof(genericClassDefinition));
+
+            if (!genericClassDefinition.IsClass() || !genericClassDefinition.IsGenericTypeDefinition())
+            {
+                throw new ArgumentNullException("'{0}' is not a generic class definition.".FormatWith(CultureInfo.InvariantCulture, genericClassDefinition));
+            }
+
+            return InheritsGenericDefinitionInternal(type, genericClassDefinition, out implementingType);
+        }
+
+        private static bool InheritsGenericDefinitionInternal(Type currentType, Type genericClassDefinition, out Type? implementingType)
+        {
+            do
+            {
+                if (currentType.IsGenericType() && genericClassDefinition == currentType.GetGenericTypeDefinition())
+                {
+                    implementingType = currentType;
+                    return true;
+                }
+
+                currentType = currentType.BaseType();
+            }
+            while (currentType != null);
+
+            implementingType = null;
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the type of the typed collection's items.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <returns>The type of the typed collection's items.</returns>
+        public static Type? GetCollectionItemType(Type type)
+        {
+            ValidationUtils.ArgumentNotNull(type, nameof(type));
+
+            if (type.IsArray)
+            {
+                return type.GetElementType();
+            }
+            if (ImplementsGenericDefinition(type, typeof(IEnumerable<>), out Type? genericListType))
+            {
+                if (genericListType!.IsGenericTypeDefinition())
+                {
+                    throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));
+                }
+
+                return genericListType!.GetGenericArguments()[0];
+            }
+            if (typeof(IEnumerable).IsAssignableFrom(type))
+            {
+                return null;
+            }
+
+            throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));
+        }
+
+        public static void GetDictionaryKeyValueTypes(Type dictionaryType, out Type? keyType, out Type? valueType)
+        {
+            ValidationUtils.ArgumentNotNull(dictionaryType, nameof(dictionaryType));
+
+            if (ImplementsGenericDefinition(dictionaryType, typeof(IDictionary<,>), out Type? genericDictionaryType))
+            {
+                if (genericDictionaryType!.IsGenericTypeDefinition())
+                {
+                    throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, dictionaryType));
+                }
+
+                Type[] dictionaryGenericArguments = genericDictionaryType!.GetGenericArguments();
+
+                keyType = dictionaryGenericArguments[0];
+                valueType = dictionaryGenericArguments[1];
+                return;
+            }
+            if (typeof(IDictionary).IsAssignableFrom(dictionaryType))
+            {
+                keyType = null;
+                valueType = null;
+                return;
+            }
+
+            throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, dictionaryType));
+        }
+
+        /// <summary>
+        /// Gets the member's underlying type.
+        /// </summary>
+        /// <param name="member">The member.</param>
+        /// <returns>The underlying type of the member.</returns>
+        public static Type GetMemberUnderlyingType(MemberInfo member)
+        {
+            ValidationUtils.ArgumentNotNull(member, nameof(member));
+
+            switch (member.MemberType())
+            {
+                case MemberTypes.Field:
+                    return ((FieldInfo)member).FieldType;
+                case MemberTypes.Property:
+                    return ((PropertyInfo)member).PropertyType;
+                case MemberTypes.Event:
+                    return ((EventInfo)member).EventHandlerType;
+                case MemberTypes.Method:
+                    return ((MethodInfo)member).ReturnType;
+                default:
+                    throw new ArgumentException("MemberInfo must be of type FieldInfo, PropertyInfo, EventInfo or MethodInfo", nameof(member));
+            }
+        }
+
+        public static bool IsByRefLikeType(Type type)
+        {
+            if (!type.IsValueType())
+            {
+                return false;
+            }
+
+            // IsByRefLike flag on type is not available in netstandard2.0
+            Attribute[] attributes = GetAttributes(type, null, false);
+            for (int i = 0; i < attributes.Length; i++)
+            {
+                if (string.Equals(attributes[i].GetType().FullName, "System.Runtime.CompilerServices.IsByRefLikeAttribute", StringComparison.Ordinal))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether the property is an indexed property.
+        /// </summary>
+        /// <param name="property">The property.</param>
+        /// <returns>
+        /// 	<c>true</c> if the property is an indexed property; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsIndexedProperty(PropertyInfo property)
+        {
+            ValidationUtils.ArgumentNotNull(property, nameof(property));
+
+            return (property.GetIndexParameters().Length > 0);
+        }
+
+        /// <summary>
+        /// Gets the member's value on the object.
+        /// </summary>
+        /// <param name="member">The member.</param>
+        /// <param name="target">The target object.</param>
+        /// <returns>The member's value on the object.</returns>
+        public static object GetMemberValue(MemberInfo member, object target)
+        {
+            ValidationUtils.ArgumentNotNull(member, nameof(member));
+            ValidationUtils.ArgumentNotNull(target, nameof(target));
+
+            switch (member.MemberType())
+            {
+                case MemberTypes.Field:
+                    return ((FieldInfo)member).GetValue(target);
+                case MemberTypes.Property:
+                    try
+                    {
+                        return ((PropertyInfo)member).GetValue(target, null);
+                    }
+                    catch (TargetParameterCountException e)
+                    {
+                        throw new ArgumentException("MemberInfo '{0}' has index parameters".FormatWith(CultureInfo.InvariantCulture, member.Name), e);
+                    }
+                default:
+                    throw new ArgumentException("MemberInfo '{0}' is not of type FieldInfo or PropertyInfo".FormatWith(CultureInfo.InvariantCulture, member.Name), nameof(member));
+            }
+        }
+
+        /// <summary>
+        /// Sets the member's value on the target object.
+        /// </summary>
+        /// <param name="member">The member.</param>
+        /// <param name="target">The target.</param>
+        /// <param name="value">The value.</param>
+        public static void SetMemberValue(MemberInfo member, object target, object? value)
+        {
+            ValidationUtils.ArgumentNotNull(member, nameof(member));
+            ValidationUtils.ArgumentNotNull(target, nameof(target));
+
+            switch (member.MemberType())
+            {
+                case MemberTypes.Field:
+                    ((FieldInfo)member).SetValue(target, value);
+                    break;
+                case MemberTypes.Property:
+                    ((PropertyInfo)member).SetValue(target, value, null);
+                    break;
+                default:
+                    throw new ArgumentException("MemberInfo '{0}' must be of type FieldInfo or PropertyInfo".FormatWith(CultureInfo.InvariantCulture, member.Name), nameof(member));
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified MemberInfo can be read.
+        /// </summary>
+        /// <param name="member">The MemberInfo to determine whether can be read.</param>
+        /// /// <param name="nonPublic">if set to <c>true</c> then allow the member to be gotten non-publicly.</param>
+        /// <returns>
+        /// 	<c>true</c> if the specified MemberInfo can be read; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool CanReadMemberValue(MemberInfo member, bool nonPublic)
+        {
+            switch (member.MemberType())
+            {
+                case MemberTypes.Field:
+                    FieldInfo fieldInfo = (FieldInfo)member;
+
+                    if (nonPublic)
+                    {
+                        return true;
+                    }
+                    else if (fieldInfo.IsPublic)
+                    {
+                        return true;
+                    }
+                    return false;
+                case MemberTypes.Property:
+                    PropertyInfo propertyInfo = (PropertyInfo)member;
+
+                    if (!propertyInfo.CanRead)
+                    {
+                        return false;
+                    }
+                    if (nonPublic)
+                    {
+                        return true;
+                    }
+                    return (propertyInfo.GetGetMethod(nonPublic) != null);
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified MemberInfo can be set.
+        /// </summary>
+        /// <param name="member">The MemberInfo to determine whether can be set.</param>
+        /// <param name="nonPublic">if set to <c>true</c> then allow the member to be set non-publicly.</param>
+        /// <param name="canSetReadOnly">if set to <c>true</c> then allow the member to be set if read-only.</param>
+        /// <returns>
+        /// 	<c>true</c> if the specified MemberInfo can be set; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool CanSetMemberValue(MemberInfo member, bool nonPublic, bool canSetReadOnly)
+        {
+            switch (member.MemberType())
+            {
+                case MemberTypes.Field:
+                    FieldInfo fieldInfo = (FieldInfo)member;
+
+                    if (fieldInfo.IsLiteral)
+                    {
+                        return false;
+                    }
+                    if (fieldInfo.IsInitOnly && !canSetReadOnly)
+                    {
+                        return false;
+                    }
+                    if (nonPublic)
+                    {
+                        return true;
+                    }
+                    if (fieldInfo.IsPublic)
+                    {
+                        return true;
+                    }
+                    return false;
+                case MemberTypes.Property:
+                    PropertyInfo propertyInfo = (PropertyInfo)member;
+
+                    if (!propertyInfo.CanWrite)
+                    {
+                        return false;
+                    }
+                    if (nonPublic)
+                    {
+                        return true;
+                    }
+                    return (propertyInfo.GetSetMethod(nonPublic) != null);
+                default:
+                    return false;
+            }
+        }
+
+        public static List<MemberInfo> GetFieldsAndProperties(Type type, BindingFlags bindingAttr)
+        {
+            List<MemberInfo> targetMembers = new List<MemberInfo>();
+
+            targetMembers.AddRange(GetFields(type, bindingAttr));
+            targetMembers.AddRange(GetProperties(type, bindingAttr));
+
+            // for some reason .NET returns multiple members when overriding a generic member on a base class
+            // http://social.msdn.microsoft.com/Forums/en-US/b5abbfee-e292-4a64-8907-4e3f0fb90cd9/reflection-overriden-abstract-generic-properties?forum=netfxbcl
+            // filter members to only return the override on the topmost class
+            // update: I think this is fixed in .NET 3.5 SP1 - leave this in for now...
+            List<MemberInfo> distinctMembers = new List<MemberInfo>(targetMembers.Count);
+
+            foreach (IGrouping<string, MemberInfo> groupedMember in targetMembers.GroupBy(m => m.Name))
+            {
+                int count = groupedMember.Count();
+
+                if (count == 1)
+                {
+                    distinctMembers.Add(groupedMember.First());
+                }
+                else
+                {
+                    List<MemberInfo> resolvedMembers = new List<MemberInfo>();
+                    foreach (MemberInfo memberInfo in groupedMember)
+                    {
+                        // this is a bit hacky
+                        // if the hiding property is hiding a base property and it is virtual
+                        // then this ensures the derived property gets used
+                        if (resolvedMembers.Count == 0)
+                        {
+                            resolvedMembers.Add(memberInfo);
+                        }
+                        else if (!IsOverridenGenericMember(memberInfo, bindingAttr) || memberInfo.Name == "Item")
+                        {
+                            // two members with the same name were declared on a type
+                            // this can be done via IL emit, e.g. Moq
+                            if (resolvedMembers.Any(m => m.DeclaringType == memberInfo.DeclaringType))
+                            {
+                                continue;
+                            }
+
+                            resolvedMembers.Add(memberInfo);
+                        }
+                    }
+
+                    distinctMembers.AddRange(resolvedMembers);
+                }
+            }
+
+            return distinctMembers;
+        }
+
+        private static bool IsOverridenGenericMember(MemberInfo memberInfo, BindingFlags bindingAttr)
+        {
+            if (memberInfo.MemberType() != MemberTypes.Property)
+            {
+                return false;
+            }
+
+            PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
+            if (!IsVirtual(propertyInfo))
+            {
+                return false;
+            }
+
+            Type declaringType = propertyInfo.DeclaringType;
+            if (!declaringType.IsGenericType())
+            {
+                return false;
+            }
+            Type genericTypeDefinition = declaringType.GetGenericTypeDefinition();
+            if (genericTypeDefinition == null)
+            {
+                return false;
+            }
+            MemberInfo[] members = genericTypeDefinition.GetMember(propertyInfo.Name, bindingAttr);
+            if (members.Length == 0)
+            {
+                return false;
+            }
+            Type memberUnderlyingType = GetMemberUnderlyingType(members[0]);
+            if (!memberUnderlyingType.IsGenericParameter)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        public static T? GetAttribute<T>(object attributeProvider) where T : Attribute
+        {
+            return GetAttribute<T>(attributeProvider, true);
+        }
+
+        public static T? GetAttribute<T>(object attributeProvider, bool inherit) where T : Attribute
+        {
+            T[] attributes = GetAttributes<T>(attributeProvider, inherit);
+
+            return attributes?.FirstOrDefault();
+        }
+
+#if !(DOTNET || PORTABLE) || NETSTANDARD2_0
+        public static T[] GetAttributes<T>(object attributeProvider, bool inherit) where T : Attribute
+        {
+            Attribute[] a = GetAttributes(attributeProvider, typeof(T), inherit);
+
+            if (a is T[] attributes)
+            {
+                return attributes;
+            }
+
+            return a.Cast<T>().ToArray();
+        }
+
+        public static Attribute[] GetAttributes(object attributeProvider, Type? attributeType, bool inherit)
+        {
+            ValidationUtils.ArgumentNotNull(attributeProvider, nameof(attributeProvider));
+
+            object provider = attributeProvider;
+
+            // http://hyperthink.net/blog/getcustomattributes-gotcha/
+            // ICustomAttributeProvider doesn't do inheritance
+
+            switch (provider)
+            {
+                case Type t:
+                    object[] array = attributeType != null ? t.GetCustomAttributes(attributeType, inherit) : t.GetCustomAttributes(inherit);
+                    Attribute[] attributes = array.Cast<Attribute>().ToArray();
+
+#if (NET20 || NET35)
+                    // ye olde .NET GetCustomAttributes doesn't respect the inherit argument
+                    if (inherit && t.BaseType != null)
+                    {
+                        attributes = attributes.Union(GetAttributes(t.BaseType, attributeType, inherit)).ToArray();
+                    }
+#endif
+
+                    return attributes;
+                case Assembly a:
+                    return (attributeType != null) ? Attribute.GetCustomAttributes(a, attributeType) : Attribute.GetCustomAttributes(a);
+                case MemberInfo mi:
+                    return (attributeType != null) ? Attribute.GetCustomAttributes(mi, attributeType, inherit) : Attribute.GetCustomAttributes(mi, inherit);
+#if !PORTABLE40
+                case Module m:
+                    return (attributeType != null) ? Attribute.GetCustomAttributes(m, attributeType, inherit) : Attribute.GetCustomAttributes(m, inherit);
+#endif
+                case ParameterInfo p:
+                    return (attributeType != null) ? Attribute.GetCustomAttributes(p, attributeType, inherit) : Attribute.GetCustomAttributes(p, inherit);
+                default:
+#if !PORTABLE40
+                    ICustomAttributeProvider customAttributeProvider = (ICustomAttributeProvider)attributeProvider;
+                    object[] result = (attributeType != null) ? customAttributeProvider.GetCustomAttributes(attributeType, inherit) : customAttributeProvider.GetCustomAttributes(inherit);
+
+                    return (Attribute[])result;
+#else
+                    throw new Exception("Cannot get attributes from '{0}'.".FormatWith(CultureInfo.InvariantCulture, provider));
+#endif
+            }
+        }
+#else
+        public static T[] GetAttributes<T>(object attributeProvider, bool inherit) where T : Attribute
+        {
+            return GetAttributes(attributeProvider, typeof(T), inherit).Cast<T>().ToArray();
+        }
+
+        public static Attribute[] GetAttributes(object provider, Type? attributeType, bool inherit)
+        {
+            switch (provider)
+            {
+                case Type t:
+                    return (attributeType != null)
+                        ? t.GetTypeInfo().GetCustomAttributes(attributeType, inherit).ToArray()
+                        : t.GetTypeInfo().GetCustomAttributes(inherit).ToArray();
+                case Assembly a:
+                    return (attributeType != null) ? a.GetCustomAttributes(attributeType).ToArray() : a.GetCustomAttributes().ToArray();
+                case MemberInfo memberInfo:
+                    return (attributeType != null) ? memberInfo.GetCustomAttributes(attributeType, inherit).ToArray() : memberInfo.GetCustomAttributes(inherit).ToArray();
+                case Module module:
+                    return (attributeType != null) ? module.GetCustomAttributes(attributeType).ToArray() : module.GetCustomAttributes().ToArray();
+                case ParameterInfo parameterInfo:
+                    return (attributeType != null) ? parameterInfo.GetCustomAttributes(attributeType, inherit).ToArray() : parameterInfo.GetCustomAttributes(inherit).ToArray();
+            }
+
+            throw new Exception("Cannot get attributes from '{0}'.".FormatWith(CultureInfo.InvariantCulture, provider));
+        }
+#endif
+
+        public static StructMultiKey<string?, string> SplitFullyQualifiedTypeName(string fullyQualifiedTypeName)
+        {
+            int? assemblyDelimiterIndex = GetAssemblyDelimiterIndex(fullyQualifiedTypeName);
+
+            string typeName;
+            string? assemblyName;
+
+            if (assemblyDelimiterIndex != null)
+            {
+                typeName = fullyQualifiedTypeName.Trim(0, assemblyDelimiterIndex.GetValueOrDefault());
+                assemblyName = fullyQualifiedTypeName.Trim(assemblyDelimiterIndex.GetValueOrDefault() + 1, fullyQualifiedTypeName.Length - assemblyDelimiterIndex.GetValueOrDefault() - 1);
+            }
+            else
+            {
+                typeName = fullyQualifiedTypeName;
+                assemblyName = null;
+            }
+
+            return new StructMultiKey<string?, string>(assemblyName, typeName);
+        }
+
+        private static int? GetAssemblyDelimiterIndex(string fullyQualifiedTypeName)
+        {
+            // we need to get the first comma following all surrounded in brackets because of generic types
+            // e.g. System.Collections.Generic.Dictionary`2[[System.String, mscorlib,Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+            int scope = 0;
+            for (int i = 0; i < fullyQualifiedTypeName.Length; i++)
+            {
+                char current = fullyQualifiedTypeName[i];
+                switch (current)
+                {
+                    case '[':
+                        scope++;
+                        break;
+                    case ']':
+                        scope--;
+                        break;
+                    case ',':
+                        if (scope == 0)
+                        {
+                            return i;
+                        }
+                        break;
+                }
+            }
+
+            return null;
+        }
+
+        public static MemberInfo GetMemberInfoFromType(Type targetType, MemberInfo memberInfo)
+        {
+            const BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+
+            switch (memberInfo.MemberType())
+            {
+                case MemberTypes.Property:
+                    PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
+
+                    Type[] types = propertyInfo.GetIndexParameters().Select(p => p.ParameterType).ToArray();
+
+                    return targetType.GetProperty(propertyInfo.Name, bindingAttr, null, propertyInfo.PropertyType, types, null);
+                default:
+                    return targetType.GetMember(memberInfo.Name, memberInfo.MemberType(), bindingAttr).SingleOrDefault();
+            }
+        }
+
+        public static IEnumerable<FieldInfo> GetFields(Type targetType, BindingFlags bindingAttr)
+        {
+            ValidationUtils.ArgumentNotNull(targetType, nameof(targetType));
+
+            List<MemberInfo> fieldInfos = new List<MemberInfo>(targetType.GetFields(bindingAttr));
+#if !PORTABLE
+            // Type.GetFields doesn't return inherited private fields
+            // manually find private fields from base class
+            GetChildPrivateFields(fieldInfos, targetType, bindingAttr);
+#endif
+
+            return fieldInfos.Cast<FieldInfo>();
+        }
+
+#if !PORTABLE
+        private static void GetChildPrivateFields(IList<MemberInfo> initialFields, Type targetType, BindingFlags bindingAttr)
+        {
+            // fix weirdness with private FieldInfos only being returned for the current Type
+            // find base type fields and add them to result
+            if ((bindingAttr & BindingFlags.NonPublic) != 0)
+            {
+                // modify flags to not search for public fields
+                BindingFlags nonPublicBindingAttr = bindingAttr.RemoveFlag(BindingFlags.Public);
+
+                while ((targetType = targetType.BaseType()) != null)
+                {
+                    // filter out protected fields
+                    IEnumerable<FieldInfo> childPrivateFields =
+                        targetType.GetFields(nonPublicBindingAttr).Where(f => f.IsPrivate);
+
+                    initialFields.AddRange(childPrivateFields);
+                }
+            }
+        }
+#endif
+
+        public static IEnumerable<PropertyInfo> GetProperties(Type targetType, BindingFlags bindingAttr)
+        {
+            ValidationUtils.ArgumentNotNull(targetType, nameof(targetType));
+
+            List<PropertyInfo> propertyInfos = new List<PropertyInfo>(targetType.GetProperties(bindingAttr));
+
+            // GetProperties on an interface doesn't return properties from its interfaces
+            if (targetType.IsInterface())
+            {
+                foreach (Type i in targetType.GetInterfaces())
+                {
+                    propertyInfos.AddRange(i.GetProperties(bindingAttr));
+                }
+            }
+
+            GetChildPrivateProperties(propertyInfos, targetType, bindingAttr);
+
+            // a base class private getter/setter will be inaccessible unless the property was gotten from the base class
+            for (int i = 0; i < propertyInfos.Count; i++)
+            {
+                PropertyInfo member = propertyInfos[i];
+                if (member.DeclaringType != targetType)
+                {
+                    PropertyInfo declaredMember = (PropertyInfo)GetMemberInfoFromType(member.DeclaringType, member);
+                    propertyInfos[i] = declaredMember;
+                }
+            }
+
+            return propertyInfos;
+        }
+
+        public static BindingFlags RemoveFlag(this BindingFlags bindingAttr, BindingFlags flag)
+        {
+            return ((bindingAttr & flag) == flag)
+                ? bindingAttr ^ flag
+                : bindingAttr;
+        }
+
+        private static void GetChildPrivateProperties(IList<PropertyInfo> initialProperties, Type targetType, BindingFlags bindingAttr)
+        {
+            // fix weirdness with private PropertyInfos only being returned for the current Type
+            // find base type properties and add them to result
+
+            // also find base properties that have been hidden by subtype properties with the same name
+
+            while ((targetType = targetType.BaseType()) != null)
+            {
+                foreach (PropertyInfo propertyInfo in targetType.GetProperties(bindingAttr))
+                {
+                    PropertyInfo subTypeProperty = propertyInfo;
+
+                    if (!subTypeProperty.IsVirtual())
+                    {
+                        if (!IsPublic(subTypeProperty))
+                        {
+                            // have to test on name rather than reference because instances are different
+                            // depending on the type that GetProperties was called on
+                            int index = initialProperties.IndexOf(p => p.Name == subTypeProperty.Name);
+                            if (index == -1)
+                            {
+                                initialProperties.Add(subTypeProperty);
+                            }
+                            else
+                            {
+                                PropertyInfo childProperty = initialProperties[index];
+                                // don't replace public child with private base
+                                if (!IsPublic(childProperty))
+                                {
+                                    // replace nonpublic properties for a child, but gotten from
+                                    // the parent with the one from the child
+                                    // the property gotten from the child will have access to private getter/setter
+                                    initialProperties[index] = subTypeProperty;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            int index = initialProperties.IndexOf(p => p.Name == subTypeProperty.Name
+                                                                       && p.DeclaringType == subTypeProperty.DeclaringType);
+
+                            if (index == -1)
+                            {
+                                initialProperties.Add(subTypeProperty);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        Type subTypePropertyDeclaringType = subTypeProperty.GetBaseDefinition()?.DeclaringType ?? subTypeProperty.DeclaringType;
+
+                        int index = initialProperties.IndexOf(p => p.Name == subTypeProperty.Name
+                                                                   && p.IsVirtual()
+                                                                   && (p.GetBaseDefinition()?.DeclaringType ?? p.DeclaringType).IsAssignableFrom(subTypePropertyDeclaringType));
+
+                        // don't add a virtual property that has an override
+                        if (index == -1)
+                        {
+                            initialProperties.Add(subTypeProperty);
+                        }
+                    }
+                }
+            }
+        }
+
+        public static bool IsMethodOverridden(Type currentType, Type methodDeclaringType, string method)
+        {
+            bool isMethodOverriden = currentType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+                .Any(info =>
+                    info.Name == method &&
+                    // check that the method overrides the original on DynamicObjectProxy
+                    info.DeclaringType != methodDeclaringType
+                    && info.GetBaseDefinition().DeclaringType == methodDeclaringType
+                );
+
+            return isMethodOverriden;
+        }
+
+        public static object? GetDefaultValue(Type type)
+        {
+            if (!type.IsValueType())
+            {
+                return null;
+            }
+
+            switch (ConvertUtils.GetTypeCode(type))
+            {
+                case PrimitiveTypeCode.Boolean:
+                    return false;
+                case PrimitiveTypeCode.Char:
+                case PrimitiveTypeCode.SByte:
+                case PrimitiveTypeCode.Byte:
+                case PrimitiveTypeCode.Int16:
+                case PrimitiveTypeCode.UInt16:
+                case PrimitiveTypeCode.Int32:
+                case PrimitiveTypeCode.UInt32:
+                    return 0;
+                case PrimitiveTypeCode.Int64:
+                case PrimitiveTypeCode.UInt64:
+                    return 0L;
+                case PrimitiveTypeCode.Single:
+                    return 0f;
+                case PrimitiveTypeCode.Double:
+                    return 0.0;
+                case PrimitiveTypeCode.Decimal:
+                    return 0m;
+                case PrimitiveTypeCode.DateTime:
+                    return new DateTime();
+#if HAVE_BIG_INTEGER
+                case PrimitiveTypeCode.BigInteger:
+                    return new BigInteger();
+#endif
+                case PrimitiveTypeCode.Guid:
+                    return new Guid();
+#if HAVE_DATE_TIME_OFFSET
+                case PrimitiveTypeCode.DateTimeOffset:
+                    return new DateTimeOffset();
+#endif
+            }
+
+            if (IsNullable(type))
+            {
+                return null;
+            }
+
+            // possibly use IL initobj for perf here?
+            return Activator.CreateInstance(type);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/StringBuffer.cs b/Libs/Newtonsoft.Json/Utilities/StringBuffer.cs
new file mode 100644
index 0000000..129ba03
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/StringBuffer.cs
@@ -0,0 +1,116 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    /// <summary>
+    /// Builds a string. Unlike <see cref="System.Text.StringBuilder"/> this class lets you reuse its internal buffer.
+    /// </summary>
+    internal struct StringBuffer
+    {
+        private char[]? _buffer;
+        private int _position;
+
+        public int Position
+        {
+            get => _position;
+            set => _position = value;
+        }
+
+        public bool IsEmpty => _buffer == null;
+
+        public StringBuffer(IArrayPool<char>? bufferPool, int initalSize) : this(BufferUtils.RentBuffer(bufferPool, initalSize))
+        {
+        }
+
+        private StringBuffer(char[] buffer)
+        {
+            _buffer = buffer;
+            _position = 0;
+        }
+
+        public void Append(IArrayPool<char>? bufferPool, char value)
+        {
+            // test if the buffer array is large enough to take the value
+            if (_position == _buffer!.Length)
+            {
+                EnsureSize(bufferPool, 1);
+            }
+
+            // set value and increment poisition
+            _buffer![_position++] = value;
+        }
+
+        public void Append(IArrayPool<char>? bufferPool, char[] buffer, int startIndex, int count)
+        {
+            if (_position + count >= _buffer!.Length)
+            {
+                EnsureSize(bufferPool, count);
+            }
+
+            Array.Copy(buffer, startIndex, _buffer, _position, count);
+
+            _position += count;
+        }
+
+        public void Clear(IArrayPool<char>? bufferPool)
+        {
+            if (_buffer != null)
+            {
+                BufferUtils.ReturnBuffer(bufferPool, _buffer);
+                _buffer = null;
+            }
+            _position = 0;
+        }
+
+        private void EnsureSize(IArrayPool<char>? bufferPool, int appendLength)
+        {
+            char[] newBuffer = BufferUtils.RentBuffer(bufferPool, (_position + appendLength) * 2);
+
+            if (_buffer != null)
+            {
+                Array.Copy(_buffer, newBuffer, _position);
+                BufferUtils.ReturnBuffer(bufferPool, _buffer);
+            }
+
+            _buffer = newBuffer;
+        }
+
+        public override string ToString()
+        {
+            return ToString(0, _position);
+        }
+
+        public string ToString(int start, int length)
+        {
+            // TODO: validation
+            return new string(_buffer, start, length);
+        }
+
+        public char[]? InternalBuffer => _buffer;
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/StringReference.cs b/Libs/Newtonsoft.Json/Utilities/StringReference.cs
new file mode 100644
index 0000000..a0439a9
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/StringReference.cs
@@ -0,0 +1,111 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal readonly struct StringReference
+    {
+        private readonly char[] _chars;
+        private readonly int _startIndex;
+        private readonly int _length;
+
+        public char this[int i] => _chars[i];
+
+        public char[] Chars => _chars;
+
+        public int StartIndex => _startIndex;
+
+        public int Length => _length;
+
+        public StringReference(char[] chars, int startIndex, int length)
+        {
+            _chars = chars;
+            _startIndex = startIndex;
+            _length = length;
+        }
+
+        public override string ToString()
+        {
+            return new string(_chars, _startIndex, _length);
+        }
+    }
+
+    internal static class StringReferenceExtensions
+    {
+        public static int IndexOf(this StringReference s, char c, int startIndex, int length)
+        {
+            int index = Array.IndexOf(s.Chars, c, s.StartIndex + startIndex, length);
+            if (index == -1)
+            {
+                return -1;
+            }
+
+            return index - s.StartIndex;
+        }
+
+        public static bool StartsWith(this StringReference s, string text)
+        {
+            if (text.Length > s.Length)
+            {
+                return false;
+            }
+
+            char[] chars = s.Chars;
+
+            for (int i = 0; i < text.Length; i++)
+            {
+                if (text[i] != chars[i + s.StartIndex])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool EndsWith(this StringReference s, string text)
+        {
+            if (text.Length > s.Length)
+            {
+                return false;
+            }
+
+            char[] chars = s.Chars;
+
+            int start = s.StartIndex + s.Length - text.Length;
+            for (int i = 0; i < text.Length; i++)
+            {
+                if (text[i] != chars[i + start])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/StringUtils.cs b/Libs/Newtonsoft.Json/Utilities/StringUtils.cs
new file mode 100644
index 0000000..38f6fb4
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/StringUtils.cs
@@ -0,0 +1,354 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Globalization;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class StringUtils
+    {
+        public const string CarriageReturnLineFeed = "\r\n";
+        public const string Empty = "";
+        public const char CarriageReturn = '\r';
+        public const char LineFeed = '\n';
+        public const char Tab = '\t';
+
+        public static bool IsNullOrEmpty([NotNullWhen(false)] string? value)
+        {
+            return string.IsNullOrEmpty(value);
+        }
+
+        public static string FormatWith(this string format, IFormatProvider provider, object? arg0)
+        {
+            return format.FormatWith(provider, new object?[] { arg0 });
+        }
+
+        public static string FormatWith(this string format, IFormatProvider provider, object? arg0, object? arg1)
+        {
+            return format.FormatWith(provider, new object?[] { arg0, arg1 });
+        }
+
+        public static string FormatWith(this string format, IFormatProvider provider, object? arg0, object? arg1, object? arg2)
+        {
+            return format.FormatWith(provider, new object?[] { arg0, arg1, arg2 });
+        }
+
+        public static string FormatWith(this string format, IFormatProvider provider, object? arg0, object? arg1, object? arg2, object? arg3)
+        {
+            return format.FormatWith(provider, new object?[] { arg0, arg1, arg2, arg3 });
+        }
+
+        private static string FormatWith(this string format, IFormatProvider provider, params object?[] args)
+        {
+            // leave this a private to force code to use an explicit overload
+            // avoids stack memory being reserved for the object array
+            ValidationUtils.ArgumentNotNull(format, nameof(format));
+
+            return string.Format(provider, format, args);
+        }
+
+        /// <summary>
+        /// Determines whether the string is all white space. Empty string will return <c>false</c>.
+        /// </summary>
+        /// <param name="s">The string to test whether it is all white space.</param>
+        /// <returns>
+        /// 	<c>true</c> if the string is all white space; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsWhiteSpace(string s)
+        {
+            if (s == null)
+            {
+                throw new ArgumentNullException(nameof(s));
+            }
+
+            if (s.Length == 0)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < s.Length; i++)
+            {
+                if (!char.IsWhiteSpace(s[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static StringWriter CreateStringWriter(int capacity)
+        {
+            StringBuilder sb = new StringBuilder(capacity);
+            StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);
+
+            return sw;
+        }
+
+        public static void ToCharAsUnicode(char c, char[] buffer)
+        {
+            buffer[0] = '\\';
+            buffer[1] = 'u';
+            buffer[2] = MathUtils.IntToHex((c >> 12) & '\x000f');
+            buffer[3] = MathUtils.IntToHex((c >> 8) & '\x000f');
+            buffer[4] = MathUtils.IntToHex((c >> 4) & '\x000f');
+            buffer[5] = MathUtils.IntToHex(c & '\x000f');
+        }
+
+        public static TSource ForgivingCaseSensitiveFind<TSource>(this IEnumerable<TSource> source, Func<TSource, string> valueSelector, string testValue)
+        {
+            if (source == null)
+            {
+                throw new ArgumentNullException(nameof(source));
+            }
+            if (valueSelector == null)
+            {
+                throw new ArgumentNullException(nameof(valueSelector));
+            }
+
+            IEnumerable<TSource> caseInsensitiveResults = source.Where(s => string.Equals(valueSelector(s), testValue, StringComparison.OrdinalIgnoreCase));
+            if (caseInsensitiveResults.Count() <= 1)
+            {
+                return caseInsensitiveResults.SingleOrDefault();
+            }
+            else
+            {
+                // multiple results returned. now filter using case sensitivity
+                IEnumerable<TSource> caseSensitiveResults = source.Where(s => string.Equals(valueSelector(s), testValue, StringComparison.Ordinal));
+                return caseSensitiveResults.SingleOrDefault();
+            }
+        }
+
+        public static string ToCamelCase(string s)
+        {
+            if (StringUtils.IsNullOrEmpty(s) || !char.IsUpper(s[0]))
+            {
+                return s;
+            }
+
+            char[] chars = s.ToCharArray();
+
+            for (int i = 0; i < chars.Length; i++)
+            {
+                if (i == 1 && !char.IsUpper(chars[i]))
+                {
+                    break;
+                }
+
+                bool hasNext = (i + 1 < chars.Length);
+                if (i > 0 && hasNext && !char.IsUpper(chars[i + 1]))
+                {
+                    // if the next character is a space, which is not considered uppercase 
+                    // (otherwise we wouldn't be here...)
+                    // we want to ensure that the following:
+                    // 'FOO bar' is rewritten as 'foo bar', and not as 'foO bar'
+                    // The code was written in such a way that the first word in uppercase
+                    // ends when if finds an uppercase letter followed by a lowercase letter.
+                    // now a ' ' (space, (char)32) is considered not upper
+                    // but in that case we still want our current character to become lowercase
+                    if (char.IsSeparator(chars[i + 1]))
+                    {
+                        chars[i] = ToLower(chars[i]);
+                    }
+
+                    break;
+                }
+
+                chars[i] = ToLower(chars[i]);
+            }
+
+            return new string(chars);
+        }
+
+        private static char ToLower(char c)
+        {
+#if HAVE_CHAR_TO_LOWER_WITH_CULTURE
+            c = char.ToLower(c, CultureInfo.InvariantCulture);
+#else
+            c = char.ToLowerInvariant(c);
+#endif
+            return c;
+        }
+
+        public static string ToSnakeCase(string s) => ToSeparatedCase(s, '_');
+
+        public static string ToKebabCase(string s) => ToSeparatedCase(s, '-');
+
+        private enum SeparatedCaseState
+        {
+            Start,
+            Lower,
+            Upper,
+            NewWord
+        }
+
+        private static string ToSeparatedCase(string s, char separator)
+        {
+            if (StringUtils.IsNullOrEmpty(s))
+            {
+                return s;
+            }
+
+            StringBuilder sb = new StringBuilder();
+            SeparatedCaseState state = SeparatedCaseState.Start;
+
+            for (int i = 0; i < s.Length; i++)
+            {
+                if (s[i] == ' ')
+                {
+                    if (state != SeparatedCaseState.Start)
+                    {
+                        state = SeparatedCaseState.NewWord;
+                    }
+                }
+                else if (char.IsUpper(s[i]))
+                {
+                    switch (state)
+                    {
+                        case SeparatedCaseState.Upper:
+                            bool hasNext = (i + 1 < s.Length);
+                            if (i > 0 && hasNext)
+                            {
+                                char nextChar = s[i + 1];
+                                if (!char.IsUpper(nextChar) && nextChar != separator)
+                                {
+                                    sb.Append(separator);
+                                }
+                            }
+                            break;
+                        case SeparatedCaseState.Lower:
+                        case SeparatedCaseState.NewWord:
+                            sb.Append(separator);
+                            break;
+                    }
+
+                    char c;
+#if HAVE_CHAR_TO_LOWER_WITH_CULTURE
+                    c = char.ToLower(s[i], CultureInfo.InvariantCulture);
+#else
+                    c = char.ToLowerInvariant(s[i]);
+#endif
+                    sb.Append(c);
+
+                    state = SeparatedCaseState.Upper;
+                }
+                else if (s[i] == separator)
+                {
+                    sb.Append(separator);
+                    state = SeparatedCaseState.Start;
+                }
+                else
+                {
+                    if (state == SeparatedCaseState.NewWord)
+                    {
+                        sb.Append(separator);
+                    }
+
+                    sb.Append(s[i]);
+                    state = SeparatedCaseState.Lower;
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        public static bool IsHighSurrogate(char c)
+        {
+#if HAVE_UNICODE_SURROGATE_DETECTION
+            return char.IsHighSurrogate(c);
+#else
+            return (c >= 55296 && c <= 56319);
+#endif
+        }
+
+        public static bool IsLowSurrogate(char c)
+        {
+#if HAVE_UNICODE_SURROGATE_DETECTION
+            return char.IsLowSurrogate(c);
+#else
+            return (c >= 56320 && c <= 57343);
+#endif
+        }
+
+        public static bool StartsWith(this string source, char value)
+        {
+            return (source.Length > 0 && source[0] == value);
+        }
+
+        public static bool EndsWith(this string source, char value)
+        {
+            return (source.Length > 0 && source[source.Length - 1] == value);
+        }
+
+        public static string Trim(this string s, int start, int length)
+        {
+            // References: https://referencesource.microsoft.com/#mscorlib/system/string.cs,2691
+            // https://referencesource.microsoft.com/#mscorlib/system/string.cs,1226
+            if (s == null)
+            {
+                throw new ArgumentNullException();
+            }
+            if (start < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(start));
+            }
+            if (length < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(length));
+            }
+            int end = start + length - 1;
+            if (end >= s.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(length));
+            }
+            for (; start < end; start++)
+            {
+                if (!char.IsWhiteSpace(s[start]))
+                {
+                    break;
+                }
+            }
+            for (; end >= start; end--)
+            {
+                if (!char.IsWhiteSpace(s[end]))
+                {
+                    break;
+                }
+            }
+            return s.Substring(start, end - start + 1);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/StructMultiKey.cs b/Libs/Newtonsoft.Json/Utilities/StructMultiKey.cs
new file mode 100644
index 0000000..84bfc04
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/StructMultiKey.cs
@@ -0,0 +1,61 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal readonly struct StructMultiKey<T1, T2> : IEquatable<StructMultiKey<T1, T2>>
+    {
+        public readonly T1 Value1;
+        public readonly T2 Value2;
+
+        public StructMultiKey(T1 v1, T2 v2)
+        {
+            Value1 = v1;
+            Value2 = v2;
+        }
+
+        public override int GetHashCode()
+        {
+            return (Value1?.GetHashCode() ?? 0) ^ (Value2?.GetHashCode() ?? 0);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is StructMultiKey<T1, T2> key))
+            {
+                return false;
+            }
+
+            return Equals(key);
+        }
+
+        public bool Equals(StructMultiKey<T1, T2> other)
+        {
+            return (Equals(Value1, other.Value1) && Equals(Value2, other.Value2));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ThreadSafeStore.cs b/Libs/Newtonsoft.Json/Utilities/ThreadSafeStore.cs
new file mode 100644
index 0000000..d8331ff
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ThreadSafeStore.cs
@@ -0,0 +1,109 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+#if HAVE_CONCURRENT_DICTIONARY
+using System.Collections.Concurrent;
+#endif
+using System.Threading;
+using LC.Newtonsoft.Json.Serialization;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal class ThreadSafeStore<TKey, TValue>
+    {
+#if HAVE_CONCURRENT_DICTIONARY
+        private readonly ConcurrentDictionary<TKey, TValue> _concurrentStore;
+#else
+        private readonly object _lock = new object();
+        private Dictionary<TKey, TValue> _store;
+#endif
+        private readonly Func<TKey, TValue> _creator;
+
+        public ThreadSafeStore(Func<TKey, TValue> creator)
+        {
+            ValidationUtils.ArgumentNotNull(creator, nameof(creator));
+
+            _creator = creator;
+#if HAVE_CONCURRENT_DICTIONARY
+            _concurrentStore = new ConcurrentDictionary<TKey, TValue>();
+#else
+            _store = new Dictionary<TKey, TValue>();
+#endif
+        }
+
+        public TValue Get(TKey key)
+        {
+#if HAVE_CONCURRENT_DICTIONARY
+            return _concurrentStore.GetOrAdd(key, _creator);
+#else
+            if (!_store.TryGetValue(key, out TValue value))
+            {
+                return AddValue(key);
+            }
+
+            return value;
+#endif
+        }
+
+#if !HAVE_CONCURRENT_DICTIONARY
+        private TValue AddValue(TKey key)
+        {
+            TValue value = _creator(key);
+
+            lock (_lock)
+            {
+                if (_store == null)
+                {
+                    _store = new Dictionary<TKey, TValue>();
+                    _store[key] = value;
+                }
+                else
+                {
+                    // double check locking
+                    if (_store.TryGetValue(key, out TValue checkValue))
+                    {
+                        return checkValue;
+                    }
+
+                    Dictionary<TKey, TValue> newStore = new Dictionary<TKey, TValue>(_store);
+                    newStore[key] = value;
+
+#if HAVE_MEMORY_BARRIER
+                    Thread.MemoryBarrier();
+#endif
+                    _store = newStore;
+                }
+
+                return value;
+            }
+        }
+#endif
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/TypeExtensions.cs b/Libs/Newtonsoft.Json/Utilities/TypeExtensions.cs
new file mode 100644
index 0000000..a3c5dc9
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/TypeExtensions.cs
@@ -0,0 +1,634 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+#if !HAVE_LINQ
+using LC.Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class TypeExtensions
+    {
+#if DOTNET || PORTABLE
+#if !DOTNET
+        private static readonly BindingFlags DefaultFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
+
+        public static MethodInfo? GetGetMethod(this PropertyInfo propertyInfo)
+        {
+            return propertyInfo.GetGetMethod(false);
+        }
+
+        public static MethodInfo? GetGetMethod(this PropertyInfo propertyInfo, bool nonPublic)
+        {
+            MethodInfo getMethod = propertyInfo.GetMethod;
+            if (getMethod != null && (getMethod.IsPublic || nonPublic))
+            {
+                return getMethod;
+            }
+
+            return null;
+        }
+
+        public static MethodInfo? GetSetMethod(this PropertyInfo propertyInfo)
+        {
+            return propertyInfo.GetSetMethod(false);
+        }
+
+        public static MethodInfo? GetSetMethod(this PropertyInfo propertyInfo, bool nonPublic)
+        {
+            MethodInfo setMethod = propertyInfo.SetMethod;
+            if (setMethod != null && (setMethod.IsPublic || nonPublic))
+            {
+                return setMethod;
+            }
+
+            return null;
+        }
+#endif
+
+        public static bool IsSubclassOf(this Type type, Type c)
+        {
+            return type.GetTypeInfo().IsSubclassOf(c);
+        }
+
+#if !DOTNET
+        public static bool IsAssignableFrom(this Type type, Type c)
+        {
+            return type.GetTypeInfo().IsAssignableFrom(c.GetTypeInfo());
+        }
+#endif
+
+        public static bool IsInstanceOfType(this Type type, object? o)
+        {
+            if (o == null)
+            {
+                return false;
+            }
+
+            return type.IsAssignableFrom(o.GetType());
+        }
+#endif
+
+        public static MethodInfo Method(this Delegate d)
+        {
+#if HAVE_FULL_REFLECTION
+            return d.Method;
+#else
+            return d.GetMethodInfo();
+#endif
+        }
+
+        public static MemberTypes MemberType(this MemberInfo memberInfo)
+        {
+#if !(DOTNET || PORTABLE || PORTABLE40)
+            return memberInfo.MemberType;
+#else
+            if (memberInfo is PropertyInfo)
+            {
+                return MemberTypes.Property;
+            }
+            else if (memberInfo is FieldInfo)
+            {
+                return MemberTypes.Field;
+            }
+            else if (memberInfo is EventInfo)
+            {
+                return MemberTypes.Event;
+            }
+            else if (memberInfo is MethodInfo)
+            {
+                return MemberTypes.Method;
+            }
+            else
+            {
+                return default;
+            }
+#endif
+        }
+
+        public static bool ContainsGenericParameters(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.ContainsGenericParameters;
+#else
+            return type.GetTypeInfo().ContainsGenericParameters;
+#endif
+        }
+
+        public static bool IsInterface(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsInterface;
+#else
+            return type.GetTypeInfo().IsInterface;
+#endif
+        }
+
+        public static bool IsGenericType(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsGenericType;
+#else
+            return type.GetTypeInfo().IsGenericType;
+#endif
+        }
+
+        public static bool IsGenericTypeDefinition(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsGenericTypeDefinition;
+#else
+            return type.GetTypeInfo().IsGenericTypeDefinition;
+#endif
+        }
+
+        public static Type BaseType(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.BaseType;
+#else
+            return type.GetTypeInfo().BaseType;
+#endif
+        }
+
+        public static Assembly Assembly(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.Assembly;
+#else
+            return type.GetTypeInfo().Assembly;
+#endif
+        }
+
+        public static bool IsEnum(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsEnum;
+#else
+            return type.GetTypeInfo().IsEnum;
+#endif
+        }
+
+        public static bool IsClass(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsClass;
+#else
+            return type.GetTypeInfo().IsClass;
+#endif
+        }
+
+        public static bool IsSealed(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsSealed;
+#else
+            return type.GetTypeInfo().IsSealed;
+#endif
+        }
+
+#if (PORTABLE40 || DOTNET || PORTABLE)
+        public static PropertyInfo GetProperty(this Type type, string name, BindingFlags bindingFlags, object? placeholder1, Type propertyType, IList<Type> indexParameters, object? placeholder2)
+        {
+            IEnumerable<PropertyInfo> propertyInfos = type.GetProperties(bindingFlags);
+
+            return propertyInfos.Where(p =>
+            {
+                if (name != null && name != p.Name)
+                {
+                    return false;
+                }
+                if (propertyType != null && propertyType != p.PropertyType)
+                {
+                    return false;
+                }
+                if (indexParameters != null)
+                {
+                    if (!p.GetIndexParameters().Select(ip => ip.ParameterType).SequenceEqual(indexParameters))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }).SingleOrDefault();
+        }
+
+        public static IEnumerable<MemberInfo> GetMember(this Type type, string name, MemberTypes memberType, BindingFlags bindingFlags)
+        {
+#if PORTABLE
+            return type.GetMemberInternal(name, memberType, bindingFlags);
+#else
+            return type.GetMember(name, bindingFlags).Where(m =>
+            {
+                if ((m.MemberType() | memberType) != memberType)
+                {
+                    return false;
+                }
+
+                return true;
+            });
+#endif
+        }
+#endif
+
+#if (DOTNET || PORTABLE)
+        public static MethodInfo GetBaseDefinition(this MethodInfo method)
+        {
+            return method.GetRuntimeBaseDefinition();
+        }
+#endif
+
+#if (DOTNET || PORTABLE)
+        public static bool IsDefined(this Type type, Type attributeType, bool inherit)
+        {
+            return type.GetTypeInfo().CustomAttributes.Any(a => a.AttributeType == attributeType);
+        }
+
+#if !DOTNET
+        
+        public static MethodInfo GetMethod(this Type type, string name)
+        {
+            return type.GetMethod(name, DefaultFlags);
+        }
+
+        public static MethodInfo GetMethod(this Type type, string name, BindingFlags bindingFlags)
+        {
+            return type.GetTypeInfo().GetDeclaredMethod(name);
+        }
+
+        public static MethodInfo GetMethod(this Type type, IList<Type> parameterTypes)
+        {
+            return type.GetMethod(null, parameterTypes);
+        }
+
+        public static MethodInfo GetMethod(this Type type, string? name, IList<Type> parameterTypes)
+        {
+            return type.GetMethod(name, DefaultFlags, null, parameterTypes, null);
+        }
+
+        public static MethodInfo GetMethod(this Type type, string? name, BindingFlags bindingFlags, object? placeHolder1, IList<Type> parameterTypes, object? placeHolder2)
+        {
+            return MethodBinder.SelectMethod(type.GetTypeInfo().DeclaredMethods.Where(m => (name == null || m.Name == name) && TestAccessibility(m, bindingFlags)), parameterTypes);
+        }
+
+        public static IEnumerable<ConstructorInfo> GetConstructors(this Type type)
+        {
+            return type.GetConstructors(DefaultFlags);
+        }
+
+        public static IEnumerable<ConstructorInfo> GetConstructors(this Type type, BindingFlags bindingFlags)
+        {
+            return type.GetTypeInfo().DeclaredConstructors.Where(c => TestAccessibility(c, bindingFlags));
+        }
+        
+        public static ConstructorInfo GetConstructor(this Type type, IList<Type> parameterTypes)
+        {
+            return type.GetConstructor(DefaultFlags, null, parameterTypes, null);
+        }
+
+        public static ConstructorInfo GetConstructor(this Type type, BindingFlags bindingFlags, object? placeholder1, IList<Type> parameterTypes, object? placeholder2)
+        {
+            return MethodBinder.SelectMethod(type.GetConstructors(bindingFlags), parameterTypes);
+        }
+        
+        public static MemberInfo[] GetMember(this Type type, string member)
+        {
+            return type.GetMemberInternal(member, null, DefaultFlags);
+        }
+
+        public static MemberInfo[] GetMember(this Type type, string member, BindingFlags bindingFlags)
+        {
+            return type.GetMemberInternal(member, null, bindingFlags);
+        }
+
+        public static MemberInfo[] GetMemberInternal(this Type type, string member, MemberTypes? memberType, BindingFlags bindingFlags)
+        {
+            return type.GetTypeInfo().GetMembersRecursive().Where(m =>
+                m.Name == member &&
+                // test type before accessibility - accessibility doesn't support some types
+                (memberType == null || (m.MemberType() | memberType) == memberType) &&
+                TestAccessibility(m, bindingFlags)).ToArray();
+        }
+
+        public static FieldInfo? GetField(this Type type, string member)
+        {
+            return type.GetField(member, DefaultFlags);
+        }
+
+        public static FieldInfo? GetField(this Type type, string member, BindingFlags bindingFlags)
+        {
+            FieldInfo field = type.GetTypeInfo().GetDeclaredField(member);
+            if (field == null || !TestAccessibility(field, bindingFlags))
+            {
+                return null;
+            }
+            
+            return field;
+        }
+
+        public static IEnumerable<PropertyInfo> GetProperties(this Type type, BindingFlags bindingFlags)
+        {
+            IList<PropertyInfo> properties = (bindingFlags.HasFlag(BindingFlags.DeclaredOnly))
+                ? type.GetTypeInfo().DeclaredProperties.ToList()
+                : type.GetTypeInfo().GetPropertiesRecursive();
+
+            return properties.Where(p => TestAccessibility(p, bindingFlags));
+        }
+
+        private static bool ContainsMemberName(IEnumerable<MemberInfo> members, string name)
+        {
+            foreach (MemberInfo memberInfo in members)
+            {
+                if (memberInfo.Name == name)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static IList<MemberInfo> GetMembersRecursive(this TypeInfo type)
+        {
+            TypeInfo? t = type;
+            List<MemberInfo> members = new List<MemberInfo>();
+            while (t != null)
+            {
+                foreach (MemberInfo member in t.DeclaredMembers)
+                {
+                    if (!ContainsMemberName(members, member.Name))
+                    {
+                        members.Add(member);
+                    }
+                }
+                t = t.BaseType?.GetTypeInfo();
+            }
+
+            return members;
+        }
+
+        private static IList<PropertyInfo> GetPropertiesRecursive(this TypeInfo type)
+        {
+            TypeInfo? t = type;
+            List<PropertyInfo> properties = new List<PropertyInfo>();
+            while (t != null)
+            {
+                foreach (PropertyInfo member in t.DeclaredProperties)
+                {
+                    if (!ContainsMemberName(properties, member.Name))
+                    {
+                        properties.Add(member);
+                    }
+                }
+                t = t.BaseType?.GetTypeInfo();
+            }
+
+            return properties;
+        }
+
+        private static IList<FieldInfo> GetFieldsRecursive(this TypeInfo type)
+        {
+            TypeInfo? t = type;
+            List<FieldInfo> fields = new List<FieldInfo>();
+            while (t != null)
+            {
+                foreach (FieldInfo member in t.DeclaredFields)
+                {
+                    if (!ContainsMemberName(fields, member.Name))
+                    {
+                        fields.Add(member);
+                    }
+                }
+                t = t.BaseType?.GetTypeInfo();
+            }
+
+            return fields;
+        }
+
+        public static IEnumerable<MethodInfo> GetMethods(this Type type, BindingFlags bindingFlags)
+        {
+            return type.GetTypeInfo().DeclaredMethods;
+        }
+
+        public static PropertyInfo? GetProperty(this Type type, string name)
+        {
+            return type.GetProperty(name, DefaultFlags);
+        }
+
+        public static PropertyInfo? GetProperty(this Type type, string name, BindingFlags bindingFlags)
+        {
+            PropertyInfo property = type.GetTypeInfo().GetDeclaredProperty(name);
+            if (property == null || !TestAccessibility(property, bindingFlags))
+            {
+                return null;
+            }
+            
+            return property;
+        }
+
+        public static IEnumerable<FieldInfo> GetFields(this Type type)
+        {
+            return type.GetFields(DefaultFlags);
+        }
+
+        public static IEnumerable<FieldInfo> GetFields(this Type type, BindingFlags bindingFlags)
+        {
+            IList<FieldInfo> fields = (bindingFlags.HasFlag(BindingFlags.DeclaredOnly))
+                ? type.GetTypeInfo().DeclaredFields.ToList()
+                : type.GetTypeInfo().GetFieldsRecursive();
+
+            return fields.Where(f => TestAccessibility(f, bindingFlags)).ToList();
+        }
+
+        private static bool TestAccessibility(PropertyInfo member, BindingFlags bindingFlags)
+        {
+            if (member.GetMethod != null && TestAccessibility(member.GetMethod, bindingFlags))
+            {
+                return true;
+            }
+
+            if (member.SetMethod != null && TestAccessibility(member.SetMethod, bindingFlags))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private static bool TestAccessibility(MemberInfo member, BindingFlags bindingFlags)
+        {
+            if (member is FieldInfo f)
+            {
+                return TestAccessibility(f, bindingFlags);
+            }
+            else if (member is MethodBase m)
+            {
+                return TestAccessibility(m, bindingFlags);
+            }
+            else if (member is PropertyInfo p)
+            {
+                return TestAccessibility(p, bindingFlags);
+            }
+
+            throw new ArgumentOutOfRangeException("Unexpected member type.");
+        }
+
+        private static bool TestAccessibility(FieldInfo member, BindingFlags bindingFlags)
+        {
+            bool visibility = (member.IsPublic && bindingFlags.HasFlag(BindingFlags.Public)) ||
+                              (!member.IsPublic && bindingFlags.HasFlag(BindingFlags.NonPublic));
+
+            bool instance = (member.IsStatic && bindingFlags.HasFlag(BindingFlags.Static)) ||
+                            (!member.IsStatic && bindingFlags.HasFlag(BindingFlags.Instance));
+
+            return visibility && instance;
+        }
+
+        private static bool TestAccessibility(MethodBase member, BindingFlags bindingFlags)
+        {
+            bool visibility = (member.IsPublic && bindingFlags.HasFlag(BindingFlags.Public)) ||
+                              (!member.IsPublic && bindingFlags.HasFlag(BindingFlags.NonPublic));
+
+            bool instance = (member.IsStatic && bindingFlags.HasFlag(BindingFlags.Static)) ||
+                            (!member.IsStatic && bindingFlags.HasFlag(BindingFlags.Instance));
+
+            return visibility && instance;
+        }
+
+        public static Type[] GetGenericArguments(this Type type)
+        {
+            return type.GetTypeInfo().GenericTypeArguments;
+        }
+
+        public static IEnumerable<Type> GetInterfaces(this Type type)
+        {
+            return type.GetTypeInfo().ImplementedInterfaces;
+        }
+
+        public static IEnumerable<MethodInfo> GetMethods(this Type type)
+        {
+            return type.GetTypeInfo().DeclaredMethods;
+        }
+#endif
+#endif
+
+        public static bool IsAbstract(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsAbstract;
+#else
+            return type.GetTypeInfo().IsAbstract;
+#endif
+        }
+
+        public static bool IsVisible(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsVisible;
+#else
+            return type.GetTypeInfo().IsVisible;
+#endif
+        }
+
+        public static bool IsValueType(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsValueType;
+#else
+            return type.GetTypeInfo().IsValueType;
+#endif
+        }
+        
+        public static bool IsPrimitive(this Type type)
+        {
+#if HAVE_FULL_REFLECTION
+            return type.IsPrimitive;
+#else
+            return type.GetTypeInfo().IsPrimitive;
+#endif
+        }
+
+        public static bool AssignableToTypeName(this Type type, string fullTypeName, bool searchInterfaces, [NotNullWhen(true)]out Type? match)
+        {
+            Type current = type;
+
+            while (current != null)
+            {
+                if (string.Equals(current.FullName, fullTypeName, StringComparison.Ordinal))
+                {
+                    match = current;
+                    return true;
+                }
+
+                current = current.BaseType();
+            }
+
+            if (searchInterfaces)
+            {
+                foreach (Type i in type.GetInterfaces())
+                {
+                    if (string.Equals(i.Name, fullTypeName, StringComparison.Ordinal))
+                    {
+                        match = type;
+                        return true;
+                    }
+                }
+            }
+
+            match = null;
+            return false;
+        }
+
+        public static bool AssignableToTypeName(this Type type, string fullTypeName, bool searchInterfaces)
+        {
+            return type.AssignableToTypeName(fullTypeName, searchInterfaces, out _);
+        }
+
+        public static bool ImplementInterface(this Type type, Type interfaceType)
+        {
+            for (Type currentType = type; currentType != null; currentType = currentType.BaseType())
+            {
+                IEnumerable<Type> interfaces = currentType.GetInterfaces();
+                foreach (Type i in interfaces)
+                {
+                    if (i == interfaceType || (i != null && i.ImplementInterface(interfaceType)))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/Utilities/ValidationUtils.cs b/Libs/Newtonsoft.Json/Utilities/ValidationUtils.cs
new file mode 100644
index 0000000..a2d1873
--- /dev/null
+++ b/Libs/Newtonsoft.Json/Utilities/ValidationUtils.cs
@@ -0,0 +1,42 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace LC.Newtonsoft.Json.Utilities
+{
+    internal static class ValidationUtils
+    {
+        public static void ArgumentNotNull([NotNull]object? value, string parameterName)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(parameterName);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/WriteState.cs b/Libs/Newtonsoft.Json/WriteState.cs
new file mode 100644
index 0000000..0e20669
--- /dev/null
+++ b/Libs/Newtonsoft.Json/WriteState.cs
@@ -0,0 +1,72 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+
+namespace LC.Newtonsoft.Json
+{
+    /// <summary>
+    /// Specifies the state of the <see cref="JsonWriter"/>.
+    /// </summary>
+    public enum WriteState
+    {
+        /// <summary>
+        /// An exception has been thrown, which has left the <see cref="JsonWriter"/> in an invalid state.
+        /// You may call the <see cref="JsonWriter.Close()"/> method to put the <see cref="JsonWriter"/> in the <c>Closed</c> state.
+        /// Any other <see cref="JsonWriter"/> method calls result in an <see cref="InvalidOperationException"/> being thrown.
+        /// </summary>
+        Error = 0,
+
+        /// <summary>
+        /// The <see cref="JsonWriter.Close()"/> method has been called.
+        /// </summary>
+        Closed = 1,
+
+        /// <summary>
+        /// An object is being written. 
+        /// </summary>
+        Object = 2,
+
+        /// <summary>
+        /// An array is being written.
+        /// </summary>
+        Array = 3,
+
+        /// <summary>
+        /// A constructor is being written.
+        /// </summary>
+        Constructor = 4,
+
+        /// <summary>
+        /// A property is being written.
+        /// </summary>
+        Property = 5,
+
+        /// <summary>
+        /// A <see cref="JsonWriter"/> write method has not been called.
+        /// </summary>
+        Start = 6
+    }
+}
\ No newline at end of file
diff --git a/Libs/Newtonsoft.Json/packageIcon.png b/Libs/Newtonsoft.Json/packageIcon.png
new file mode 100644
index 0000000..10c06a5
Binary files /dev/null and b/Libs/Newtonsoft.Json/packageIcon.png differ