diff --git a/SMAPI b/SMAPI
deleted file mode 160000
index 9e521091..00000000
--- a/SMAPI
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 9e521091fe4b13a9091bcb30c9f73ef210ace2dd
diff --git a/src/Harmony/Attributes.cs b/src/Harmony/Attributes.cs
new file mode 100644
index 00000000..14e4f513
--- /dev/null
+++ b/src/Harmony/Attributes.cs
@@ -0,0 +1,325 @@
+using System;
+using System.Collections.Generic;
+
+namespace Harmony
+{
+	public enum MethodType
+	{
+		Normal,
+		Getter,
+		Setter,
+		Constructor,
+		StaticConstructor
+	}
+
+	[Obsolete("This enum will be removed in the next major version. To define special methods, use MethodType")]
+	public enum PropertyMethod
+	{
+		Getter,
+		Setter
+	}
+
+	public enum ArgumentType
+	{
+		Normal,
+		Ref,
+		Out,
+		Pointer
+	}
+
+	public enum HarmonyPatchType
+	{
+		All,
+		Prefix,
+		Postfix,
+		Transpiler
+	}
+
+	public class HarmonyAttribute : Attribute
+	{
+		public HarmonyMethod info = new HarmonyMethod();
+	}
+
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
+	public class HarmonyPatch : HarmonyAttribute
+	{
+		// no argument (for use with TargetMethod)
+
+		public HarmonyPatch()
+		{
+		}
+
+		// starting with 'Type'
+
+		public HarmonyPatch(Type declaringType)
+		{
+			info.declaringType = declaringType;
+		}
+
+		public HarmonyPatch(Type declaringType, Type[] argumentTypes)
+		{
+			info.declaringType = declaringType;
+			info.argumentTypes = argumentTypes;
+		}
+
+		public HarmonyPatch(Type declaringType, string methodName)
+		{
+			info.declaringType = declaringType;
+			info.methodName = methodName;
+		}
+
+		public HarmonyPatch(Type declaringType, string methodName, params Type[] argumentTypes)
+		{
+			info.declaringType = declaringType;
+			info.methodName = methodName;
+			info.argumentTypes = argumentTypes;
+		}
+
+		public HarmonyPatch(Type declaringType, string methodName, Type[] argumentTypes, ArgumentType[] argumentVariations)
+		{
+			info.declaringType = declaringType;
+			info.methodName = methodName;
+			ParseSpecialArguments(argumentTypes, argumentVariations);
+		}
+
+		public HarmonyPatch(Type declaringType, MethodType methodType)
+		{
+			info.declaringType = declaringType;
+			info.methodType = methodType;
+		}
+
+		public HarmonyPatch(Type declaringType, MethodType methodType, params Type[] argumentTypes)
+		{
+			info.declaringType = declaringType;
+			info.methodType = methodType;
+			info.argumentTypes = argumentTypes;
+		}
+
+		public HarmonyPatch(Type declaringType, MethodType methodType, Type[] argumentTypes, ArgumentType[] argumentVariations)
+		{
+			info.declaringType = declaringType;
+			info.methodType = methodType;
+			ParseSpecialArguments(argumentTypes, argumentVariations);
+		}
+
+		public HarmonyPatch(Type declaringType, string propertyName, MethodType methodType)
+		{
+			info.declaringType = declaringType;
+			info.methodName = propertyName;
+			info.methodType = methodType;
+		}
+
+		// starting with 'string'
+
+		public HarmonyPatch(string methodName)
+		{
+			info.methodName = methodName;
+		}
+
+		public HarmonyPatch(string methodName, params Type[] argumentTypes)
+		{
+			info.methodName = methodName;
+			info.argumentTypes = argumentTypes;
+		}
+
+		public HarmonyPatch(string methodName, Type[] argumentTypes, ArgumentType[] argumentVariations)
+		{
+			info.methodName = methodName;
+			ParseSpecialArguments(argumentTypes, argumentVariations);
+		}
+
+		public HarmonyPatch(string propertyName, MethodType methodType)
+		{
+			info.methodName = propertyName;
+			info.methodType = methodType;
+		}
+
+		// starting with 'MethodType'
+
+		public HarmonyPatch(MethodType methodType)
+		{
+			info.methodType = methodType;
+		}
+
+		public HarmonyPatch(MethodType methodType, params Type[] argumentTypes)
+		{
+			info.methodType = methodType;
+			info.argumentTypes = argumentTypes;
+		}
+
+		public HarmonyPatch(MethodType methodType, Type[] argumentTypes, ArgumentType[] argumentVariations)
+		{
+			info.methodType = methodType;
+			ParseSpecialArguments(argumentTypes, argumentVariations);
+		}
+
+		// starting with 'Type[]'
+
+		public HarmonyPatch(Type[] argumentTypes)
+		{
+			info.argumentTypes = argumentTypes;
+		}
+
+		public HarmonyPatch(Type[] argumentTypes, ArgumentType[] argumentVariations)
+		{
+			ParseSpecialArguments(argumentTypes, argumentVariations);
+		}
+
+		// Obsolete attributes
+
+		[Obsolete("This attribute will be removed in the next major version. Use HarmonyPatch together with MethodType.Getter or MethodType.Setter instead")]
+		public HarmonyPatch(string propertyName, PropertyMethod type)
+		{
+			info.methodName = propertyName;
+			info.methodType = type == PropertyMethod.Getter ? MethodType.Getter : MethodType.Setter;
+		}
+
+		//
+
+		private void ParseSpecialArguments(Type[] argumentTypes, ArgumentType[] argumentVariations)
+		{
+			if (argumentVariations == null || argumentVariations.Length == 0)
+			{
+				info.argumentTypes = argumentTypes;
+				return;
+			}
+
+			if (argumentTypes.Length < argumentVariations.Length)
+				throw new ArgumentException("argumentVariations contains more elements than argumentTypes", nameof(argumentVariations));
+
+			var types = new List<Type>();
+			for (var i = 0; i < argumentTypes.Length; i++)
+			{
+				var type = argumentTypes[i];
+				switch (argumentVariations[i])
+				{
+					case ArgumentType.Ref:
+					case ArgumentType.Out:
+						type = type.MakeByRefType();
+						break;
+					case ArgumentType.Pointer:
+						type = type.MakePointerType();
+						break;
+				}
+				types.Add(type);
+			}
+			info.argumentTypes = types.ToArray();
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Class)]
+	public class HarmonyPatchAll : HarmonyAttribute
+	{
+		public HarmonyPatchAll()
+		{
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+	public class HarmonyPriority : HarmonyAttribute
+	{
+		public HarmonyPriority(int prioritiy)
+		{
+			info.prioritiy = prioritiy;
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+	public class HarmonyBefore : HarmonyAttribute
+	{
+		public HarmonyBefore(params string[] before)
+		{
+			info.before = before;
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+	public class HarmonyAfter : HarmonyAttribute
+	{
+		public HarmonyAfter(params string[] after)
+		{
+			info.after = after;
+		}
+	}
+
+	// If you don't want to use the special method names you can annotate
+	// using the following attributes:
+
+	[AttributeUsage(AttributeTargets.Method)]
+	public class HarmonyPrepare : Attribute
+	{
+	}
+
+	[AttributeUsage(AttributeTargets.Method)]
+	public class HarmonyCleanup : Attribute
+	{
+	}
+
+	[AttributeUsage(AttributeTargets.Method)]
+	public class HarmonyTargetMethod : Attribute
+	{
+	}
+
+	[AttributeUsage(AttributeTargets.Method)]
+	public class HarmonyTargetMethods : Attribute
+	{
+	}
+
+	[AttributeUsage(AttributeTargets.Method)]
+	public class HarmonyPrefix : Attribute
+	{
+	}
+
+	[AttributeUsage(AttributeTargets.Method)]
+	public class HarmonyPostfix : Attribute
+	{
+	}
+
+	[AttributeUsage(AttributeTargets.Method)]
+	public class HarmonyTranspiler : Attribute
+	{
+	}
+
+	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = true)]
+	public class HarmonyArgument : Attribute
+	{
+		public string OriginalName { get; private set; }
+		public int Index { get; private set; }
+		public string NewName { get; private set; }
+
+		public HarmonyArgument(string originalName) : this(originalName, null)
+		{
+		}
+
+		public HarmonyArgument(int index) : this(index, null)
+		{
+		}
+
+		public HarmonyArgument(string originalName, string newName)
+		{
+			OriginalName = originalName;
+			Index = -1;
+			NewName = newName;
+		}
+
+		public HarmonyArgument(int index, string name)
+		{
+			OriginalName = null;
+			Index = index;
+			NewName = name;
+		}
+	}
+
+	// This attribute is for Harmony patching itself to the latest
+	//
+	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor)]
+	internal class UpgradeToLatestVersion : Attribute
+	{
+		public int version;
+
+		public UpgradeToLatestVersion(int version)
+		{
+			this.version = version;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/CodeInstruction.cs b/src/Harmony/CodeInstruction.cs
new file mode 100644
index 00000000..a6d89726
--- /dev/null
+++ b/src/Harmony/CodeInstruction.cs
@@ -0,0 +1,62 @@
+using Harmony.ILCopying;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public class CodeInstruction
+	{
+		public OpCode opcode;
+		public object operand;
+		public List<Label> labels = new List<Label>();
+		public List<ExceptionBlock> blocks = new List<ExceptionBlock>();
+
+		public CodeInstruction(OpCode opcode, object operand = null)
+		{
+			this.opcode = opcode;
+			this.operand = operand;
+		}
+
+		public CodeInstruction(CodeInstruction instruction)
+		{
+			opcode = instruction.opcode;
+			operand = instruction.operand;
+			labels = instruction.labels.ToArray().ToList();
+		}
+
+		public CodeInstruction Clone()
+		{
+			return new CodeInstruction(this) { labels = new List<Label>() };
+		}
+
+		public CodeInstruction Clone(OpCode opcode)
+		{
+			var instruction = new CodeInstruction(this) { labels = new List<Label>() };
+			instruction.opcode = opcode;
+			return instruction;
+		}
+
+		public CodeInstruction Clone(OpCode opcode, object operand)
+		{
+			var instruction = new CodeInstruction(this) { labels = new List<Label>() };
+			instruction.opcode = opcode;
+			instruction.operand = operand;
+			return instruction;
+		}
+
+		public override string ToString()
+		{
+			var list = new List<string>();
+			foreach (var label in labels)
+				list.Add("Label" + label.GetHashCode());
+			foreach (var block in blocks)
+				list.Add("EX_" + block.blockType.ToString().Replace("Block", ""));
+
+			var extras = list.Count > 0 ? " [" + string.Join(", ", list.ToArray()) + "]" : "";
+			var operandStr = Emitter.FormatArgument(operand);
+			if (operandStr != "") operandStr = " " + operandStr;
+			return opcode + operandStr + extras;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/CodeTranspiler.cs b/src/Harmony/CodeTranspiler.cs
new file mode 100644
index 00000000..6deb15bc
--- /dev/null
+++ b/src/Harmony/CodeTranspiler.cs
@@ -0,0 +1,295 @@
+using System.Collections.Generic;
+using Harmony.ILCopying;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System;
+using System.Collections;
+using System.Diagnostics;
+
+namespace Harmony
+{
+	public class CodeTranspiler
+	{
+		private IEnumerable<CodeInstruction> codeInstructions;
+		private List<MethodInfo> transpilers = new List<MethodInfo>();
+
+		public CodeTranspiler(List<ILInstruction> ilInstructions)
+		{
+			codeInstructions = ilInstructions
+				.Select(ilInstruction => ilInstruction.GetCodeInstruction())
+				.ToList().AsEnumerable();
+		}
+
+		public void Add(MethodInfo transpiler)
+		{
+			transpilers.Add(transpiler);
+		}
+
+		[UpgradeToLatestVersion(1)]
+		public static object ConvertInstruction(Type type, object op, out Dictionary<string, object> unassigned)
+		{
+			var nonExisting = new Dictionary<string, object>();
+			var elementTo = AccessTools.MakeDeepCopy(op, type, (namePath, trvSrc, trvDest) =>
+			{
+				var value = trvSrc.GetValue();
+
+				if (trvDest.FieldExists() == false)
+				{
+					nonExisting[namePath] = value;
+					return null;
+				}
+
+				if (namePath == nameof(CodeInstruction.opcode))
+					return ReplaceShortJumps((OpCode)value);
+
+				return value;
+			});
+			unassigned = nonExisting;
+			return elementTo;
+		}
+
+		// ShouldAddExceptionInfo is used to determine if CodeInstructions from an older Harmony version were duplicating
+		// exception information as well as to preserve the exception information from being dropped when piping through
+		// multiple transpilers with mixed Harmony versions.
+		//
+		public static bool ShouldAddExceptionInfo(object op, int opIndex, List<object> originalInstructions, List<object> newInstructions, Dictionary<object, Dictionary<string, object>> unassignedValues)
+		{
+			var originalIndex = originalInstructions.IndexOf(op);
+			if (originalIndex == -1)
+				return false; // no need, new instruction
+
+			Dictionary<string, object> unassigned = null;
+			if (unassignedValues.TryGetValue(op, out unassigned) == false)
+				return false; // no need, no unassigned info
+
+			if (unassigned.TryGetValue(nameof(CodeInstruction.blocks), out var blocksObject) == false)
+				return false; // no need, no try-catch info
+			var blocks = blocksObject as List<ExceptionBlock>;
+
+			var dupCount = newInstructions.Count(instr => instr == op);
+			if (dupCount <= 1)
+				return true; // ok, no duplicate found
+
+			var isStartBlock = blocks.FirstOrDefault(block => block.blockType != ExceptionBlockType.EndExceptionBlock);
+			var isEndBlock = blocks.FirstOrDefault(block => block.blockType == ExceptionBlockType.EndExceptionBlock);
+
+			if (isStartBlock != null && isEndBlock == null)
+			{
+				var pairInstruction = originalInstructions.Skip(originalIndex + 1).FirstOrDefault(instr =>
+				{
+					if (unassignedValues.TryGetValue(instr, out unassigned) == false)
+						return false;
+					if (unassigned.TryGetValue(nameof(CodeInstruction.blocks), out blocksObject) == false)
+						return false;
+					blocks = blocksObject as List<ExceptionBlock>;
+					return blocks.Count() > 0;
+				});
+				if (pairInstruction != null)
+				{
+					var pairStart = originalIndex + 1;
+					var pairEnd = pairStart + originalInstructions.Skip(pairStart).ToList().IndexOf(pairInstruction) - 1;
+					var originalBetweenInstructions = originalInstructions
+						.GetRange(pairStart, pairEnd - pairStart)
+						.Intersect(newInstructions);
+
+					pairInstruction = newInstructions.Skip(opIndex + 1).FirstOrDefault(instr =>
+					{
+						if (unassignedValues.TryGetValue(instr, out unassigned) == false)
+							return false;
+						if (unassigned.TryGetValue(nameof(CodeInstruction.blocks), out blocksObject) == false)
+							return false;
+						blocks = blocksObject as List<ExceptionBlock>;
+						return blocks.Count() > 0;
+					});
+					if (pairInstruction != null)
+					{
+						pairStart = opIndex + 1;
+						pairEnd = pairStart + newInstructions.Skip(opIndex + 1).ToList().IndexOf(pairInstruction) - 1;
+						var newBetweenInstructions = newInstructions.GetRange(pairStart, pairEnd - pairStart);
+						var remaining = originalBetweenInstructions.Except(newBetweenInstructions).ToList();
+						return remaining.Count() == 0;
+					}
+				}
+			}
+			if (isStartBlock == null && isEndBlock != null)
+			{
+				var pairInstruction = originalInstructions.GetRange(0, originalIndex).LastOrDefault(instr =>
+				{
+					if (unassignedValues.TryGetValue(instr, out unassigned) == false)
+						return false;
+					if (unassigned.TryGetValue(nameof(CodeInstruction.blocks), out blocksObject) == false)
+						return false;
+					blocks = blocksObject as List<ExceptionBlock>;
+					return blocks.Count() > 0;
+				});
+				if (pairInstruction != null)
+				{
+					var pairStart = originalInstructions.GetRange(0, originalIndex).LastIndexOf(pairInstruction);
+					var pairEnd = originalIndex;
+					var originalBetweenInstructions = originalInstructions
+						.GetRange(pairStart, pairEnd - pairStart)
+						.Intersect(newInstructions);
+
+					pairInstruction = newInstructions.GetRange(0, opIndex).LastOrDefault(instr =>
+					{
+						if (unassignedValues.TryGetValue(instr, out unassigned) == false)
+							return false;
+						if (unassigned.TryGetValue(nameof(CodeInstruction.blocks), out blocksObject) == false)
+							return false;
+						blocks = blocksObject as List<ExceptionBlock>;
+						return blocks.Count() > 0;
+					});
+					if (pairInstruction != null)
+					{
+						pairStart = newInstructions.GetRange(0, opIndex).LastIndexOf(pairInstruction);
+						pairEnd = opIndex;
+						var newBetweenInstructions = newInstructions.GetRange(pairStart, pairEnd - pairStart);
+						var remaining = originalBetweenInstructions.Except(newBetweenInstructions);
+						return remaining.Count() == 0;
+					}
+				}
+			}
+
+			// unclear or unexpected case, ok by default
+			return true;
+		}
+
+		public static IEnumerable ConvertInstructionsAndUnassignedValues(Type type, IEnumerable enumerable, out Dictionary<object, Dictionary<string, object>> unassignedValues)
+		{
+			var enumerableAssembly = type.GetGenericTypeDefinition().Assembly;
+			var genericListType = enumerableAssembly.GetType(typeof(List<>).FullName);
+			var elementType = type.GetGenericArguments()[0];
+			var listType = enumerableAssembly.GetType(genericListType.MakeGenericType(new Type[] { elementType }).FullName);
+			var list = Activator.CreateInstance(listType);
+			var listAdd = list.GetType().GetMethod("Add");
+			unassignedValues = new Dictionary<object, Dictionary<string, object>>();
+			foreach (var op in enumerable)
+			{
+				var elementTo = ConvertInstruction(elementType, op, out var unassigned);
+				unassignedValues.Add(elementTo, unassigned);
+				listAdd.Invoke(list, new object[] { elementTo });
+				// cannot yield return 'elementTo' here because we have an out parameter in the method
+			}
+			return list as IEnumerable;
+		}
+
+		[UpgradeToLatestVersion(1)]
+		public static IEnumerable ConvertToOurInstructions(IEnumerable instructions, List<object> originalInstructions, Dictionary<object, Dictionary<string, object>> unassignedValues)
+		{
+			// Since we are patching this method, we cannot use typeof(CodeInstruction)
+			// because that would use the CodeInstruction of the Harmony lib that patches
+			// us and we get a type assignment error.
+			// Instead, we know that our caller returns List<X> where X is the type we need
+			//
+			var codeInstructionType = new StackTrace().GetFrames()
+				.Select(frame => frame.GetMethod())
+				.OfType<MethodInfo>()
+				.Select(method =>
+				{
+					var returnType = method.ReturnType;
+					if (returnType.IsGenericType == false) return null;
+					var listTypes = returnType.GetGenericArguments();
+					if (listTypes.Length != 1) return null;
+					var type = listTypes[0];
+					return type.FullName == typeof(CodeInstruction).FullName ? type : null;
+				})
+				.Where(type => type != null)
+				.First();
+
+			var newInstructions = instructions.Cast<object>().ToList();
+
+			var index = -1;
+			foreach (var op in newInstructions)
+			{
+				index++;
+				var elementTo = AccessTools.MakeDeepCopy(op, codeInstructionType);
+				if (unassignedValues.TryGetValue(op, out var fields))
+				{
+					var addExceptionInfo = ShouldAddExceptionInfo(op, index, originalInstructions, newInstructions, unassignedValues);
+
+					var trv = Traverse.Create(elementTo);
+					foreach (var field in fields)
+					{
+						if (addExceptionInfo || field.Key != nameof(CodeInstruction.blocks))
+							trv.Field(field.Key).SetValue(field.Value);
+					}
+				}
+				yield return elementTo;
+			}
+		}
+
+		public static IEnumerable ConvertToGeneralInstructions(MethodInfo transpiler, IEnumerable enumerable, out Dictionary<object, Dictionary<string, object>> unassignedValues)
+		{
+			var type = transpiler.GetParameters()
+				  .Select(p => p.ParameterType)
+				  .FirstOrDefault(t => t.IsGenericType && t.GetGenericTypeDefinition().Name.StartsWith("IEnumerable"));
+			return ConvertInstructionsAndUnassignedValues(type, enumerable, out unassignedValues);
+		}
+
+		public static List<object> GetTranspilerCallParameters(ILGenerator generator, MethodInfo transpiler, MethodBase method, IEnumerable instructions)
+		{
+			var parameter = new List<object>();
+			transpiler.GetParameters().Select(param => param.ParameterType).Do(type =>
+			{
+				if (type.IsAssignableFrom(typeof(ILGenerator)))
+					parameter.Add(generator);
+				else if (type.IsAssignableFrom(typeof(MethodBase)))
+					parameter.Add(method);
+				else
+					parameter.Add(instructions);
+			});
+			return parameter;
+		}
+
+		public List<CodeInstruction> GetResult(ILGenerator generator, MethodBase method)
+		{
+			IEnumerable instructions = codeInstructions;
+			transpilers.ForEach(transpiler =>
+			{
+				// before calling some transpiler, convert the input to 'their' CodeInstruction type
+				// also remember any unassignable values that otherwise would be lost
+				instructions = ConvertToGeneralInstructions(transpiler, instructions, out var unassignedValues);
+
+				// remember the order of the original input (for detection of dupped code instructions)
+				var originalInstructions = new List<object>();
+				originalInstructions.AddRange(instructions.Cast<object>());
+
+				// call the transpiler
+				var parameter = GetTranspilerCallParameters(generator, transpiler, method, instructions);
+				instructions = transpiler.Invoke(null, parameter.ToArray()) as IEnumerable;
+
+				// convert result back to 'our' CodeInstruction and re-assign otherwise lost fields
+				instructions = ConvertToOurInstructions(instructions, originalInstructions, unassignedValues);
+			});
+			return instructions.Cast<CodeInstruction>().ToList();
+		}
+
+		//
+
+		static readonly Dictionary<OpCode, OpCode> allJumpCodes = new Dictionary<OpCode, OpCode>
+		{
+			{ OpCodes.Beq_S, OpCodes.Beq },
+			{ OpCodes.Bge_S, OpCodes.Bge },
+			{ OpCodes.Bge_Un_S, OpCodes.Bge_Un },
+			{ OpCodes.Bgt_S, OpCodes.Bgt },
+			{ OpCodes.Bgt_Un_S, OpCodes.Bgt_Un },
+			{ OpCodes.Ble_S, OpCodes.Ble },
+			{ OpCodes.Ble_Un_S, OpCodes.Ble_Un },
+			{ OpCodes.Blt_S, OpCodes.Blt },
+			{ OpCodes.Blt_Un_S, OpCodes.Blt_Un },
+			{ OpCodes.Bne_Un_S, OpCodes.Bne_Un },
+			{ OpCodes.Brfalse_S, OpCodes.Brfalse },
+			{ OpCodes.Brtrue_S, OpCodes.Brtrue },
+			{ OpCodes.Br_S, OpCodes.Br },
+			{ OpCodes.Leave_S, OpCodes.Leave }
+		};
+		static OpCode ReplaceShortJumps(OpCode opcode)
+		{
+			foreach (var pair in allJumpCodes)
+				if (opcode == pair.Key)
+					return pair.Value;
+			return opcode;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Extras/DelegateTypeFactory.cs b/src/Harmony/Extras/DelegateTypeFactory.cs
new file mode 100644
index 00000000..a7e45b9a
--- /dev/null
+++ b/src/Harmony/Extras/DelegateTypeFactory.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public class DelegateTypeFactory
+	{
+		readonly ModuleBuilder module;
+
+		static int counter;
+		public DelegateTypeFactory()
+		{
+			counter++;
+			var name = new AssemblyName("HarmonyDTFAssembly" + counter);
+			var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
+			module = assembly.DefineDynamicModule("HarmonyDTFModule" + counter);
+		}
+
+		public Type CreateDelegateType(MethodInfo method)
+		{
+			var attr = TypeAttributes.Sealed | TypeAttributes.Public;
+			var typeBuilder = module.DefineType("HarmonyDTFType" + counter, attr, typeof(MulticastDelegate));
+
+			var constructor = typeBuilder.DefineConstructor(
+				 MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public,
+				 CallingConventions.Standard, new[] { typeof(object), typeof(IntPtr) });
+			constructor.SetImplementationFlags(MethodImplAttributes.CodeTypeMask);
+
+			var parameters = method.GetParameters();
+
+			var invokeMethod = typeBuilder.DefineMethod(
+				 "Invoke", MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public,
+				 method.ReturnType, parameters.Types());
+			invokeMethod.SetImplementationFlags(MethodImplAttributes.CodeTypeMask);
+
+			for (var i = 0; i < parameters.Length; i++)
+				invokeMethod.DefineParameter(i + 1, ParameterAttributes.None, parameters[i].Name);
+
+			return typeBuilder.CreateType();
+		}
+	}
+}
diff --git a/src/Harmony/Extras/FastAccess.cs b/src/Harmony/Extras/FastAccess.cs
new file mode 100644
index 00000000..ad748319
--- /dev/null
+++ b/src/Harmony/Extras/FastAccess.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	// Based on https://www.codeproject.com/Articles/14973/Dynamic-Code-Generation-vs-Reflection
+
+	public delegate object GetterHandler(object source);
+	public delegate void SetterHandler(object source, object value);
+	public delegate object InstantiationHandler();
+
+	public class FastAccess
+	{
+		public static InstantiationHandler CreateInstantiationHandler(Type type)
+		{
+			var constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[0], null);
+			if (constructorInfo == null)
+			{
+				throw new ApplicationException(string.Format("The type {0} must declare an empty constructor (the constructor may be private, internal, protected, protected internal, or public).", type));
+			}
+
+			var dynamicMethod = new DynamicMethod("InstantiateObject_" + type.Name, MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, typeof(object), null, type, true);
+			var generator = dynamicMethod.GetILGenerator();
+			generator.Emit(OpCodes.Newobj, constructorInfo);
+			generator.Emit(OpCodes.Ret);
+			return (InstantiationHandler)dynamicMethod.CreateDelegate(typeof(InstantiationHandler));
+		}
+
+		public static GetterHandler CreateGetterHandler(PropertyInfo propertyInfo)
+		{
+			var getMethodInfo = propertyInfo.GetGetMethod(true);
+			var dynamicGet = CreateGetDynamicMethod(propertyInfo.DeclaringType);
+			var getGenerator = dynamicGet.GetILGenerator();
+
+			getGenerator.Emit(OpCodes.Ldarg_0);
+			getGenerator.Emit(OpCodes.Call, getMethodInfo);
+			BoxIfNeeded(getMethodInfo.ReturnType, getGenerator);
+			getGenerator.Emit(OpCodes.Ret);
+
+			return (GetterHandler)dynamicGet.CreateDelegate(typeof(GetterHandler));
+		}
+
+		public static GetterHandler CreateGetterHandler(FieldInfo fieldInfo)
+		{
+			var dynamicGet = CreateGetDynamicMethod(fieldInfo.DeclaringType);
+			var getGenerator = dynamicGet.GetILGenerator();
+
+			getGenerator.Emit(OpCodes.Ldarg_0);
+			getGenerator.Emit(OpCodes.Ldfld, fieldInfo);
+			BoxIfNeeded(fieldInfo.FieldType, getGenerator);
+			getGenerator.Emit(OpCodes.Ret);
+
+			return (GetterHandler)dynamicGet.CreateDelegate(typeof(GetterHandler));
+		}
+
+		public static GetterHandler CreateFieldGetter(Type type, params string[] names)
+		{
+			foreach (var name in names)
+			{
+				if (AccessTools.Field(typeof(ILGenerator), name) != null)
+					return CreateGetterHandler(AccessTools.Field(type, name));
+
+				if (AccessTools.Property(typeof(ILGenerator), name) != null)
+					return CreateGetterHandler(AccessTools.Property(type, name));
+			}
+			return null;
+		}
+
+		public static SetterHandler CreateSetterHandler(PropertyInfo propertyInfo)
+		{
+			var setMethodInfo = propertyInfo.GetSetMethod(true);
+			var dynamicSet = CreateSetDynamicMethod(propertyInfo.DeclaringType);
+			var setGenerator = dynamicSet.GetILGenerator();
+
+			setGenerator.Emit(OpCodes.Ldarg_0);
+			setGenerator.Emit(OpCodes.Ldarg_1);
+			UnboxIfNeeded(setMethodInfo.GetParameters()[0].ParameterType, setGenerator);
+			setGenerator.Emit(OpCodes.Call, setMethodInfo);
+			setGenerator.Emit(OpCodes.Ret);
+
+			return (SetterHandler)dynamicSet.CreateDelegate(typeof(SetterHandler));
+		}
+
+		public static SetterHandler CreateSetterHandler(FieldInfo fieldInfo)
+		{
+			var dynamicSet = CreateSetDynamicMethod(fieldInfo.DeclaringType);
+			var setGenerator = dynamicSet.GetILGenerator();
+
+			setGenerator.Emit(OpCodes.Ldarg_0);
+			setGenerator.Emit(OpCodes.Ldarg_1);
+			UnboxIfNeeded(fieldInfo.FieldType, setGenerator);
+			setGenerator.Emit(OpCodes.Stfld, fieldInfo);
+			setGenerator.Emit(OpCodes.Ret);
+
+			return (SetterHandler)dynamicSet.CreateDelegate(typeof(SetterHandler));
+		}
+
+		//
+
+		static DynamicMethod CreateGetDynamicMethod(Type type)
+		{
+			return new DynamicMethod("DynamicGet_" + type.Name, typeof(object), new Type[] { typeof(object) }, type, true);
+		}
+
+		static DynamicMethod CreateSetDynamicMethod(Type type)
+		{
+			return new DynamicMethod("DynamicSet_" + type.Name, typeof(void), new Type[] { typeof(object), typeof(object) }, type, true);
+		}
+
+		static void BoxIfNeeded(Type type, ILGenerator generator)
+		{
+			if (type.IsValueType)
+				generator.Emit(OpCodes.Box, type);
+		}
+
+		static void UnboxIfNeeded(Type type, ILGenerator generator)
+		{
+			if (type.IsValueType)
+				generator.Emit(OpCodes.Unbox_Any, type);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Extras/MethodInvoker.cs b/src/Harmony/Extras/MethodInvoker.cs
new file mode 100644
index 00000000..e45e2bf9
--- /dev/null
+++ b/src/Harmony/Extras/MethodInvoker.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	// Based on https://www.codeproject.com/Articles/14593/A-General-Fast-Method-Invoker
+
+	public delegate object FastInvokeHandler(object target, object[] paramters);
+
+	public class MethodInvoker
+	{
+		public static FastInvokeHandler GetHandler(DynamicMethod methodInfo, Module module)
+		{
+			return Handler(methodInfo, module);
+		}
+
+		public static FastInvokeHandler GetHandler(MethodInfo methodInfo)
+		{
+			return Handler(methodInfo, methodInfo.DeclaringType.Module);
+		}
+
+		static FastInvokeHandler Handler(MethodInfo methodInfo, Module module, bool directBoxValueAccess = false)
+		{
+			var dynamicMethod = new DynamicMethod("FastInvoke_" + methodInfo.Name + "_" + (directBoxValueAccess ? "direct" : "indirect"), typeof(object), new Type[] { typeof(object), typeof(object[]) }, module, true);
+			var il = dynamicMethod.GetILGenerator();
+
+			if (!methodInfo.IsStatic)
+			{
+				il.Emit(OpCodes.Ldarg_0);
+				EmitUnboxIfNeeded(il, methodInfo.DeclaringType);
+			}
+
+			var generateLocalBoxValuePtr = true;
+			var ps = methodInfo.GetParameters();
+			for (var i = 0; i < ps.Length; i++)
+			{
+				var argType = ps[i].ParameterType;
+				var argIsByRef = argType.IsByRef;
+				if (argIsByRef)
+					argType = argType.GetElementType();
+				var argIsValueType = argType.IsValueType;
+
+				if (argIsByRef && argIsValueType && !directBoxValueAccess)
+				{
+					// used later when storing back the reference to the new box in the array.
+					il.Emit(OpCodes.Ldarg_1);
+					EmitFastInt(il, i);
+				}
+
+				il.Emit(OpCodes.Ldarg_1);
+				EmitFastInt(il, i);
+
+				if (argIsByRef && !argIsValueType)
+				{
+					il.Emit(OpCodes.Ldelema, typeof(object));
+				}
+				else
+				{
+					il.Emit(OpCodes.Ldelem_Ref);
+					if (argIsValueType)
+					{
+						if (!argIsByRef || !directBoxValueAccess)
+						{
+							// if !directBoxValueAccess, create a new box if required
+							il.Emit(OpCodes.Unbox_Any, argType);
+							if (argIsByRef)
+							{
+								// box back
+								il.Emit(OpCodes.Box, argType);
+
+								// store new box value address to local 0
+								il.Emit(OpCodes.Dup);
+								il.Emit(OpCodes.Unbox, argType);
+								if (generateLocalBoxValuePtr)
+								{
+									generateLocalBoxValuePtr = false;
+									// Yes, you're seeing this right - a local of type void* to store the box value address!
+									il.DeclareLocal(typeof(void*), true);
+								}
+								il.Emit(OpCodes.Stloc_0);
+
+								// arr and index set up already
+								il.Emit(OpCodes.Stelem_Ref);
+
+								// load address back to stack
+								il.Emit(OpCodes.Ldloc_0);
+							}
+						}
+						else
+						{
+							// if directBoxValueAccess, emit unbox (get value address)
+							il.Emit(OpCodes.Unbox, argType);
+						}
+					}
+				}
+			}
+
+#pragma warning disable XS0001
+			if (methodInfo.IsStatic)
+				il.EmitCall(OpCodes.Call, methodInfo, null);
+			else
+				il.EmitCall(OpCodes.Callvirt, methodInfo, null);
+#pragma warning restore XS0001
+
+			if (methodInfo.ReturnType == typeof(void))
+				il.Emit(OpCodes.Ldnull);
+			else
+				EmitBoxIfNeeded(il, methodInfo.ReturnType);
+
+			il.Emit(OpCodes.Ret);
+
+			var invoder = (FastInvokeHandler)dynamicMethod.CreateDelegate(typeof(FastInvokeHandler));
+			return invoder;
+		}
+
+		static void EmitCastToReference(ILGenerator il, Type type)
+		{
+			if (type.IsValueType)
+				il.Emit(OpCodes.Unbox_Any, type);
+			else
+				il.Emit(OpCodes.Castclass, type);
+		}
+
+		static void EmitUnboxIfNeeded(ILGenerator il, Type type)
+		{
+			if (type.IsValueType)
+				il.Emit(OpCodes.Unbox_Any, type);
+		}
+
+		static void EmitBoxIfNeeded(ILGenerator il, Type type)
+		{
+			if (type.IsValueType)
+				il.Emit(OpCodes.Box, type);
+		}
+
+		static void EmitFastInt(ILGenerator il, int value)
+		{
+			switch (value)
+			{
+				case -1:
+					il.Emit(OpCodes.Ldc_I4_M1);
+					return;
+				case 0:
+					il.Emit(OpCodes.Ldc_I4_0);
+					return;
+				case 1:
+					il.Emit(OpCodes.Ldc_I4_1);
+					return;
+				case 2:
+					il.Emit(OpCodes.Ldc_I4_2);
+					return;
+				case 3:
+					il.Emit(OpCodes.Ldc_I4_3);
+					return;
+				case 4:
+					il.Emit(OpCodes.Ldc_I4_4);
+					return;
+				case 5:
+					il.Emit(OpCodes.Ldc_I4_5);
+					return;
+				case 6:
+					il.Emit(OpCodes.Ldc_I4_6);
+					return;
+				case 7:
+					il.Emit(OpCodes.Ldc_I4_7);
+					return;
+				case 8:
+					il.Emit(OpCodes.Ldc_I4_8);
+					return;
+			}
+
+			if (value > -129 && value < 128)
+				il.Emit(OpCodes.Ldc_I4_S, (sbyte)value);
+			else
+				il.Emit(OpCodes.Ldc_I4, value);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/GlobalSuppressions.cs b/src/Harmony/GlobalSuppressions.cs
new file mode 100644
index 00000000..c5356404
--- /dev/null
+++ b/src/Harmony/GlobalSuppressions.cs
@@ -0,0 +1,4 @@
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Scope = "member", Target = "Harmony.FileLog.#LogBytes(System.Int64,System.Int32)")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Scope = "member", Target = "Harmony.DynamicTools.#PrepareDynamicMethod(System.Reflection.Emit.DynamicMethod)")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2002:DoNotLockOnObjectsWithWeakIdentity", Scope = "member", Target = "Harmony.HarmonySharedState.#GetState()")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Scope = "member", Target = "Harmony.ILCopying.Memory.#GetMethodStart(System.Reflection.MethodBase)")]
diff --git a/src/Harmony/HarmonyInstance.cs b/src/Harmony/HarmonyInstance.cs
new file mode 100644
index 00000000..274feadb
--- /dev/null
+++ b/src/Harmony/HarmonyInstance.cs
@@ -0,0 +1,190 @@
+using Harmony.Tools;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public class Patches
+	{
+		public readonly ReadOnlyCollection<Patch> Prefixes;
+		public readonly ReadOnlyCollection<Patch> Postfixes;
+		public readonly ReadOnlyCollection<Patch> Transpilers;
+
+		public ReadOnlyCollection<string> Owners
+		{
+			get
+			{
+				var result = new HashSet<string>();
+				result.UnionWith(Prefixes.Select(p => p.owner));
+				result.UnionWith(Postfixes.Select(p => p.owner));
+				result.UnionWith(Transpilers.Select(p => p.owner));
+				return result.ToList().AsReadOnly();
+			}
+		}
+
+		public Patches(Patch[] prefixes, Patch[] postfixes, Patch[] transpilers)
+		{
+			if (prefixes == null) prefixes = new Patch[0];
+			if (postfixes == null) postfixes = new Patch[0];
+			if (transpilers == null) transpilers = new Patch[0];
+
+			Prefixes = prefixes.ToList().AsReadOnly();
+			Postfixes = postfixes.ToList().AsReadOnly();
+			Transpilers = transpilers.ToList().AsReadOnly();
+		}
+	}
+
+	public class HarmonyInstance
+	{
+		readonly string id;
+		public string Id => id;
+		public static bool DEBUG = false;
+
+		private static bool selfPatchingDone = false;
+
+		HarmonyInstance(string id)
+		{
+			if (DEBUG)
+			{
+				var assembly = typeof(HarmonyInstance).Assembly;
+				var version = assembly.GetName().Version;
+				var location = assembly.Location;
+				if (location == null || location == "") location = new Uri(assembly.CodeBase).LocalPath;
+				FileLog.Log("### Harmony id=" + id + ", version=" + version + ", location=" + location);
+				var callingMethod = GetOutsideCaller();
+				var callingAssembly = callingMethod.DeclaringType.Assembly;
+				location = callingAssembly.Location;
+				if (location == null || location == "") location = new Uri(callingAssembly.CodeBase).LocalPath;
+				FileLog.Log("### Started from " + callingMethod.FullDescription() + ", location " + location);
+				FileLog.Log("### At " + DateTime.Now.ToString("yyyy-MM-dd hh.mm.ss"));
+			}
+
+			this.id = id;
+
+			if (!selfPatchingDone)
+			{
+				selfPatchingDone = true;
+				SelfPatching.PatchOldHarmonyMethods();
+			}
+		}
+
+		public static HarmonyInstance Create(string id)
+		{
+			if (id == null) throw new Exception("id cannot be null");
+			return new HarmonyInstance(id);
+		}
+
+		private MethodBase GetOutsideCaller()
+		{
+			var trace = new StackTrace(true);
+			foreach (var frame in trace.GetFrames())
+			{
+				var method = frame.GetMethod();
+				if (method.DeclaringType.Namespace != typeof(HarmonyInstance).Namespace)
+					return method;
+			}
+			throw new Exception("Unexpected end of stack trace");
+		}
+
+		//
+
+		public void PatchAll()
+		{
+			var method = new StackTrace().GetFrame(1).GetMethod();
+			var assembly = method.ReflectedType.Assembly;
+			PatchAll(assembly);
+		}
+
+		public void PatchAll(Assembly assembly)
+		{
+			assembly.GetTypes().Do(type =>
+			{
+				var parentMethodInfos = type.GetHarmonyMethods();
+				if (parentMethodInfos != null && parentMethodInfos.Count() > 0)
+				{
+					var info = HarmonyMethod.Merge(parentMethodInfos);
+					var processor = new PatchProcessor(this, type, info);
+					processor.Patch();
+				}
+			});
+		}
+
+		public DynamicMethod Patch(MethodBase original, HarmonyMethod prefix = null, HarmonyMethod postfix = null, HarmonyMethod transpiler = null)
+		{
+			var processor = new PatchProcessor(this, new List<MethodBase> { original }, prefix, postfix, transpiler);
+			return processor.Patch().FirstOrDefault();
+		}
+
+		public void UnpatchAll(string harmonyID = null)
+		{
+			bool IDCheck(Patch patchInfo) => harmonyID == null || patchInfo.owner == harmonyID;
+
+			var originals = GetPatchedMethods().ToList();
+			foreach (var original in originals)
+			{
+				var info = GetPatchInfo(original);
+				info.Prefixes.DoIf(IDCheck, patchInfo => Unpatch(original, patchInfo.patch));
+				info.Postfixes.DoIf(IDCheck, patchInfo => Unpatch(original, patchInfo.patch));
+				info.Transpilers.DoIf(IDCheck, patchInfo => Unpatch(original, patchInfo.patch));
+			}
+		}
+
+		public void Unpatch(MethodBase original, HarmonyPatchType type, string harmonyID = null)
+		{
+			var processor = new PatchProcessor(this, new List<MethodBase> { original });
+			processor.Unpatch(type, harmonyID);
+		}
+
+		public void Unpatch(MethodBase original, MethodInfo patch)
+		{
+			var processor = new PatchProcessor(this, new List<MethodBase> { original });
+			processor.Unpatch(patch);
+		}
+
+		//
+
+		public bool HasAnyPatches(string harmonyID)
+		{
+			return GetPatchedMethods()
+				.Select(original => GetPatchInfo(original))
+				.Any(info => info.Owners.Contains(harmonyID));
+		}
+
+		public Patches GetPatchInfo(MethodBase method)
+		{
+			return PatchProcessor.GetPatchInfo(method);
+		}
+
+		public IEnumerable<MethodBase> GetPatchedMethods()
+		{
+			return HarmonySharedState.GetPatchedMethods();
+		}
+
+		public Dictionary<string, Version> VersionInfo(out Version currentVersion)
+		{
+			currentVersion = typeof(HarmonyInstance).Assembly.GetName().Version;
+			var assemblies = new Dictionary<string, Assembly>();
+			GetPatchedMethods().Do(method =>
+			{
+				var info = HarmonySharedState.GetPatchInfo(method);
+				info.prefixes.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
+				info.postfixes.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
+				info.transpilers.Do(fix => assemblies[fix.owner] = fix.patch.DeclaringType.Assembly);
+			});
+
+			var result = new Dictionary<string, Version>();
+			assemblies.Do(info =>
+			{
+				var assemblyName = info.Value.GetReferencedAssemblies().FirstOrDefault(a => a.FullName.StartsWith("0Harmony, Version"));
+				if (assemblyName != null)
+					result[info.Key] = assemblyName.Version;
+			});
+			return result;
+		}
+	}
+}
diff --git a/src/Harmony/HarmonyMethod.cs b/src/Harmony/HarmonyMethod.cs
new file mode 100644
index 00000000..74e6e256
--- /dev/null
+++ b/src/Harmony/HarmonyMethod.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public class HarmonyMethod
+	{
+		public MethodInfo method; // need to be called 'method'
+
+		public Type declaringType;
+		public string methodName;
+		public MethodType? methodType;
+		public Type[] argumentTypes;
+		public int prioritiy = -1;
+		public string[] before;
+		public string[] after;
+
+		public HarmonyMethod()
+		{
+		}
+
+		void ImportMethod(MethodInfo theMethod)
+		{
+			method = theMethod;
+			if (method != null)
+			{
+				var infos = method.GetHarmonyMethods();
+				if (infos != null)
+					Merge(infos).CopyTo(this);
+			}
+		}
+
+		public HarmonyMethod(MethodInfo method)
+		{
+			ImportMethod(method);
+		}
+
+		public HarmonyMethod(Type type, string name, Type[] parameters = null)
+		{
+			var method = AccessTools.Method(type, name, parameters);
+			ImportMethod(method);
+		}
+
+		public static List<string> HarmonyFields()
+		{
+			return AccessTools
+				.GetFieldNames(typeof(HarmonyMethod))
+				.Where(s => s != "method")
+				.ToList();
+		}
+
+		public static HarmonyMethod Merge(List<HarmonyMethod> attributes)
+		{
+			var result = new HarmonyMethod();
+			if (attributes == null) return result;
+			var resultTrv = Traverse.Create(result);
+			attributes.ForEach(attribute =>
+			{
+				var trv = Traverse.Create(attribute);
+				HarmonyFields().ForEach(f =>
+				{
+					var val = trv.Field(f).GetValue();
+					if (val != null)
+						resultTrv.Field(f).SetValue(val);
+				});
+			});
+			return result;
+		}
+
+		public override string ToString()
+		{
+			var result = "HarmonyMethod[";
+			var trv = Traverse.Create(this);
+			HarmonyFields().ForEach(f =>
+			{
+				result += f + '=' + trv.Field(f).GetValue();
+			});
+			return result + "]";
+		}
+	}
+
+	public static class HarmonyMethodExtensions
+	{
+		public static void CopyTo(this HarmonyMethod from, HarmonyMethod to)
+		{
+			if (to == null) return;
+			var fromTrv = Traverse.Create(from);
+			var toTrv = Traverse.Create(to);
+			HarmonyMethod.HarmonyFields().ForEach(f =>
+			{
+				var val = fromTrv.Field(f).GetValue();
+				if (val != null) toTrv.Field(f).SetValue(val);
+			});
+		}
+
+		public static HarmonyMethod Clone(this HarmonyMethod original)
+		{
+			var result = new HarmonyMethod();
+			original.CopyTo(result);
+			return result;
+		}
+
+		public static HarmonyMethod Merge(this HarmonyMethod master, HarmonyMethod detail)
+		{
+			if (detail == null) return master;
+			var result = new HarmonyMethod();
+			var resultTrv = Traverse.Create(result);
+			var masterTrv = Traverse.Create(master);
+			var detailTrv = Traverse.Create(detail);
+			HarmonyMethod.HarmonyFields().ForEach(f =>
+			{
+				var baseValue = masterTrv.Field(f).GetValue();
+				var detailValue = detailTrv.Field(f).GetValue();
+				resultTrv.Field(f).SetValue(detailValue ?? baseValue);
+			});
+			return result;
+		}
+
+		public static List<HarmonyMethod> GetHarmonyMethods(this Type type)
+		{
+			return type.GetCustomAttributes(true)
+						.Where(attr => attr is HarmonyAttribute)
+						.Cast<HarmonyAttribute>()
+						.Select(attr => attr.info)
+						.ToList();
+		}
+
+		public static List<HarmonyMethod> GetHarmonyMethods(this MethodBase method)
+		{
+			if (method is DynamicMethod) return new List<HarmonyMethod>();
+			return method.GetCustomAttributes(true)
+						.Where(attr => attr is HarmonyAttribute)
+						.Cast<HarmonyAttribute>()
+						.Select(attr => attr.info)
+						.ToList();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/HarmonySharedState.cs b/src/Harmony/HarmonySharedState.cs
new file mode 100644
index 00000000..2fdc08a0
--- /dev/null
+++ b/src/Harmony/HarmonySharedState.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public static class HarmonySharedState
+	{
+		static readonly string name = "HarmonySharedState";
+		internal static readonly int internalVersion = 100;
+		internal static int actualVersion = -1;
+
+		static Dictionary<MethodBase, byte[]> GetState()
+		{
+			lock (name)
+			{
+				var assembly = SharedStateAssembly();
+				if (assembly == null)
+				{
+					var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run);
+					var moduleBuilder = assemblyBuilder.DefineDynamicModule(name);
+					var typeAttributes = TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Abstract;
+					var typeBuilder = moduleBuilder.DefineType(name, typeAttributes);
+					typeBuilder.DefineField("state", typeof(Dictionary<MethodBase, byte[]>), FieldAttributes.Static | FieldAttributes.Public);
+					typeBuilder.DefineField("version", typeof(int), FieldAttributes.Static | FieldAttributes.Public).SetConstant(internalVersion);
+					typeBuilder.CreateType();
+
+					assembly = SharedStateAssembly();
+					if (assembly == null) throw new Exception("Cannot find or create harmony shared state");
+				}
+
+				var versionField = assembly.GetType(name).GetField("version");
+				if (versionField == null) throw new Exception("Cannot find harmony state version field");
+				actualVersion = (int)versionField.GetValue(null);
+
+				var stateField = assembly.GetType(name).GetField("state");
+				if (stateField == null) throw new Exception("Cannot find harmony state field");
+				if (stateField.GetValue(null) == null) stateField.SetValue(null, new Dictionary<MethodBase, byte[]>());
+				return (Dictionary<MethodBase, byte[]>)stateField.GetValue(null);
+			}
+		}
+
+		static Assembly SharedStateAssembly()
+		{
+			return AppDomain.CurrentDomain.GetAssemblies()
+				.FirstOrDefault(a => a.GetName().Name.Contains(name));
+		}
+
+		internal static PatchInfo GetPatchInfo(MethodBase method)
+		{
+			var bytes = GetState().GetValueSafe(method);
+			if (bytes == null) return null;
+			return PatchInfoSerialization.Deserialize(bytes);
+		}
+
+		internal static IEnumerable<MethodBase> GetPatchedMethods()
+		{
+			return GetState().Keys.AsEnumerable();
+		}
+
+		internal static void UpdatePatchInfo(MethodBase method, PatchInfo patchInfo)
+		{
+			GetState()[method] = patchInfo.Serialize();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/ILCopying/ByteBuffer.cs b/src/Harmony/ILCopying/ByteBuffer.cs
new file mode 100644
index 00000000..d1dcf69b
--- /dev/null
+++ b/src/Harmony/ILCopying/ByteBuffer.cs
@@ -0,0 +1,104 @@
+using System;
+
+namespace Harmony.ILCopying
+{
+	public class ByteBuffer
+	{
+		public byte[] buffer;
+		public int position;
+
+		public ByteBuffer(byte[] buffer)
+		{
+			this.buffer = buffer;
+		}
+
+		public byte ReadByte()
+		{
+			CheckCanRead(1);
+			return buffer[position++];
+		}
+
+		public byte[] ReadBytes(int length)
+		{
+			CheckCanRead(length);
+			var value = new byte[length];
+			Buffer.BlockCopy(buffer, position, value, 0, length);
+			position += length;
+			return value;
+		}
+
+		public short ReadInt16()
+		{
+			CheckCanRead(2);
+			var value = (short)(buffer[position]
+				| (buffer[position + 1] << 8));
+			position += 2;
+			return value;
+		}
+
+		public int ReadInt32()
+		{
+			CheckCanRead(4);
+			var value = buffer[position]
+				| (buffer[position + 1] << 8)
+				| (buffer[position + 2] << 16)
+				| (buffer[position + 3] << 24);
+			position += 4;
+			return value;
+		}
+
+		public long ReadInt64()
+		{
+			CheckCanRead(8);
+			var low = (uint)(buffer[position]
+				| (buffer[position + 1] << 8)
+				| (buffer[position + 2] << 16)
+				| (buffer[position + 3] << 24));
+
+			var high = (uint)(buffer[position + 4]
+				| (buffer[position + 5] << 8)
+				| (buffer[position + 6] << 16)
+				| (buffer[position + 7] << 24));
+
+			var value = (((long)high) << 32) | low;
+			position += 8;
+			return value;
+		}
+
+		public float ReadSingle()
+		{
+			if (!BitConverter.IsLittleEndian)
+			{
+				var bytes = ReadBytes(4);
+				Array.Reverse(bytes);
+				return BitConverter.ToSingle(bytes, 0);
+			}
+
+			CheckCanRead(4);
+			var value = BitConverter.ToSingle(buffer, position);
+			position += 4;
+			return value;
+		}
+
+		public double ReadDouble()
+		{
+			if (!BitConverter.IsLittleEndian)
+			{
+				var bytes = ReadBytes(8);
+				Array.Reverse(bytes);
+				return BitConverter.ToDouble(bytes, 0);
+			}
+
+			CheckCanRead(8);
+			var value = BitConverter.ToDouble(buffer, position);
+			position += 8;
+			return value;
+		}
+
+		void CheckCanRead(int count)
+		{
+			if (position + count > buffer.Length)
+				throw new ArgumentOutOfRangeException();
+		}
+	}
+}
diff --git a/src/Harmony/ILCopying/Emitter.cs b/src/Harmony/ILCopying/Emitter.cs
new file mode 100644
index 00000000..d57d8ede
--- /dev/null
+++ b/src/Harmony/ILCopying/Emitter.cs
@@ -0,0 +1,315 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.InteropServices;
+
+namespace Harmony.ILCopying
+{
+	public class LeaveTry
+	{
+		public override string ToString()
+		{
+			return "(autogenerated)";
+		}
+	}
+
+	public static class Emitter
+	{
+		static readonly GetterHandler codeLenGetter = FastAccess.CreateFieldGetter(typeof(ILGenerator), "code_len", "m_length");
+		static readonly GetterHandler localsGetter = FastAccess.CreateFieldGetter(typeof(ILGenerator), "locals");
+		static readonly GetterHandler localCountGetter = FastAccess.CreateFieldGetter(typeof(ILGenerator), "m_localCount");
+
+		public static string CodePos(ILGenerator il)
+		{
+			var offset = (int)codeLenGetter(il);
+			return string.Format("L_{0:x4}: ", offset);
+		}
+
+		public static void LogIL(ILGenerator il, OpCode opCode, object argument)
+		{
+			if (HarmonyInstance.DEBUG)
+			{
+				var argStr = FormatArgument(argument);
+				var space = argStr.Length > 0 ? " " : "";
+				FileLog.LogBuffered(string.Format("{0}{1}{2}{3}", CodePos(il), opCode, space, argStr));
+			}
+		}
+
+		public static void LogLocalVariable(ILGenerator il, LocalBuilder variable)
+		{
+			if (HarmonyInstance.DEBUG)
+			{
+				var localCount = -1;
+				var localsArray = localsGetter != null ? (LocalBuilder[])localsGetter(il) : null;
+				if (localsArray != null && localsArray.Length > 0)
+					localCount = localsArray.Length;
+				else
+					localCount = (int)localCountGetter(il);
+
+				var str = string.Format("{0}Local var {1}: {2}{3}", CodePos(il), localCount - 1, variable.LocalType.FullName, variable.IsPinned ? "(pinned)" : "");
+				FileLog.LogBuffered(str);
+			}
+		}
+
+		public static string FormatArgument(object argument)
+		{
+			if (argument == null) return "NULL";
+			var type = argument.GetType();
+
+			if (type == typeof(string))
+				return "\"" + argument + "\"";
+			if (type == typeof(Label))
+				return "Label" + ((Label)argument).GetHashCode();
+			if (type == typeof(Label[]))
+				return "Labels" + string.Join(",", ((Label[])argument).Select(l => l.GetHashCode().ToString()).ToArray());
+			if (type == typeof(LocalBuilder))
+				return ((LocalBuilder)argument).LocalIndex + " (" + ((LocalBuilder)argument).LocalType + ")";
+
+			return argument.ToString().Trim();
+		}
+
+		public static void MarkLabel(ILGenerator il, Label label)
+		{
+			if (HarmonyInstance.DEBUG) FileLog.LogBuffered(CodePos(il) + FormatArgument(label));
+			il.MarkLabel(label);
+		}
+
+		public static void MarkBlockBefore(ILGenerator il, ExceptionBlock block, out Label? label)
+		{
+			label = null;
+			switch (block.blockType)
+			{
+				case ExceptionBlockType.BeginExceptionBlock:
+					if (HarmonyInstance.DEBUG)
+					{
+						FileLog.LogBuffered(".try");
+						FileLog.LogBuffered("{");
+						FileLog.ChangeIndent(1);
+					}
+					label = il.BeginExceptionBlock();
+					return;
+
+				case ExceptionBlockType.BeginCatchBlock:
+					if (HarmonyInstance.DEBUG)
+					{
+						// fake log a LEAVE code since BeginCatchBlock() does add it
+						LogIL(il, OpCodes.Leave, new LeaveTry());
+
+						FileLog.ChangeIndent(-1);
+						FileLog.LogBuffered("} // end try");
+
+						FileLog.LogBuffered(".catch " + block.catchType);
+						FileLog.LogBuffered("{");
+						FileLog.ChangeIndent(1);
+					}
+					il.BeginCatchBlock(block.catchType);
+					return;
+
+				case ExceptionBlockType.BeginExceptFilterBlock:
+					if (HarmonyInstance.DEBUG)
+					{
+						// fake log a LEAVE code since BeginCatchBlock() does add it
+						LogIL(il, OpCodes.Leave, new LeaveTry());
+
+						FileLog.ChangeIndent(-1);
+						FileLog.LogBuffered("} // end try");
+
+						FileLog.LogBuffered(".filter");
+						FileLog.LogBuffered("{");
+						FileLog.ChangeIndent(1);
+					}
+					il.BeginExceptFilterBlock();
+					return;
+
+				case ExceptionBlockType.BeginFaultBlock:
+					if (HarmonyInstance.DEBUG)
+					{
+						// fake log a LEAVE code since BeginCatchBlock() does add it
+						LogIL(il, OpCodes.Leave, new LeaveTry());
+
+						FileLog.ChangeIndent(-1);
+						FileLog.LogBuffered("} // end try");
+
+						FileLog.LogBuffered(".fault");
+						FileLog.LogBuffered("{");
+						FileLog.ChangeIndent(1);
+					}
+					il.BeginFaultBlock();
+					return;
+
+				case ExceptionBlockType.BeginFinallyBlock:
+					if (HarmonyInstance.DEBUG)
+					{
+						// fake log a LEAVE code since BeginCatchBlock() does add it
+						LogIL(il, OpCodes.Leave, new LeaveTry());
+
+						FileLog.ChangeIndent(-1);
+						FileLog.LogBuffered("} // end try");
+
+						FileLog.LogBuffered(".finally");
+						FileLog.LogBuffered("{");
+						FileLog.ChangeIndent(1);
+					}
+					il.BeginFinallyBlock();
+					return;
+			}
+		}
+
+		public static void MarkBlockAfter(ILGenerator il, ExceptionBlock block)
+		{
+			if (block.blockType == ExceptionBlockType.EndExceptionBlock)
+			{
+				if (HarmonyInstance.DEBUG)
+				{
+					// fake log a LEAVE code since BeginCatchBlock() does add it
+					LogIL(il, OpCodes.Leave, new LeaveTry());
+
+					FileLog.ChangeIndent(-1);
+					FileLog.LogBuffered("} // end handler");
+				}
+				il.EndExceptionBlock();
+			}
+		}
+
+		// MethodCopier calls when Operand type is InlineNone
+		public static void Emit(ILGenerator il, OpCode opcode)
+		{
+			if (HarmonyInstance.DEBUG) FileLog.LogBuffered(CodePos(il) + opcode);
+			il.Emit(opcode);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, LocalBuilder local)
+		{
+			LogIL(il, opcode, local);
+			il.Emit(opcode, local);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, FieldInfo field)
+		{
+			LogIL(il, opcode, field);
+			il.Emit(opcode, field);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, Label[] labels)
+		{
+			LogIL(il, opcode, labels);
+			il.Emit(opcode, labels);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, Label label)
+		{
+			LogIL(il, opcode, label);
+			il.Emit(opcode, label);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, string str)
+		{
+			LogIL(il, opcode, str);
+			il.Emit(opcode, str);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, float arg)
+		{
+			LogIL(il, opcode, arg);
+			il.Emit(opcode, arg);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, byte arg)
+		{
+			LogIL(il, opcode, arg);
+			il.Emit(opcode, arg);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, sbyte arg)
+		{
+			LogIL(il, opcode, arg);
+			il.Emit(opcode, arg);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, double arg)
+		{
+			LogIL(il, opcode, arg);
+			il.Emit(opcode, arg);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, int arg)
+		{
+			LogIL(il, opcode, arg);
+			il.Emit(opcode, arg);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, MethodInfo meth)
+		{
+			LogIL(il, opcode, meth);
+			il.Emit(opcode, meth);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, short arg)
+		{
+			LogIL(il, opcode, arg);
+			il.Emit(opcode, arg);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, SignatureHelper signature)
+		{
+			LogIL(il, opcode, signature);
+			il.Emit(opcode, signature);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, ConstructorInfo con)
+		{
+			LogIL(il, opcode, con);
+			il.Emit(opcode, con);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, Type cls)
+		{
+			LogIL(il, opcode, cls);
+			il.Emit(opcode, cls);
+		}
+
+		// MethodCopier calls by 3rd argument type
+		public static void Emit(ILGenerator il, OpCode opcode, long arg)
+		{
+			LogIL(il, opcode, arg);
+			il.Emit(opcode, arg);
+		}
+
+		// called from MethodInvoker (calls from MethodCopier use the corresponding Emit() call above)
+		public static void EmitCall(ILGenerator il, OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
+		{
+			if (HarmonyInstance.DEBUG) FileLog.LogBuffered(string.Format("{0}Call {1} {2} {3}", CodePos(il), opcode, methodInfo, optionalParameterTypes));
+			il.EmitCall(opcode, methodInfo, optionalParameterTypes);
+		}
+
+		// not called yet
+		public static void EmitCalli(ILGenerator il, OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes)
+		{
+			if (HarmonyInstance.DEBUG) FileLog.LogBuffered(string.Format("{0}Calli {1} {2} {3} {4}", CodePos(il), opcode, unmanagedCallConv, returnType, parameterTypes));
+			il.EmitCalli(opcode, unmanagedCallConv, returnType, parameterTypes);
+		}
+
+		// not called yet
+		public static void EmitCalli(ILGenerator il, OpCode opcode, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
+		{
+			if (HarmonyInstance.DEBUG) FileLog.LogBuffered(string.Format("{0}Calli {1} {2} {3} {4} {5}", CodePos(il), opcode, callingConvention, returnType, parameterTypes, optionalParameterTypes));
+			il.EmitCalli(opcode, callingConvention, returnType, parameterTypes, optionalParameterTypes);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/ILCopying/ILInstruction.cs b/src/Harmony/ILCopying/ILInstruction.cs
new file mode 100644
index 00000000..3c8c8b90
--- /dev/null
+++ b/src/Harmony/ILCopying/ILInstruction.cs
@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection.Emit;
+
+namespace Harmony.ILCopying
+{
+	public enum ExceptionBlockType
+	{
+		BeginExceptionBlock,
+		BeginCatchBlock,
+		BeginExceptFilterBlock,
+		BeginFaultBlock,
+		BeginFinallyBlock,
+		EndExceptionBlock
+	}
+
+	public class ExceptionBlock
+	{
+		public ExceptionBlockType blockType;
+		public Type catchType;
+
+		public ExceptionBlock(ExceptionBlockType blockType, Type catchType)
+		{
+			this.blockType = blockType;
+			this.catchType = catchType;
+		}
+	}
+
+	public class ILInstruction
+	{
+		public int offset;
+		public OpCode opcode;
+		public object operand;
+		public object argument;
+
+		public List<Label> labels = new List<Label>();
+		public List<ExceptionBlock> blocks = new List<ExceptionBlock>();
+
+		public ILInstruction(OpCode opcode, object operand = null)
+		{
+			this.opcode = opcode;
+			this.operand = operand;
+			argument = operand;
+		}
+
+		public CodeInstruction GetCodeInstruction()
+		{
+			var instr = new CodeInstruction(opcode, argument);
+			if (opcode.OperandType == OperandType.InlineNone)
+				instr.operand = null;
+			instr.labels = labels;
+			instr.blocks = blocks;
+			return instr;
+		}
+
+		public int GetSize()
+		{
+			var size = opcode.Size;
+
+			switch (opcode.OperandType)
+			{
+				case OperandType.InlineSwitch:
+					size += (1 + ((Array)operand).Length) * 4;
+					break;
+
+				case OperandType.InlineI8:
+				case OperandType.InlineR:
+					size += 8;
+					break;
+
+				case OperandType.InlineBrTarget:
+				case OperandType.InlineField:
+				case OperandType.InlineI:
+				case OperandType.InlineMethod:
+				case OperandType.InlineSig:
+				case OperandType.InlineString:
+				case OperandType.InlineTok:
+				case OperandType.InlineType:
+				case OperandType.ShortInlineR:
+					size += 4;
+					break;
+
+				case OperandType.InlineVar:
+					size += 2;
+					break;
+
+				case OperandType.ShortInlineBrTarget:
+				case OperandType.ShortInlineI:
+				case OperandType.ShortInlineVar:
+					size += 1;
+					break;
+			}
+
+			return size;
+		}
+
+		public override string ToString()
+		{
+			var instruction = "";
+
+			AppendLabel(ref instruction, this);
+			instruction = instruction + ": " + opcode.Name;
+
+			if (operand == null)
+				return instruction;
+
+			instruction = instruction + " ";
+
+			switch (opcode.OperandType)
+			{
+				case OperandType.ShortInlineBrTarget:
+				case OperandType.InlineBrTarget:
+					AppendLabel(ref instruction, operand);
+					break;
+
+				case OperandType.InlineSwitch:
+					var switchLabels = (ILInstruction[])operand;
+					for (var i = 0; i < switchLabels.Length; i++)
+					{
+						if (i > 0)
+							instruction = instruction + ",";
+
+						AppendLabel(ref instruction, switchLabels[i]);
+					}
+					break;
+
+				case OperandType.InlineString:
+					instruction = instruction + "\"" + operand + "\"";
+					break;
+
+				default:
+					instruction = instruction + operand;
+					break;
+			}
+
+			return instruction;
+		}
+
+		static void AppendLabel(ref string str, object argument)
+		{
+			var instruction = argument as ILInstruction;
+			if (instruction != null)
+				str = str + "IL_" + instruction.offset.ToString("X4");
+			else
+				str = str + "IL_" + argument;
+		}
+	}
+}
diff --git a/src/Harmony/ILCopying/Memory.cs b/src/Harmony/ILCopying/Memory.cs
new file mode 100644
index 00000000..f7e86f06
--- /dev/null
+++ b/src/Harmony/ILCopying/Memory.cs
@@ -0,0 +1,204 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Harmony.ILCopying
+{
+	[Flags]
+	public enum Protection
+	{
+		PAGE_NOACCESS = 0x01,
+		PAGE_READONLY = 0x02,
+		PAGE_READWRITE = 0x04,
+		PAGE_WRITECOPY = 0x08,
+		PAGE_EXECUTE = 0x10,
+		PAGE_EXECUTE_READ = 0x20,
+		PAGE_EXECUTE_READWRITE = 0x40,
+		PAGE_EXECUTE_WRITECOPY = 0x80,
+		PAGE_GUARD = 0x100,
+		PAGE_NOCACHE = 0x200,
+		PAGE_WRITECOMBINE = 0x400
+	}
+
+	public static class Memory
+	{
+		private static readonly HashSet<PlatformID> WindowsPlatformIDSet = new HashSet<PlatformID>
+		{
+			PlatformID.Win32NT, PlatformID.Win32S, PlatformID.Win32Windows, PlatformID.WinCE
+		};
+
+		public static bool IsWindows => WindowsPlatformIDSet.Contains(Environment.OSVersion.Platform);
+
+		// Safe to use windows reference since this will only ever be called on windows
+		//
+		[DllImport("kernel32.dll")]
+		public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, Protection flNewProtect, out Protection lpflOldProtect);
+
+		public static void UnprotectMemoryPage(long memory)
+		{
+			if (IsWindows)
+			{
+				var success = VirtualProtect(new IntPtr(memory), new UIntPtr(1), Protection.PAGE_EXECUTE_READWRITE, out var _ignored);
+				if (success == false)
+					throw new System.ComponentModel.Win32Exception();
+			}
+		}
+
+		public static string DetourMethod(MethodBase original, MethodBase replacement)
+		{
+			var originalCodeStart = GetMethodStart(original, out var exception);
+			if (originalCodeStart == 0)
+				return exception.Message;
+			var patchCodeStart = GetMethodStart(replacement, out exception);
+			if (patchCodeStart == 0)
+				return exception.Message;
+
+			return WriteJump(originalCodeStart, patchCodeStart);
+		}
+
+		/*
+		 * This is still a rough part in Harmony. So much information and no easy way
+		 * to determine when and what is valid. Especially with different environments
+		 * and .NET versions. More information might be found here:
+		 * 
+		 * https://stackoverflow.com/questions/38782934/how-to-replace-the-pointer-to-the-overridden-virtual-method-in-the-pointer-of/
+		 * https://stackoverflow.com/questions/39034018/how-to-replace-a-pointer-to-a-pointer-to-a-method-in-a-class-of-my-method-inheri
+		 *
+		 */
+		public static string WriteJump(long memory, long destination)
+		{
+			UnprotectMemoryPage(memory);
+
+			if (IntPtr.Size == sizeof(long))
+			{
+				if (CompareBytes(memory, new byte[] { 0xe9 }))
+				{
+					var offset = ReadInt(memory + 1);
+					memory += 5 + offset;
+				}
+
+				memory = WriteBytes(memory, new byte[] { 0x48, 0xB8 });
+				memory = WriteLong(memory, destination);
+				memory = WriteBytes(memory, new byte[] { 0xFF, 0xE0 });
+			}
+			else
+			{
+				memory = WriteByte(memory, 0x68);
+				memory = WriteInt(memory, (int)destination);
+				memory = WriteByte(memory, 0xc3);
+			}
+			return null;
+		}
+
+		private static RuntimeMethodHandle GetRuntimeMethodHandle(MethodBase method)
+		{
+			if (method is DynamicMethod)
+			{
+				var nonPublicInstance = BindingFlags.NonPublic | BindingFlags.Instance;
+
+				// DynamicMethod actually generates its m_methodHandle on-the-fly and therefore
+				// we should call GetMethodDescriptor to force it to be created
+				//
+				var m_GetMethodDescriptor = typeof(DynamicMethod).GetMethod("GetMethodDescriptor", nonPublicInstance);
+				if (m_GetMethodDescriptor != null)
+					return (RuntimeMethodHandle)m_GetMethodDescriptor.Invoke(method, new object[0]);
+
+				// .Net Core
+				var f_m_method = typeof(DynamicMethod).GetField("m_method", nonPublicInstance);
+				if (f_m_method != null)
+					return (RuntimeMethodHandle)f_m_method.GetValue(method);
+
+				// Mono
+				var f_mhandle = typeof(DynamicMethod).GetField("mhandle", nonPublicInstance);
+				return (RuntimeMethodHandle)f_mhandle.GetValue(method);
+			}
+
+			return method.MethodHandle;
+		}
+
+		public static long GetMethodStart(MethodBase method, out Exception exception)
+		{
+			// required in .NET Core so that the method is JITed and the method start does not change
+			//
+			var handle = GetRuntimeMethodHandle(method);
+			try
+			{
+				RuntimeHelpers.PrepareMethod(handle);
+			}
+			catch (Exception)
+			{
+			}
+
+			try
+			{
+				exception = null;
+				return handle.GetFunctionPointer().ToInt64();
+			}
+			catch (Exception ex)
+			{
+				exception = ex;
+				return 0;
+			}
+		}
+
+		public static unsafe bool CompareBytes(long memory, byte[] values)
+		{
+			var p = (byte*)memory;
+			foreach (var value in values)
+			{
+				if (value != *p) return false;
+				p++;
+			}
+			return true;
+		}
+
+		public static unsafe byte ReadByte(long memory)
+		{
+			var p = (byte*)memory;
+			return *p;
+		}
+
+		public static unsafe int ReadInt(long memory)
+		{
+			var p = (int*)memory;
+			return *p;
+		}
+
+		public static unsafe long ReadLong(long memory)
+		{
+			var p = (long*)memory;
+			return *p;
+		}
+
+		public static unsafe long WriteByte(long memory, byte value)
+		{
+			var p = (byte*)memory;
+			*p = value;
+			return memory + sizeof(byte);
+		}
+
+		public static unsafe long WriteBytes(long memory, byte[] values)
+		{
+			foreach (var value in values)
+				memory = WriteByte(memory, value);
+			return memory;
+		}
+
+		public static unsafe long WriteInt(long memory, int value)
+		{
+			var p = (int*)memory;
+			*p = value;
+			return memory + sizeof(int);
+		}
+
+		public static unsafe long WriteLong(long memory, long value)
+		{
+			var p = (long*)memory;
+			*p = value;
+			return memory + sizeof(long);
+		}
+	}
+}
diff --git a/src/Harmony/ILCopying/MethodCopier.cs b/src/Harmony/ILCopying/MethodCopier.cs
new file mode 100644
index 00000000..8344ca98
--- /dev/null
+++ b/src/Harmony/ILCopying/MethodCopier.cs
@@ -0,0 +1,730 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+
+namespace Harmony.ILCopying
+{
+	public class MethodCopier
+	{
+		readonly MethodBodyReader reader;
+		readonly List<MethodInfo> transpilers = new List<MethodInfo>();
+
+		public MethodCopier(MethodBase fromMethod, ILGenerator toILGenerator, LocalBuilder[] existingVariables = null)
+		{
+			if (fromMethod == null) throw new ArgumentNullException("Method cannot be null");
+			reader = new MethodBodyReader(fromMethod, toILGenerator);
+			reader.DeclareVariables(existingVariables);
+			reader.ReadInstructions();
+		}
+
+		public void AddTranspiler(MethodInfo transpiler)
+		{
+			transpilers.Add(transpiler);
+		}
+
+		public void Finalize(List<Label> endLabels, List<ExceptionBlock> endBlocks)
+		{
+			reader.FinalizeILCodes(transpilers, endLabels, endBlocks);
+		}
+	}
+
+	public class MethodBodyReader
+	{
+		readonly ILGenerator generator;
+
+		readonly MethodBase method;
+		readonly Module module;
+		readonly Type[] typeArguments;
+		readonly Type[] methodArguments;
+		readonly ByteBuffer ilBytes;
+		readonly ParameterInfo this_parameter;
+		readonly ParameterInfo[] parameters;
+		readonly IList<LocalVariableInfo> locals;
+		readonly IList<ExceptionHandlingClause> exceptions;
+		List<ILInstruction> ilInstructions;
+
+		LocalBuilder[] variables;
+
+		// NOTE: you cannot simply "copy" ILInstructions from a method. They contain references to
+		// local variables which must be CREATED on an ILGenerator or else they are invalid when you
+		// want to use the ILInstruction. If you are really clever, you can supply a dummy generator
+		// and edit out all labels during the processing but that might be more trickier than you think
+		//
+		// In order to copy together a bunch of method parts within a transpiler, you have to pass in
+		// your current generator that builds your new method
+		//
+		// You will end up with the sum of all declared local variables of all methods you run
+		// GetInstructions on or use a dummy generator but edit out the invalid labels from the codes
+		// you copy
+		//
+		public static List<ILInstruction> GetInstructions(ILGenerator generator, MethodBase method)
+		{
+			if (method == null) throw new ArgumentNullException("Method cannot be null");
+			var reader = new MethodBodyReader(method, generator);
+			reader.DeclareVariables(null);
+			reader.ReadInstructions();
+			return reader.ilInstructions;
+		}
+
+		// constructor
+		//
+		public MethodBodyReader(MethodBase method, ILGenerator generator)
+		{
+			this.generator = generator;
+			this.method = method;
+			module = method.Module;
+
+			var body = method.GetMethodBody();
+			if (body == null)
+				throw new ArgumentException("Method " + method.FullDescription() + " has no body");
+
+			var bytes = body.GetILAsByteArray();
+			if (bytes == null)
+				throw new ArgumentException("Can not get IL bytes of method " + method.FullDescription());
+			ilBytes = new ByteBuffer(bytes);
+			ilInstructions = new List<ILInstruction>((bytes.Length + 1) / 2);
+
+			var type = method.DeclaringType;
+
+			if (type.IsGenericType)
+			{
+				try { typeArguments = type.GetGenericArguments(); }
+				catch { typeArguments = null; }
+			}
+
+			if (method.IsGenericMethod)
+			{
+				try { methodArguments = method.GetGenericArguments(); }
+				catch { methodArguments = null; }
+			}
+
+			if (!method.IsStatic)
+				this_parameter = new ThisParameter(method);
+			parameters = method.GetParameters();
+
+			locals = body.LocalVariables;
+			exceptions = body.ExceptionHandlingClauses;
+		}
+
+		// read and parse IL codes
+		//
+		public void ReadInstructions()
+		{
+			while (ilBytes.position < ilBytes.buffer.Length)
+			{
+				var loc = ilBytes.position; // get location first (ReadOpCode will advance it)
+				var instruction = new ILInstruction(ReadOpCode()) { offset = loc };
+				ReadOperand(instruction);
+				ilInstructions.Add(instruction);
+			}
+
+			ResolveBranches();
+			ParseExceptions();
+		}
+
+		// declare local variables
+		//
+		public void DeclareVariables(LocalBuilder[] existingVariables)
+		{
+			if (generator == null) return;
+			if (existingVariables != null)
+				variables = existingVariables;
+			else
+				variables = locals.Select(
+					lvi => generator.DeclareLocal(lvi.LocalType, lvi.IsPinned)
+				).ToArray();
+		}
+
+		// process all jumps
+		//
+		void ResolveBranches()
+		{
+			foreach (var ilInstruction in ilInstructions)
+			{
+				switch (ilInstruction.opcode.OperandType)
+				{
+					case OperandType.ShortInlineBrTarget:
+					case OperandType.InlineBrTarget:
+						ilInstruction.operand = GetInstruction((int)ilInstruction.operand, false);
+						break;
+
+					case OperandType.InlineSwitch:
+						var offsets = (int[])ilInstruction.operand;
+						var branches = new ILInstruction[offsets.Length];
+						for (var j = 0; j < offsets.Length; j++)
+							branches[j] = GetInstruction(offsets[j], false);
+
+						ilInstruction.operand = branches;
+						break;
+				}
+			}
+		}
+
+		// process all exception blocks
+		//
+		void ParseExceptions()
+		{
+			foreach (var exception in exceptions)
+			{
+				var try_start = exception.TryOffset;
+				var try_end = exception.TryOffset + exception.TryLength - 1;
+
+				var handler_start = exception.HandlerOffset;
+				var handler_end = exception.HandlerOffset + exception.HandlerLength - 1;
+
+				var instr1 = GetInstruction(try_start, false);
+				instr1.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock, null));
+
+				var instr2 = GetInstruction(handler_end, true);
+				instr2.blocks.Add(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock, null));
+
+				// The FilterOffset property is meaningful only for Filter clauses. 
+				// The CatchType property is not meaningful for Filter or Finally clauses. 
+				//
+				switch (exception.Flags)
+				{
+					case ExceptionHandlingClauseOptions.Filter:
+						var instr3 = GetInstruction(exception.FilterOffset, false);
+						instr3.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginExceptFilterBlock, null));
+						break;
+
+					case ExceptionHandlingClauseOptions.Finally:
+						var instr4 = GetInstruction(handler_start, false);
+						instr4.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFinallyBlock, null));
+						break;
+
+					case ExceptionHandlingClauseOptions.Clause:
+						var instr5 = GetInstruction(handler_start, false);
+						instr5.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock, exception.CatchType));
+						break;
+
+					case ExceptionHandlingClauseOptions.Fault:
+						var instr6 = GetInstruction(handler_start, false);
+						instr6.blocks.Add(new ExceptionBlock(ExceptionBlockType.BeginFaultBlock, null));
+						break;
+				}
+			}
+		}
+
+		// used in FinalizeILCodes to convert short jumps to long ones
+		static Dictionary<OpCode, OpCode> shortJumps = new Dictionary<OpCode, OpCode>()
+		{
+			{ OpCodes.Leave_S, OpCodes.Leave },
+			{ OpCodes.Brfalse_S, OpCodes.Brfalse },
+			{ OpCodes.Brtrue_S, OpCodes.Brtrue },
+			{ OpCodes.Beq_S, OpCodes.Beq },
+			{ OpCodes.Bge_S, OpCodes.Bge },
+			{ OpCodes.Bgt_S, OpCodes.Bgt },
+			{ OpCodes.Ble_S, OpCodes.Ble },
+			{ OpCodes.Blt_S, OpCodes.Blt },
+			{ OpCodes.Bne_Un_S, OpCodes.Bne_Un },
+			{ OpCodes.Bge_Un_S, OpCodes.Bge_Un },
+			{ OpCodes.Bgt_Un_S, OpCodes.Bgt_Un },
+			{ OpCodes.Ble_Un_S, OpCodes.Ble_Un },
+			{ OpCodes.Br_S, OpCodes.Br },
+			{ OpCodes.Blt_Un_S, OpCodes.Blt_Un }
+		};
+
+		// use parsed IL codes and emit them to a generator
+		//
+		public void FinalizeILCodes(List<MethodInfo> transpilers, List<Label> endLabels, List<ExceptionBlock> endBlocks)
+		{
+			if (generator == null) return;
+
+			// pass1 - define labels and add them to instructions that are target of a jump
+			//
+			foreach (var ilInstruction in ilInstructions)
+			{
+				switch (ilInstruction.opcode.OperandType)
+				{
+					case OperandType.InlineSwitch:
+						{
+							var targets = ilInstruction.operand as ILInstruction[];
+							if (targets != null)
+							{
+								var labels = new List<Label>();
+								foreach (var target in targets)
+								{
+									var label = generator.DefineLabel();
+									target.labels.Add(label);
+									labels.Add(label);
+								}
+								ilInstruction.argument = labels.ToArray();
+							}
+							break;
+						}
+
+					case OperandType.ShortInlineBrTarget:
+					case OperandType.InlineBrTarget:
+						{
+							var target = ilInstruction.operand as ILInstruction;
+							if (target != null)
+							{
+								var label = generator.DefineLabel();
+								target.labels.Add(label);
+								ilInstruction.argument = label;
+							}
+							break;
+						}
+				}
+			}
+
+			// pass2 - filter through all processors
+			//
+			var codeTranspiler = new CodeTranspiler(ilInstructions);
+			transpilers.Do(transpiler => codeTranspiler.Add(transpiler));
+			var codeInstructions = codeTranspiler.GetResult(generator, method);
+
+			// pass3 - remove RET if it appears at the end
+			while (true)
+			{
+				var lastInstruction = codeInstructions.LastOrDefault();
+				if (lastInstruction == null || lastInstruction.opcode != OpCodes.Ret) break;
+
+				// remember any existing labels
+				endLabels.AddRange(lastInstruction.labels);
+
+				codeInstructions.RemoveAt(codeInstructions.Count - 1);
+			}
+
+			// pass4 - mark labels and exceptions and emit codes
+			//
+			var idx = 0;
+			codeInstructions.Do(codeInstruction =>
+			{
+				// mark all labels
+				codeInstruction.labels.Do(label => Emitter.MarkLabel(generator, label));
+
+				// start all exception blocks
+				// TODO: we ignore the resulting label because we have no way to use it
+				//
+				codeInstruction.blocks.Do(block => { Label? label; Emitter.MarkBlockBefore(generator, block, out label); });
+
+				var code = codeInstruction.opcode;
+				var operand = codeInstruction.operand;
+
+				// replace RET with a jump to the end (outside this code)
+				if (code == OpCodes.Ret)
+				{
+					var endLabel = generator.DefineLabel();
+					code = OpCodes.Br;
+					operand = endLabel;
+					endLabels.Add(endLabel);
+				}
+
+				// replace short jumps with long ones (can be optimized but requires byte counting, not instruction counting)
+				if (shortJumps.TryGetValue(code, out var longJump))
+					code = longJump;
+
+				var emitCode = true;
+
+				//if (code == OpCodes.Leave || code == OpCodes.Leave_S)
+				//{
+				//	// skip LEAVE on EndExceptionBlock
+				//	if (codeInstruction.blocks.Any(block => block.blockType == ExceptionBlockType.EndExceptionBlock))
+				//		emitCode = false;
+
+				//	// skip LEAVE on next instruction starts a new exception handler and we are already in 
+				//	if (idx < instructions.Length - 1)
+				//		if (instructions[idx + 1].blocks.Any(block => block.blockType != ExceptionBlockType.EndExceptionBlock))
+				//			emitCode = false;
+				//}
+
+				if (emitCode)
+				{
+					switch (code.OperandType)
+					{
+						case OperandType.InlineNone:
+							Emitter.Emit(generator, code);
+							break;
+
+						case OperandType.InlineSig:
+
+							// TODO the following will fail because we do not convert the token (operand)
+							// All the decompilers can show the arguments correctly, we just need to find out how
+							//
+							if (operand == null) throw new Exception("Wrong null argument: " + codeInstruction);
+							if ((operand is int) == false) throw new Exception("Wrong Emit argument type " + operand.GetType() + " in " + codeInstruction);
+							Emitter.Emit(generator, code, (int)operand);
+
+							/*
+							// the following will only work if we can convert the original signature token to the required arguments
+							//
+							var callingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall;
+							var returnType = typeof(object);
+							var parameterTypes = new[] { typeof(object) };
+							Emitter.EmitCalli(generator, code, callingConvention, returnType, parameterTypes);
+
+							var callingConventions = System.Reflection.CallingConventions.Standard;
+							var optionalParameterTypes = new[] { typeof(object) };
+							Emitter.EmitCalli(generator, code, callingConventions, returnType, parameterTypes, optionalParameterTypes);
+							*/
+							break;
+
+						default:
+							if (operand == null) throw new Exception("Wrong null argument: " + codeInstruction);
+							var emitMethod = EmitMethodForType(operand.GetType());
+							if (emitMethod == null) throw new Exception("Unknown Emit argument type " + operand.GetType() + " in " + codeInstruction);
+							if (HarmonyInstance.DEBUG) FileLog.LogBuffered(Emitter.CodePos(generator) + code + " " + Emitter.FormatArgument(operand));
+							emitMethod.Invoke(generator, new object[] { code, operand });
+							break;
+					}
+				}
+
+				codeInstruction.blocks.Do(block => Emitter.MarkBlockAfter(generator, block));
+
+				idx++;
+			});
+		}
+
+		// interpret member info value
+		//
+		static void GetMemberInfoValue(MemberInfo info, out object result)
+		{
+			result = null;
+			switch (info.MemberType)
+			{
+				case MemberTypes.Constructor:
+					result = (ConstructorInfo)info;
+					break;
+
+				case MemberTypes.Event:
+					result = (EventInfo)info;
+					break;
+
+				case MemberTypes.Field:
+					result = (FieldInfo)info;
+					break;
+
+				case MemberTypes.Method:
+					result = (MethodInfo)info;
+					break;
+
+				case MemberTypes.TypeInfo:
+				case MemberTypes.NestedType:
+					result = (Type)info;
+					break;
+
+				case MemberTypes.Property:
+					result = (PropertyInfo)info;
+					break;
+			}
+		}
+
+		// interpret instruction operand
+		//
+		void ReadOperand(ILInstruction instruction)
+		{
+			switch (instruction.opcode.OperandType)
+			{
+				case OperandType.InlineNone:
+					{
+						instruction.argument = null;
+						break;
+					}
+
+				case OperandType.InlineSwitch:
+					{
+						var length = ilBytes.ReadInt32();
+						var base_offset = ilBytes.position + (4 * length);
+						var branches = new int[length];
+						for (var i = 0; i < length; i++)
+							branches[i] = ilBytes.ReadInt32() + base_offset;
+						instruction.operand = branches;
+						break;
+					}
+
+				case OperandType.ShortInlineBrTarget:
+					{
+						var val = (sbyte)ilBytes.ReadByte();
+						instruction.operand = val + ilBytes.position;
+						break;
+					}
+
+				case OperandType.InlineBrTarget:
+					{
+						var val = ilBytes.ReadInt32();
+						instruction.operand = val + ilBytes.position;
+						break;
+					}
+
+				case OperandType.ShortInlineI:
+					{
+						if (instruction.opcode == OpCodes.Ldc_I4_S)
+						{
+							var sb = (sbyte)ilBytes.ReadByte();
+							instruction.operand = sb;
+							instruction.argument = (sbyte)instruction.operand;
+						}
+						else
+						{
+							var b = ilBytes.ReadByte();
+							instruction.operand = b;
+							instruction.argument = (byte)instruction.operand;
+						}
+						break;
+					}
+
+				case OperandType.InlineI:
+					{
+						var val = ilBytes.ReadInt32();
+						instruction.operand = val;
+						instruction.argument = (int)instruction.operand;
+						break;
+					}
+
+				case OperandType.ShortInlineR:
+					{
+						var val = ilBytes.ReadSingle();
+						instruction.operand = val;
+						instruction.argument = (float)instruction.operand;
+						break;
+					}
+
+				case OperandType.InlineR:
+					{
+						var val = ilBytes.ReadDouble();
+						instruction.operand = val;
+						instruction.argument = (double)instruction.operand;
+						break;
+					}
+
+				case OperandType.InlineI8:
+					{
+						var val = ilBytes.ReadInt64();
+						instruction.operand = val;
+						instruction.argument = (long)instruction.operand;
+						break;
+					}
+
+				case OperandType.InlineSig:
+					{
+						var val = ilBytes.ReadInt32();
+						var bytes = module.ResolveSignature(val);
+						instruction.operand = bytes;
+						instruction.argument = bytes;
+						Debugger.Log(0, "TEST", "METHOD " + method.FullDescription() + "\n");
+						Debugger.Log(0, "TEST", "Signature = " + bytes.Select(b => string.Format("0x{0:x02}", b)).Aggregate((a, b) => a + " " + b) + "\n");
+						Debugger.Break();
+						break;
+					}
+
+				case OperandType.InlineString:
+					{
+						var val = ilBytes.ReadInt32();
+						instruction.operand = module.ResolveString(val);
+						instruction.argument = (string)instruction.operand;
+						break;
+					}
+
+				case OperandType.InlineTok:
+					{
+						var val = ilBytes.ReadInt32();
+						instruction.operand = module.ResolveMember(val, typeArguments, methodArguments);
+						GetMemberInfoValue((MemberInfo)instruction.operand, out instruction.argument);
+						break;
+					}
+
+				case OperandType.InlineType:
+					{
+						var val = ilBytes.ReadInt32();
+						instruction.operand = module.ResolveType(val, typeArguments, methodArguments);
+						instruction.argument = (Type)instruction.operand;
+						break;
+					}
+
+				case OperandType.InlineMethod:
+					{
+						var val = ilBytes.ReadInt32();
+						instruction.operand = module.ResolveMethod(val, typeArguments, methodArguments);
+						if (instruction.operand is ConstructorInfo)
+							instruction.argument = (ConstructorInfo)instruction.operand;
+						else
+							instruction.argument = (MethodInfo)instruction.operand;
+						break;
+					}
+
+				case OperandType.InlineField:
+					{
+						var val = ilBytes.ReadInt32();
+						instruction.operand = module.ResolveField(val, typeArguments, methodArguments);
+						instruction.argument = (FieldInfo)instruction.operand;
+						break;
+					}
+
+				case OperandType.ShortInlineVar:
+					{
+						var idx = ilBytes.ReadByte();
+						if (TargetsLocalVariable(instruction.opcode))
+						{
+							var lvi = GetLocalVariable(idx);
+							if (lvi == null)
+								instruction.argument = idx;
+							else
+							{
+								instruction.operand = lvi;
+								instruction.argument = variables[lvi.LocalIndex];
+							}
+						}
+						else
+						{
+							instruction.operand = GetParameter(idx);
+							instruction.argument = idx;
+						}
+						break;
+					}
+
+				case OperandType.InlineVar:
+					{
+						var idx = ilBytes.ReadInt16();
+						if (TargetsLocalVariable(instruction.opcode))
+						{
+							var lvi = GetLocalVariable(idx);
+							if (lvi == null)
+								instruction.argument = idx;
+							else
+							{
+								instruction.operand = lvi;
+								instruction.argument = variables[lvi.LocalIndex];
+							}
+						}
+						else
+						{
+							instruction.operand = GetParameter(idx);
+							instruction.argument = idx;
+						}
+						break;
+					}
+
+				default:
+					throw new NotSupportedException();
+			}
+		}
+
+		ILInstruction GetInstruction(int offset, bool isEndOfInstruction)
+		{
+			var lastInstructionIndex = ilInstructions.Count - 1;
+			if (offset < 0 || offset > ilInstructions[lastInstructionIndex].offset)
+				throw new Exception("Instruction offset " + offset + " is outside valid range 0 - " + ilInstructions[lastInstructionIndex].offset);
+
+			var min = 0;
+			var max = lastInstructionIndex;
+			while (min <= max)
+			{
+				var mid = min + ((max - min) / 2);
+				var instruction = ilInstructions[mid];
+
+				if (isEndOfInstruction)
+				{
+					if (offset == instruction.offset + instruction.GetSize() - 1)
+						return instruction;
+				}
+				else
+				{
+					if (offset == instruction.offset)
+						return instruction;
+				}
+
+				if (offset < instruction.offset)
+					max = mid - 1;
+				else
+					min = mid + 1;
+			}
+
+			throw new Exception("Cannot find instruction for " + offset.ToString("X4"));
+		}
+
+		static bool TargetsLocalVariable(OpCode opcode)
+		{
+			return opcode.Name.Contains("loc");
+		}
+
+		LocalVariableInfo GetLocalVariable(int index)
+		{
+			return locals?[index];
+		}
+
+		ParameterInfo GetParameter(int index)
+		{
+			if (index == 0)
+				return this_parameter;
+
+			return parameters[index - 1];
+		}
+
+		OpCode ReadOpCode()
+		{
+			var op = ilBytes.ReadByte();
+			return op != 0xfe
+				? one_byte_opcodes[op]
+				: two_bytes_opcodes[ilBytes.ReadByte()];
+		}
+
+		MethodInfo EmitMethodForType(Type type)
+		{
+			foreach (var entry in emitMethods)
+				if (entry.Key == type) return entry.Value;
+			foreach (var entry in emitMethods)
+				if (entry.Key.IsAssignableFrom(type)) return entry.Value;
+			return null;
+		}
+
+		// static initializer to prep opcodes
+
+		static readonly OpCode[] one_byte_opcodes;
+		static readonly OpCode[] two_bytes_opcodes;
+
+		static readonly Dictionary<Type, MethodInfo> emitMethods;
+
+		[MethodImpl(MethodImplOptions.Synchronized)]
+		static MethodBodyReader()
+		{
+			one_byte_opcodes = new OpCode[0xe1];
+			two_bytes_opcodes = new OpCode[0x1f];
+
+			var fields = typeof(OpCodes).GetFields(
+				BindingFlags.Public | BindingFlags.Static);
+
+			foreach (var field in fields)
+			{
+				var opcode = (OpCode)field.GetValue(null);
+				if (opcode.OpCodeType == OpCodeType.Nternal)
+					continue;
+
+				if (opcode.Size == 1)
+					one_byte_opcodes[opcode.Value] = opcode;
+				else
+					two_bytes_opcodes[opcode.Value & 0xff] = opcode;
+			}
+
+			emitMethods = new Dictionary<Type, MethodInfo>();
+			typeof(ILGenerator).GetMethods().ToList()
+				.Do(method =>
+				{
+					if (method.Name != "Emit") return;
+					var pinfos = method.GetParameters();
+					if (pinfos.Length != 2) return;
+					var types = pinfos.Select(p => p.ParameterType).ToArray();
+					if (types[0] != typeof(OpCode)) return;
+					emitMethods[types[1]] = method;
+				});
+		}
+
+		// a custom this parameter
+
+		class ThisParameter : ParameterInfo
+		{
+			public ThisParameter(MethodBase method)
+			{
+				MemberImpl = method;
+				ClassImpl = method.DeclaringType;
+				NameImpl = "this";
+				PositionImpl = -1;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/ILCopying/Signature.cs b/src/Harmony/ILCopying/Signature.cs
new file mode 100644
index 00000000..fae8a202
--- /dev/null
+++ b/src/Harmony/ILCopying/Signature.cs
@@ -0,0 +1,271 @@
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.Remoting.Contexts;
+using System.Linq;
+
+namespace Harmony.ILCopying
+{
+	/*
+	 * TODO - this needs to be worked on. The purpose is to decode the signature into
+	 *        a high level reflection based calling signature that is valid in the
+	 *        current assembly
+	 *
+	 *        See also where OperandType.InlineSig is handled in MethodCopier.cs
+	 * 
+	public static class Signature
+	{
+		internal const byte DEFAULT = 0x00;
+		internal const byte VARARG = 0x05;
+		internal const byte GENERIC = 0x10;
+		internal const byte HASTHIS = 0x20;
+		internal const byte EXPLICITTHIS = 0x40;
+		internal const byte FIELD = 0x06;
+		internal const byte LOCAL_SIG = 0x07;
+		internal const byte PROPERTY = 0x08;
+		internal const byte GENERICINST = 0x0A;
+		internal const byte SENTINEL = 0x41;
+		internal const byte ELEMENT_TYPE_VOID = 0x01;
+		internal const byte ELEMENT_TYPE_BOOLEAN = 0x02;
+		internal const byte ELEMENT_TYPE_CHAR = 0x03;
+		internal const byte ELEMENT_TYPE_I1 = 0x04;
+		internal const byte ELEMENT_TYPE_U1 = 0x05;
+		internal const byte ELEMENT_TYPE_I2 = 0x06;
+		internal const byte ELEMENT_TYPE_U2 = 0x07;
+		internal const byte ELEMENT_TYPE_I4 = 0x08;
+		internal const byte ELEMENT_TYPE_U4 = 0x09;
+		internal const byte ELEMENT_TYPE_I8 = 0x0a;
+		internal const byte ELEMENT_TYPE_U8 = 0x0b;
+		internal const byte ELEMENT_TYPE_R4 = 0x0c;
+		internal const byte ELEMENT_TYPE_R8 = 0x0d;
+		internal const byte ELEMENT_TYPE_STRING = 0x0e;
+		internal const byte ELEMENT_TYPE_PTR = 0x0f;
+		internal const byte ELEMENT_TYPE_BYREF = 0x10;
+		internal const byte ELEMENT_TYPE_VALUETYPE = 0x11;
+		internal const byte ELEMENT_TYPE_CLASS = 0x12;
+		internal const byte ELEMENT_TYPE_VAR = 0x13;
+		internal const byte ELEMENT_TYPE_ARRAY = 0x14;
+		internal const byte ELEMENT_TYPE_GENERICINST = 0x15;
+		internal const byte ELEMENT_TYPE_TYPEDBYREF = 0x16;
+		internal const byte ELEMENT_TYPE_I = 0x18;
+		internal const byte ELEMENT_TYPE_U = 0x19;
+		internal const byte ELEMENT_TYPE_FNPTR = 0x1b;
+		internal const byte ELEMENT_TYPE_OBJECT = 0x1c;
+		internal const byte ELEMENT_TYPE_SZARRAY = 0x1d;
+		internal const byte ELEMENT_TYPE_MVAR = 0x1e;
+		internal const byte ELEMENT_TYPE_CMOD_REQD = 0x1f;
+		internal const byte ELEMENT_TYPE_CMOD_OPT = 0x20;
+		internal const byte ELEMENT_TYPE_PINNED = 0x45;
+
+		static int ReadCompressedUInt(byte[] bytes, ref int n)
+		{
+			var b1 = bytes[n++];
+			if (b1 <= 0x7F)
+			{
+				return b1;
+			}
+			else if ((b1 & 0xC0) == 0x80)
+			{
+				var b2 = bytes[n++];
+				return ((b1 & 0x3F) << 8) | b2;
+			}
+			else
+			{
+				var b2 = bytes[n++];
+				var b3 = bytes[n++];
+				var b4 = bytes[n++];
+				return ((b1 & 0x3F) << 24) + (b2 << 16) + (b3 << 8) + b4;
+			}
+		}
+
+		static Type ReadTypeOrVoid(Module module, byte[] bytes, ref int n, Context context)
+		{
+			if (bytes[n] == ELEMENT_TYPE_VOID)
+			{
+				n++;
+				return module.GetType("System.Void");
+			}
+			else
+			{
+				return ReadType(module, br, context);
+			}
+		}
+
+		static Type ReadFunctionPointer(Module module, byte[] bytes, ref int n, Context context)
+		{
+			var len = bytes.Length - n;
+			var newBytes = new byte[len];
+			for (var i = 0; i < len; i++)
+				newBytes[i] = bytes[n + i];
+
+			var sig = ReadStandaloneSignature(module, newBytes, context);
+			if (module.universe.EnableFunctionPointers)
+			{
+				return FunctionPointerType.Make(module.universe, sig);
+			}
+			else
+			{
+				// by default, like .NET we return System.IntPtr here
+				return module.universe.System_IntPtr;
+			}
+		}
+
+		static Type ReadType(Module module, byte[] bytes, ref int n, Context context)
+		{
+			CustomModifiers mods;
+			switch (bytes[n++])
+			{
+				case ELEMENT_TYPE_CLASS:
+					return ReadTypeDefOrRefEncoded(module, br, context).MarkNotValueType();
+				case ELEMENT_TYPE_VALUETYPE:
+					return ReadTypeDefOrRefEncoded(module, br, context).MarkValueType();
+				case ELEMENT_TYPE_BOOLEAN:
+					return module.GetType("System.Boolean");
+				case ELEMENT_TYPE_CHAR:
+					return module.GetType("System.Char");
+				case ELEMENT_TYPE_I1:
+					return module.GetType("System.SByte");
+				case ELEMENT_TYPE_U1:
+					return module.GetType("System.Byte");
+				case ELEMENT_TYPE_I2:
+					return module.GetType("System.Int16");
+				case ELEMENT_TYPE_U2:
+					return module.GetType("System.UInt16");
+				case ELEMENT_TYPE_I4:
+					return module.GetType("System.Int32");
+				case ELEMENT_TYPE_U4:
+					return module.GetType("System.UInt32");
+				case ELEMENT_TYPE_I8:
+					return module.GetType("System.Int64");
+				case ELEMENT_TYPE_U8:
+					return module.GetType("System.UInt64");
+				case ELEMENT_TYPE_R4:
+					return module.GetType("System.Single");
+				case ELEMENT_TYPE_R8:
+					return module.GetType("System.Double");
+				case ELEMENT_TYPE_I:
+					return module.GetType("System.IntPtr");
+				case ELEMENT_TYPE_U:
+					return module.GetType("System.UIntPtr");
+				case ELEMENT_TYPE_STRING:
+					return module.GetType("System.String");
+				case ELEMENT_TYPE_OBJECT:
+					return module.GetType("System.Object");
+				case ELEMENT_TYPE_VAR:
+					return context.GetGenericTypeArgument(br.ReadCompressedUInt());
+				case ELEMENT_TYPE_MVAR:
+					return context.GetGenericMethodArgument(br.ReadCompressedUInt());
+				case ELEMENT_TYPE_GENERICINST:
+					return ReadGenericInst(module, br, context);
+				case ELEMENT_TYPE_SZARRAY:
+					mods = CustomModifiers.Read(module, br, context);
+					return ReadType(module, br, context).__MakeArrayType(mods);
+				case ELEMENT_TYPE_ARRAY:
+					mods = CustomModifiers.Read(module, br, context);
+					return ReadType(module, br, context).__MakeArrayType(br.ReadCompressedUInt(), ReadArraySizes(br), ReadArrayBounds(br), mods);
+				case ELEMENT_TYPE_PTR:
+					mods = CustomModifiers.Read(module, br, context);
+					return ReadTypeOrVoid(module, br, context).__MakePointerType(mods);
+				case ELEMENT_TYPE_FNPTR:
+					return ReadFunctionPointer(module, br, context);
+				default:
+					throw new BadImageFormatException();
+			}
+		}
+
+		static Type ReadTypeOrByRef(Module module, byte[] bytes, ref int n, Context context)
+		{
+			if (bytes[n] == ELEMENT_TYPE_BYREF)
+			{
+				n++;
+				// LAMESPEC it is allowed (by C++/CLI, ilasm and peverify) to have custom modifiers after the BYREF
+				// (which makes sense, as it is analogous to pointers)
+				CustomModifiers mods = CustomModifiers.Read(module, br, context);
+				// C++/CLI generates void& local variables, so we need to use ReadTypeOrVoid here
+				return ReadTypeOrVoid(module, br, context).__MakeByRefType(mods);
+			}
+			return ReadType(module, br, context);
+		}
+
+		static Type ReadRetType(Module module, byte[] bytes, ref int n, Context context)
+		{
+			switch (bytes[n])
+			{
+				case ELEMENT_TYPE_VOID:
+					n++;
+					return module.GetType("System.Void");
+				case ELEMENT_TYPE_TYPEDBYREF:
+					n++;
+					return module.GetType("System.TypedReference");
+				default:
+					return ReadTypeOrByRef(module, br, context);
+			}
+		}
+
+		public static void ReadStandaloneSignature(Module module, byte[] bytes, Context context)
+		{
+			CallingConvention unmanagedCallingConvention;
+			CallingConventions callingConvention;
+
+			var n = 0;
+			unmanagedCallingConvention = 0;
+			callingConvention = 0;
+
+			var flags = bytes[n++];
+			bool unmanaged;
+			switch (flags & 7)
+			{
+				case DEFAULT:
+					callingConvention = CallingConventions.Standard;
+					unmanaged = false;
+					break;
+				case 0x01:  // C
+					unmanagedCallingConvention = CallingConvention.Cdecl;
+					unmanaged = true;
+					break;
+				case 0x02:  // STDCALL
+					unmanagedCallingConvention = CallingConvention.StdCall;
+					unmanaged = true;
+					break;
+				case 0x03:  // THISCALL
+					unmanagedCallingConvention = CallingConvention.ThisCall;
+					unmanaged = true;
+					break;
+				case 0x04:  // FASTCALL
+					unmanagedCallingConvention = CallingConvention.FastCall;
+					unmanaged = true;
+					break;
+				case VARARG:
+					callingConvention = CallingConventions.VarArgs;
+					unmanaged = false;
+					break;
+				default:
+					throw new BadImageFormatException();
+			}
+			if ((flags & HASTHIS) != 0) callingConvention |= CallingConventions.HasThis;
+			if ((flags & EXPLICITTHIS) != 0) callingConvention |= CallingConventions.ExplicitThis;
+			if ((flags & GENERIC) != 0) throw new BadImageFormatException();
+			var paramCount = ReadCompressedUInt(bytes, ref n);
+			CustomModifiers[] customModifiers = null;
+			PackedCustomModifiers.Pack(ref customModifiers, 0, CustomModifiers.Read(module, br, context), paramCount + 1);
+			Type returnType = ReadRetType(module, br, context);
+			List<Type> parameterTypes = new List<Type>();
+			List<Type> optionalParameterTypes = new List<Type>();
+			List<Type> curr = parameterTypes;
+			for (int i = 0; i < paramCount; i++)
+			{
+				if (br.PeekByte() == SENTINEL)
+				{
+					br.ReadByte();
+					curr = optionalParameterTypes;
+				}
+				PackedCustomModifiers.Pack(ref customModifiers, i + 1, CustomModifiers.Read(module, br, context), paramCount + 1);
+				curr.Add(ReadParam(module, br, context));
+			}
+		}
+	}
+	*/
+}
diff --git a/src/Harmony/MethodPatcher.cs b/src/Harmony/MethodPatcher.cs
new file mode 100644
index 00000000..9187a7d7
--- /dev/null
+++ b/src/Harmony/MethodPatcher.cs
@@ -0,0 +1,419 @@
+using Harmony.ILCopying;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public static class MethodPatcher
+	{
+		// special parameter names that can be used in prefix and postfix methods
+		//
+		public static string INSTANCE_PARAM = "__instance";
+		public static string ORIGINAL_METHOD_PARAM = "__originalMethod";
+		public static string RESULT_VAR = "__result";
+		public static string STATE_VAR = "__state";
+		public static string PARAM_INDEX_PREFIX = "__";
+		public static string INSTANCE_FIELD_PREFIX = "___";
+
+		// in case of trouble, set to true to write dynamic method to desktop as a dll
+		// won't work for all methods because of the inability to extend a type compared
+		// to the way DynamicTools.CreateDynamicMethod works
+		//
+		static readonly bool DEBUG_METHOD_GENERATION_BY_DLL_CREATION = false;
+
+		// for fixing old harmony bugs
+		[UpgradeToLatestVersion(1)]
+		public static DynamicMethod CreatePatchedMethod(MethodBase original, List<MethodInfo> prefixes, List<MethodInfo> postfixes, List<MethodInfo> transpilers)
+		{
+			return CreatePatchedMethod(original, "HARMONY_PATCH_1.1.1", prefixes, postfixes, transpilers);
+		}
+
+		public static DynamicMethod CreatePatchedMethod(MethodBase original, string harmonyInstanceID, List<MethodInfo> prefixes, List<MethodInfo> postfixes, List<MethodInfo> transpilers)
+		{
+			try
+			{
+				if (HarmonyInstance.DEBUG) FileLog.LogBuffered("### Patch " + original.DeclaringType + ", " + original);
+
+				var idx = prefixes.Count() + postfixes.Count();
+				var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
+				if (patch == null)
+					return null;
+
+				var il = patch.GetILGenerator();
+
+				// for debugging
+				AssemblyBuilder assemblyBuilder = null;
+				TypeBuilder typeBuilder = null;
+				if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
+					il = DynamicTools.CreateSaveableMethod(original, "_Patch" + idx, out assemblyBuilder, out typeBuilder);
+
+				var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
+				var privateVars = new Dictionary<string, LocalBuilder>();
+
+				LocalBuilder resultVariable = null;
+				if (idx > 0)
+				{
+					resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
+					privateVars[RESULT_VAR] = resultVariable;
+				}
+
+				prefixes.ForEach(prefix =>
+				{
+					prefix.GetParameters()
+						.Where(patchParam => patchParam.Name == STATE_VAR)
+						.Do(patchParam =>
+						{
+							var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
+							privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
+						});
+				});
+
+				var skipOriginalLabel = il.DefineLabel();
+				var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel);
+
+				var copier = new MethodCopier(original, il, originalVariables);
+				foreach (var transpiler in transpilers)
+					copier.AddTranspiler(transpiler);
+
+				var endLabels = new List<Label>();
+				var endBlocks = new List<ExceptionBlock>();
+				copier.Finalize(endLabels, endBlocks);
+
+				foreach (var label in endLabels)
+					Emitter.MarkLabel(il, label);
+				foreach (var block in endBlocks)
+					Emitter.MarkBlockAfter(il, block);
+				if (resultVariable != null)
+					Emitter.Emit(il, OpCodes.Stloc, resultVariable);
+				if (canHaveJump)
+					Emitter.MarkLabel(il, skipOriginalLabel);
+
+				AddPostfixes(il, original, postfixes, privateVars, false);
+
+				if (resultVariable != null)
+					Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
+
+				AddPostfixes(il, original, postfixes, privateVars, true);
+
+				Emitter.Emit(il, OpCodes.Ret);
+
+				if (HarmonyInstance.DEBUG)
+				{
+					FileLog.LogBuffered("DONE");
+					FileLog.LogBuffered("");
+					FileLog.FlushBuffer();
+				}
+
+				// for debugging
+				if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
+				{
+					DynamicTools.SaveMethod(assemblyBuilder, typeBuilder);
+					return null;
+				}
+
+				DynamicTools.PrepareDynamicMethod(patch);
+				return patch;
+			}
+			catch (Exception ex)
+			{
+				throw new Exception("Exception from HarmonyInstance \"" + harmonyInstanceID + "\"", ex);
+			}
+			finally
+			{
+				if (HarmonyInstance.DEBUG)
+					FileLog.FlushBuffer();
+			}
+		}
+
+		static OpCode LoadIndOpCodeFor(Type type)
+		{
+			if (type.IsEnum) return OpCodes.Ldind_I4;
+
+			if (type == typeof(float)) return OpCodes.Ldind_R4;
+			if (type == typeof(double)) return OpCodes.Ldind_R8;
+
+			if (type == typeof(byte)) return OpCodes.Ldind_U1;
+			if (type == typeof(ushort)) return OpCodes.Ldind_U2;
+			if (type == typeof(uint)) return OpCodes.Ldind_U4;
+			if (type == typeof(ulong)) return OpCodes.Ldind_I8;
+
+			if (type == typeof(sbyte)) return OpCodes.Ldind_I1;
+			if (type == typeof(short)) return OpCodes.Ldind_I2;
+			if (type == typeof(int)) return OpCodes.Ldind_I4;
+			if (type == typeof(long)) return OpCodes.Ldind_I8;
+
+			return OpCodes.Ldind_Ref;
+		}
+
+		static HarmonyArgument GetArgumentAttribute(this ParameterInfo parameter)
+		{
+			return parameter.GetCustomAttributes(false).FirstOrDefault(attr => attr is HarmonyArgument) as HarmonyArgument;
+		}
+
+		static HarmonyArgument[] GetArgumentAttributes(this MethodInfo method)
+		{
+			return method.GetCustomAttributes(false).Where(attr => attr is HarmonyArgument).Cast<HarmonyArgument>().ToArray();
+		}
+
+		static HarmonyArgument[] GetArgumentAttributes(this Type type)
+		{
+			return type.GetCustomAttributes(false).Where(attr => attr is HarmonyArgument).Cast<HarmonyArgument>().ToArray();
+		}
+
+		static string GetOriginalArgumentName(this ParameterInfo parameter, string[] originalParameterNames)
+		{
+			var attribute = parameter.GetArgumentAttribute();
+			if (attribute == null)
+				return null;
+
+			if (string.IsNullOrEmpty(attribute.OriginalName) == false)
+				return attribute.OriginalName;
+
+			if (attribute.Index >= 0 && attribute.Index < originalParameterNames.Length)
+				return originalParameterNames[attribute.Index];
+
+			return null;
+		}
+
+		static string GetOriginalArgumentName(HarmonyArgument[] attributes, string name, string[] originalParameterNames)
+		{
+			if (attributes.Length <= 0)
+				return null;
+
+			var attribute = attributes.SingleOrDefault(p => p.NewName == name);
+			if (attribute == null)
+				return null;
+
+			if (string.IsNullOrEmpty(attribute.OriginalName) == false)
+				return attribute.OriginalName;
+
+			if (attribute.Index >= 0 && attribute.Index < originalParameterNames.Length)
+				return originalParameterNames[attribute.Index];
+
+			return null;
+		}
+
+		static string GetOriginalArgumentName(this MethodInfo method, string[] originalParameterNames, string name)
+		{
+			string argumentName;
+
+			argumentName = GetOriginalArgumentName(method.GetArgumentAttributes(), name, originalParameterNames);
+			if (argumentName != null)
+				return argumentName;
+
+			argumentName = GetOriginalArgumentName(method.DeclaringType.GetArgumentAttributes(), name, originalParameterNames);
+			if (argumentName != null)
+				return argumentName;
+
+			return name;
+		}
+
+		private static int GetArgumentIndex(MethodInfo patch, string[] originalParameterNames, ParameterInfo patchParam)
+		{
+			var originalName = patchParam.GetOriginalArgumentName(originalParameterNames);
+			if (originalName != null)
+				return Array.IndexOf(originalParameterNames, originalName);
+
+			var patchParamName = patchParam.Name;
+			originalName = patch.GetOriginalArgumentName(originalParameterNames, patchParamName);
+			if (originalName != null)
+				return Array.IndexOf(originalParameterNames, originalName);
+
+			return -1;
+		}
+
+		static MethodInfo getMethodMethod = typeof(MethodBase).GetMethod("GetMethodFromHandle", new[] { typeof(RuntimeMethodHandle) });
+
+		static void EmitCallParameter(ILGenerator il, MethodBase original, MethodInfo patch, Dictionary<string, LocalBuilder> variables, bool allowFirsParamPassthrough)
+		{
+			var isInstance = original.IsStatic == false;
+			var originalParameters = original.GetParameters();
+			var originalParameterNames = originalParameters.Select(p => p.Name).ToArray();
+
+			// check for passthrough using first parameter (which must have same type as return type)
+			var parameters = patch.GetParameters().ToList();
+			if (allowFirsParamPassthrough && patch.ReturnType != typeof(void) && parameters.Count > 0 && parameters[0].ParameterType == patch.ReturnType)
+				parameters.RemoveRange(0, 1);
+
+			foreach (var patchParam in parameters)
+			{
+				if (patchParam.Name == ORIGINAL_METHOD_PARAM)
+				{
+					var constructorInfo = original as ConstructorInfo;
+					if (constructorInfo != null)
+					{
+						Emitter.Emit(il, OpCodes.Ldtoken, constructorInfo);
+						Emitter.Emit(il, OpCodes.Call, getMethodMethod);
+						continue;
+					}
+					var methodInfo = original as MethodInfo;
+					if (methodInfo != null)
+					{
+						Emitter.Emit(il, OpCodes.Ldtoken, methodInfo);
+						Emitter.Emit(il, OpCodes.Call, getMethodMethod);
+						continue;
+					}
+					Emitter.Emit(il, OpCodes.Ldnull);
+					continue;
+				}
+
+				if (patchParam.Name == INSTANCE_PARAM)
+				{
+					if (original.IsStatic)
+						Emitter.Emit(il, OpCodes.Ldnull);
+					else if (patchParam.ParameterType.IsByRef)
+						Emitter.Emit(il, OpCodes.Ldarga, 0); // probably won't work or will be useless
+					else
+						Emitter.Emit(il, OpCodes.Ldarg_0);
+					continue;
+				}
+
+				if (patchParam.Name.StartsWith(INSTANCE_FIELD_PREFIX))
+				{
+					var fieldName = patchParam.Name.Substring(INSTANCE_FIELD_PREFIX.Length);
+					FieldInfo fieldInfo;
+					if (fieldName.All(char.IsDigit))
+					{
+						fieldInfo = AccessTools.Field(original.DeclaringType, int.Parse(fieldName));
+						if (fieldInfo == null)
+							throw new ArgumentException("No field found at given index in class " + original.DeclaringType.FullName, fieldName);
+					}
+					else
+					{
+						fieldInfo = AccessTools.Field(original.DeclaringType, fieldName);
+						if (fieldInfo == null)
+							throw new ArgumentException("No such field defined in class " + original.DeclaringType.FullName, fieldName);
+					}
+
+					if (fieldInfo.IsStatic)
+					{
+						if (patchParam.ParameterType.IsByRef)
+							Emitter.Emit(il, OpCodes.Ldsflda, fieldInfo);
+						else
+							Emitter.Emit(il, OpCodes.Ldsfld, fieldInfo);
+					}
+					else
+					{
+						if (patchParam.ParameterType.IsByRef)
+						{
+							Emitter.Emit(il, OpCodes.Ldarg_0);
+							Emitter.Emit(il, OpCodes.Ldflda, fieldInfo);
+						}
+						else
+						{
+							Emitter.Emit(il, OpCodes.Ldarg_0);
+							Emitter.Emit(il, OpCodes.Ldfld, fieldInfo);
+						}
+					}
+					continue;
+				}
+
+				if (patchParam.Name == STATE_VAR)
+				{
+					var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
+					Emitter.Emit(il, ldlocCode, variables[patch.DeclaringType.FullName]);
+					continue;
+				}
+
+				if (patchParam.Name == RESULT_VAR)
+				{
+					if (AccessTools.GetReturnedType(original) == typeof(void))
+						throw new Exception("Cannot get result from void method " + original.FullDescription());
+					var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
+					Emitter.Emit(il, ldlocCode, variables[RESULT_VAR]);
+					continue;
+				}
+
+				int idx;
+				if (patchParam.Name.StartsWith(PARAM_INDEX_PREFIX))
+				{
+					var val = patchParam.Name.Substring(PARAM_INDEX_PREFIX.Length);
+					if (!int.TryParse(val, out idx))
+						throw new Exception("Parameter " + patchParam.Name + " does not contain a valid index");
+					if (idx < 0 || idx >= originalParameters.Length)
+						throw new Exception("No parameter found at index " + idx);
+				}
+				else
+				{
+					idx = GetArgumentIndex(patch, originalParameterNames, patchParam);
+					if (idx == -1) throw new Exception("Parameter \"" + patchParam.Name + "\" not found in method " + original.FullDescription());
+				}
+
+				//   original -> patch     opcode
+				// --------------------------------------
+				// 1 normal   -> normal  : LDARG
+				// 2 normal   -> ref/out : LDARGA
+				// 3 ref/out  -> normal  : LDARG, LDIND_x
+				// 4 ref/out  -> ref/out : LDARG
+				//
+				var originalIsNormal = originalParameters[idx].IsOut == false && originalParameters[idx].ParameterType.IsByRef == false;
+				var patchIsNormal = patchParam.IsOut == false && patchParam.ParameterType.IsByRef == false;
+				var patchArgIndex = idx + (isInstance ? 1 : 0);
+
+				// Case 1 + 4
+				if (originalIsNormal == patchIsNormal)
+				{
+					Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
+					continue;
+				}
+
+				// Case 2
+				if (originalIsNormal && patchIsNormal == false)
+				{
+					Emitter.Emit(il, OpCodes.Ldarga, patchArgIndex);
+					continue;
+				}
+
+				// Case 3
+				Emitter.Emit(il, OpCodes.Ldarg, patchArgIndex);
+				Emitter.Emit(il, LoadIndOpCodeFor(originalParameters[idx].ParameterType));
+			}
+		}
+
+		static bool AddPrefixes(ILGenerator il, MethodBase original, List<MethodInfo> prefixes, Dictionary<string, LocalBuilder> variables, Label label)
+		{
+			var canHaveJump = false;
+			prefixes.ForEach(fix =>
+			{
+				EmitCallParameter(il, original, fix, variables, false);
+				Emitter.Emit(il, OpCodes.Call, fix);
+
+				if (fix.ReturnType != typeof(void))
+				{
+					if (fix.ReturnType != typeof(bool))
+						throw new Exception("Prefix patch " + fix + " has not \"bool\" or \"void\" return type: " + fix.ReturnType);
+					Emitter.Emit(il, OpCodes.Brfalse, label);
+					canHaveJump = true;
+				}
+			});
+			return canHaveJump;
+		}
+
+		static void AddPostfixes(ILGenerator il, MethodBase original, List<MethodInfo> postfixes, Dictionary<string, LocalBuilder> variables, bool passthroughPatches)
+		{
+			postfixes
+				.Where(fix => passthroughPatches == (fix.ReturnType != typeof(void)))
+				.Do(fix =>
+				{
+					EmitCallParameter(il, original, fix, variables, true);
+					Emitter.Emit(il, OpCodes.Call, fix);
+
+					if (fix.ReturnType != typeof(void))
+					{
+						var firstFixParam = fix.GetParameters().FirstOrDefault();
+						var hasPassThroughResultParam = firstFixParam != null && fix.ReturnType == firstFixParam.ParameterType;
+						if (!hasPassThroughResultParam)
+						{
+							if (firstFixParam != null)
+								throw new Exception("Return type of postfix patch " + fix + " does match type of its first parameter");
+
+							throw new Exception("Postfix patch " + fix + " must have a \"void\" return type");
+						}
+					}
+				});
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Patch.cs b/src/Harmony/Patch.cs
new file mode 100644
index 00000000..69adb189
--- /dev/null
+++ b/src/Harmony/Patch.cs
@@ -0,0 +1,194 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters.Binary;
+
+namespace Harmony
+{
+	public static class PatchInfoSerialization
+	{
+		class Binder : SerializationBinder
+		{
+			public override Type BindToType(string assemblyName, string typeName)
+			{
+				var types = new Type[] {
+					typeof(PatchInfo),
+					typeof(Patch[]),
+					typeof(Patch)
+				};
+				foreach (var type in types)
+					if (typeName == type.FullName)
+						return type;
+				var typeToDeserialize = Type.GetType(string.Format("{0}, {1}", typeName, assemblyName));
+				return typeToDeserialize;
+			}
+		}
+
+		public static byte[] Serialize(this PatchInfo patchInfo)
+		{
+#pragma warning disable XS0001
+			using (var streamMemory = new MemoryStream())
+			{
+				var formatter = new BinaryFormatter();
+				formatter.Serialize(streamMemory, patchInfo);
+				return streamMemory.GetBuffer();
+			}
+#pragma warning restore XS0001
+		}
+
+		public static PatchInfo Deserialize(byte[] bytes)
+		{
+			var formatter = new BinaryFormatter { Binder = new Binder() };
+#pragma warning disable XS0001
+			var streamMemory = new MemoryStream(bytes);
+#pragma warning restore XS0001
+			return (PatchInfo)formatter.Deserialize(streamMemory);
+		}
+
+		// general sorting by (in that order): before, after, priority and index
+		public static int PriorityComparer(object obj, int index, int priority, string[] before, string[] after)
+		{
+			var trv = Traverse.Create(obj);
+			var theirOwner = trv.Field("owner").GetValue<string>();
+			var theirPriority = trv.Field("priority").GetValue<int>();
+			var theirIndex = trv.Field("index").GetValue<int>();
+
+			if (before != null && Array.IndexOf(before, theirOwner) > -1)
+				return -1;
+			if (after != null && Array.IndexOf(after, theirOwner) > -1)
+				return 1;
+
+			if (priority != theirPriority)
+				return -(priority.CompareTo(theirPriority));
+
+			return index.CompareTo(theirIndex);
+		}
+	}
+
+	[Serializable]
+	public class PatchInfo
+	{
+		public Patch[] prefixes;
+		public Patch[] postfixes;
+		public Patch[] transpilers;
+
+		public PatchInfo()
+		{
+			prefixes = new Patch[0];
+			postfixes = new Patch[0];
+			transpilers = new Patch[0];
+		}
+
+		public void AddPrefix(MethodInfo patch, string owner, int priority, string[] before, string[] after)
+		{
+			var l = prefixes.ToList();
+			l.Add(new Patch(patch, prefixes.Count() + 1, owner, priority, before, after));
+			prefixes = l.ToArray();
+		}
+
+		public void RemovePrefix(string owner)
+		{
+			if (owner == "*")
+			{
+				prefixes = new Patch[0];
+				return;
+			}
+			prefixes = prefixes.Where(patch => patch.owner != owner).ToArray();
+		}
+
+		public void AddPostfix(MethodInfo patch, string owner, int priority, string[] before, string[] after)
+		{
+			var l = postfixes.ToList();
+			l.Add(new Patch(patch, postfixes.Count() + 1, owner, priority, before, after));
+			postfixes = l.ToArray();
+		}
+
+		public void RemovePostfix(string owner)
+		{
+			if (owner == "*")
+			{
+				postfixes = new Patch[0];
+				return;
+			}
+			postfixes = postfixes.Where(patch => patch.owner != owner).ToArray();
+		}
+
+		public void AddTranspiler(MethodInfo patch, string owner, int priority, string[] before, string[] after)
+		{
+			var l = transpilers.ToList();
+			l.Add(new Patch(patch, transpilers.Count() + 1, owner, priority, before, after));
+			transpilers = l.ToArray();
+		}
+
+		public void RemoveTranspiler(string owner)
+		{
+			if (owner == "*")
+			{
+				transpilers = new Patch[0];
+				return;
+			}
+			transpilers = transpilers.Where(patch => patch.owner != owner).ToArray();
+		}
+
+		public void RemovePatch(MethodInfo patch)
+		{
+			prefixes = prefixes.Where(p => p.patch != patch).ToArray();
+			postfixes = postfixes.Where(p => p.patch != patch).ToArray();
+			transpilers = transpilers.Where(p => p.patch != patch).ToArray();
+		}
+	}
+
+	[Serializable]
+	public class Patch : IComparable
+	{
+		readonly public int index;
+		readonly public string owner;
+		readonly public int priority;
+		readonly public string[] before;
+		readonly public string[] after;
+
+		readonly public MethodInfo patch;
+
+		public Patch(MethodInfo patch, int index, string owner, int priority, string[] before, string[] after)
+		{
+			if (patch is DynamicMethod) throw new Exception("Cannot directly reference dynamic method \"" + patch.FullDescription() + "\" in Harmony. Use a factory method instead that will return the dynamic method.");
+
+			this.index = index;
+			this.owner = owner;
+			this.priority = priority;
+			this.before = before;
+			this.after = after;
+			this.patch = patch;
+		}
+
+		public MethodInfo GetMethod(MethodBase original)
+		{
+			if (patch.ReturnType != typeof(DynamicMethod)) return patch;
+			if (patch.IsStatic == false) return patch;
+			var parameters = patch.GetParameters();
+			if (parameters.Count() != 1) return patch;
+			if (parameters[0].ParameterType != typeof(MethodBase)) return patch;
+
+			// we have a DynamicMethod factory, let's use it
+			return patch.Invoke(null, new object[] { original }) as DynamicMethod;
+		}
+
+		public override bool Equals(object obj)
+		{
+			return ((obj != null) && (obj is Patch) && (patch == ((Patch)obj).patch));
+		}
+
+		public int CompareTo(object obj)
+		{
+			return PatchInfoSerialization.PriorityComparer(obj, index, priority, before, after);
+		}
+
+		public override int GetHashCode()
+		{
+			return patch.GetHashCode();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/PatchFunctions.cs b/src/Harmony/PatchFunctions.cs
new file mode 100644
index 00000000..dde8011f
--- /dev/null
+++ b/src/Harmony/PatchFunctions.cs
@@ -0,0 +1,99 @@
+using Harmony.ILCopying;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public static class PatchFunctions
+	{
+		public static void AddPrefix(PatchInfo patchInfo, string owner, HarmonyMethod info)
+		{
+			if (info == null || info.method == null) return;
+
+			var priority = info.prioritiy == -1 ? Priority.Normal : info.prioritiy;
+			var before = info.before ?? new string[0];
+			var after = info.after ?? new string[0];
+
+			patchInfo.AddPrefix(info.method, owner, priority, before, after);
+		}
+
+		public static void RemovePrefix(PatchInfo patchInfo, string owner)
+		{
+			patchInfo.RemovePrefix(owner);
+		}
+
+		public static void AddPostfix(PatchInfo patchInfo, string owner, HarmonyMethod info)
+		{
+			if (info == null || info.method == null) return;
+
+			var priority = info.prioritiy == -1 ? Priority.Normal : info.prioritiy;
+			var before = info.before ?? new string[0];
+			var after = info.after ?? new string[0];
+
+			patchInfo.AddPostfix(info.method, owner, priority, before, after);
+		}
+
+		public static void RemovePostfix(PatchInfo patchInfo, string owner)
+		{
+			patchInfo.RemovePostfix(owner);
+		}
+
+		public static void AddTranspiler(PatchInfo patchInfo, string owner, HarmonyMethod info)
+		{
+			if (info == null || info.method == null) return;
+
+			var priority = info.prioritiy == -1 ? Priority.Normal : info.prioritiy;
+			var before = info.before ?? new string[0];
+			var after = info.after ?? new string[0];
+
+			patchInfo.AddTranspiler(info.method, owner, priority, before, after);
+		}
+
+		public static void RemoveTranspiler(PatchInfo patchInfo, string owner)
+		{
+			patchInfo.RemoveTranspiler(owner);
+		}
+
+		public static void RemovePatch(PatchInfo patchInfo, MethodInfo patch)
+		{
+			patchInfo.RemovePatch(patch);
+		}
+
+		// pass in a generator that will create local variables for the returned instructions
+		//
+		public static List<ILInstruction> GetInstructions(ILGenerator generator, MethodBase method)
+		{
+			return MethodBodyReader.GetInstructions(generator, method);
+		}
+
+		public static List<MethodInfo> GetSortedPatchMethods(MethodBase original, Patch[] patches)
+		{
+			return patches
+				.Where(p => p.patch != null)
+				.OrderBy(p => p)
+				.Select(p => p.GetMethod(original))
+				.ToList();
+		}
+
+		public static DynamicMethod UpdateWrapper(MethodBase original, PatchInfo patchInfo, string instanceID)
+		{
+			var sortedPrefixes = GetSortedPatchMethods(original, patchInfo.prefixes);
+			var sortedPostfixes = GetSortedPatchMethods(original, patchInfo.postfixes);
+			var sortedTranspilers = GetSortedPatchMethods(original, patchInfo.transpilers);
+
+			var replacement = MethodPatcher.CreatePatchedMethod(original, instanceID, sortedPrefixes, sortedPostfixes, sortedTranspilers);
+			if (replacement == null) throw new MissingMethodException("Cannot create dynamic replacement for " + original.FullDescription());
+
+			var errorString = Memory.DetourMethod(original, replacement);
+			if (errorString != null)
+				throw new FormatException("Method " + original.FullDescription() + " cannot be patched. Reason: " + errorString);
+
+			PatchTools.RememberObject(original, replacement); // no gc for new value + release old value to gc
+
+			return replacement;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/PatchProcessor.cs b/src/Harmony/PatchProcessor.cs
new file mode 100644
index 00000000..10b14c72
--- /dev/null
+++ b/src/Harmony/PatchProcessor.cs
@@ -0,0 +1,305 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public class PatchProcessor
+	{
+		static object locker = new object();
+
+		readonly HarmonyInstance instance;
+
+		readonly Type container;
+		readonly HarmonyMethod containerAttributes;
+
+		List<MethodBase> originals = new List<MethodBase>();
+		HarmonyMethod prefix;
+		HarmonyMethod postfix;
+		HarmonyMethod transpiler;
+
+		public PatchProcessor(HarmonyInstance instance, Type type, HarmonyMethod attributes)
+		{
+			this.instance = instance;
+			container = type;
+			containerAttributes = attributes ?? new HarmonyMethod(null);
+			prefix = containerAttributes.Clone();
+			postfix = containerAttributes.Clone();
+			transpiler = containerAttributes.Clone();
+			PrepareType();
+		}
+
+		public PatchProcessor(HarmonyInstance instance, List<MethodBase> originals, HarmonyMethod prefix = null, HarmonyMethod postfix = null, HarmonyMethod transpiler = null)
+		{
+			this.instance = instance;
+			this.originals = originals;
+			this.prefix = prefix ?? new HarmonyMethod(null);
+			this.postfix = postfix ?? new HarmonyMethod(null);
+			this.transpiler = transpiler ?? new HarmonyMethod(null);
+		}
+
+		public static Patches GetPatchInfo(MethodBase method)
+		{
+			lock (locker)
+			{
+				var patchInfo = HarmonySharedState.GetPatchInfo(method);
+				if (patchInfo == null) return null;
+				return new Patches(patchInfo.prefixes, patchInfo.postfixes, patchInfo.transpilers);
+			}
+		}
+
+		public static IEnumerable<MethodBase> AllPatchedMethods()
+		{
+			lock (locker)
+			{
+				return HarmonySharedState.GetPatchedMethods();
+			}
+		}
+
+		public List<DynamicMethod> Patch()
+		{
+			lock (locker)
+			{
+				var dynamicMethods = new List<DynamicMethod>();
+				foreach (var original in originals)
+				{
+					if (original == null)
+						throw new NullReferenceException("original");
+
+					var individualPrepareResult = RunMethod<HarmonyPrepare, bool>(true, original);
+					if (individualPrepareResult)
+					{
+						var patchInfo = HarmonySharedState.GetPatchInfo(original);
+						if (patchInfo == null) patchInfo = new PatchInfo();
+
+						PatchFunctions.AddPrefix(patchInfo, instance.Id, prefix);
+						PatchFunctions.AddPostfix(patchInfo, instance.Id, postfix);
+						PatchFunctions.AddTranspiler(patchInfo, instance.Id, transpiler);
+						dynamicMethods.Add(PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id));
+
+						HarmonySharedState.UpdatePatchInfo(original, patchInfo);
+
+						RunMethod<HarmonyCleanup>(original);
+					}
+				}
+				return dynamicMethods;
+			}
+		}
+
+		public void Unpatch(HarmonyPatchType type, string harmonyID)
+		{
+			lock (locker)
+			{
+				foreach (var original in originals)
+				{
+					var patchInfo = HarmonySharedState.GetPatchInfo(original);
+					if (patchInfo == null) patchInfo = new PatchInfo();
+
+					if (type == HarmonyPatchType.All || type == HarmonyPatchType.Prefix)
+						PatchFunctions.RemovePrefix(patchInfo, harmonyID);
+					if (type == HarmonyPatchType.All || type == HarmonyPatchType.Postfix)
+						PatchFunctions.RemovePostfix(patchInfo, harmonyID);
+					if (type == HarmonyPatchType.All || type == HarmonyPatchType.Transpiler)
+						PatchFunctions.RemoveTranspiler(patchInfo, harmonyID);
+					PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id);
+
+					HarmonySharedState.UpdatePatchInfo(original, patchInfo);
+				}
+			}
+		}
+
+		public void Unpatch(MethodInfo patch)
+		{
+			lock (locker)
+			{
+				foreach (var original in originals)
+				{
+					var patchInfo = HarmonySharedState.GetPatchInfo(original);
+					if (patchInfo == null) patchInfo = new PatchInfo();
+
+					PatchFunctions.RemovePatch(patchInfo, patch);
+					PatchFunctions.UpdateWrapper(original, patchInfo, instance.Id);
+
+					HarmonySharedState.UpdatePatchInfo(original, patchInfo);
+				}
+			}
+		}
+
+		void PrepareType()
+		{
+			var mainPrepareResult = RunMethod<HarmonyPrepare, bool>(true);
+			if (mainPrepareResult == false)
+				return;
+
+			var customOriginals = RunMethod<HarmonyTargetMethods, IEnumerable<MethodBase>>(null);
+			if (customOriginals != null)
+			{
+				originals = customOriginals.ToList();
+			}
+			else
+			{
+				var originalMethodType = containerAttributes.methodType;
+
+				// MethodType default is Normal
+				if (containerAttributes.methodType == null)
+					containerAttributes.methodType = MethodType.Normal;
+
+				var isPatchAll = Attribute.GetCustomAttribute(container, typeof(HarmonyPatchAll)) != null;
+				if (isPatchAll)
+				{
+					var type = containerAttributes.declaringType;
+					originals.AddRange(AccessTools.GetDeclaredConstructors(type).Cast<MethodBase>());
+					originals.AddRange(AccessTools.GetDeclaredMethods(type).Cast<MethodBase>());
+				}
+				else
+				{
+					var original = RunMethod<HarmonyTargetMethod, MethodBase>(null);
+
+					if (original == null)
+						original = GetOriginalMethod();
+
+					if (original == null)
+					{
+						var info = "(";
+						info += "declaringType=" + containerAttributes.declaringType + ", ";
+						info += "methodName =" + containerAttributes.methodName + ", ";
+						info += "methodType=" + originalMethodType + ", ";
+						info += "argumentTypes=" + containerAttributes.argumentTypes.Description();
+						info += ")";
+						throw new ArgumentException("No target method specified for class " + container.FullName + " " + info);
+					}
+
+					originals.Add(original);
+				}
+			}
+
+			PatchTools.GetPatches(container, out prefix.method, out postfix.method, out transpiler.method);
+
+			if (prefix.method != null)
+			{
+				if (prefix.method.IsStatic == false)
+					throw new ArgumentException("Patch method " + prefix.method.FullDescription() + " must be static");
+
+				var prefixAttributes = prefix.method.GetHarmonyMethods();
+				containerAttributes.Merge(HarmonyMethod.Merge(prefixAttributes)).CopyTo(prefix);
+			}
+
+			if (postfix.method != null)
+			{
+				if (postfix.method.IsStatic == false)
+					throw new ArgumentException("Patch method " + postfix.method.FullDescription() + " must be static");
+
+				var postfixAttributes = postfix.method.GetHarmonyMethods();
+				containerAttributes.Merge(HarmonyMethod.Merge(postfixAttributes)).CopyTo(postfix);
+			}
+
+			if (transpiler.method != null)
+			{
+				if (transpiler.method.IsStatic == false)
+					throw new ArgumentException("Patch method " + transpiler.method.FullDescription() + " must be static");
+
+				var infixAttributes = transpiler.method.GetHarmonyMethods();
+				containerAttributes.Merge(HarmonyMethod.Merge(infixAttributes)).CopyTo(transpiler);
+			}
+		}
+
+		MethodBase GetOriginalMethod()
+		{
+			var attr = containerAttributes;
+			if (attr.declaringType == null) return null;
+
+			switch (attr.methodType)
+			{
+				case MethodType.Normal:
+					if (attr.methodName == null)
+						return null;
+					return AccessTools.DeclaredMethod(attr.declaringType, attr.methodName, attr.argumentTypes);
+
+				case MethodType.Getter:
+					if (attr.methodName == null)
+						return null;
+					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetGetMethod(true);
+
+				case MethodType.Setter:
+					if (attr.methodName == null)
+						return null;
+					return AccessTools.DeclaredProperty(attr.declaringType, attr.methodName).GetSetMethod(true);
+
+				case MethodType.Constructor:
+					return AccessTools.DeclaredConstructor(attr.declaringType, attr.argumentTypes);
+
+				case MethodType.StaticConstructor:
+					return AccessTools.GetDeclaredConstructors(attr.declaringType)
+						.Where(c => c.IsStatic)
+						.FirstOrDefault();
+			}
+
+			return null;
+		}
+
+		T RunMethod<S, T>(T defaultIfNotExisting, params object[] parameters)
+		{
+			if (container == null)
+				return defaultIfNotExisting;
+
+			var methodName = typeof(S).Name.Replace("Harmony", "");
+
+			var paramList = new List<object> { instance };
+			paramList.AddRange(parameters);
+			var paramTypes = AccessTools.GetTypes(paramList.ToArray());
+			var method = PatchTools.GetPatchMethod<S>(container, methodName, paramTypes);
+			if (method != null && typeof(T).IsAssignableFrom(method.ReturnType))
+				return (T)method.Invoke(null, paramList.ToArray());
+
+			method = PatchTools.GetPatchMethod<S>(container, methodName, new Type[] { typeof(HarmonyInstance) });
+			if (method != null && typeof(T).IsAssignableFrom(method.ReturnType))
+				return (T)method.Invoke(null, new object[] { instance });
+
+			method = PatchTools.GetPatchMethod<S>(container, methodName, Type.EmptyTypes);
+			if (method != null)
+			{
+				if (typeof(T).IsAssignableFrom(method.ReturnType))
+					return (T)method.Invoke(null, Type.EmptyTypes);
+
+				method.Invoke(null, Type.EmptyTypes);
+				return defaultIfNotExisting;
+			}
+
+			return defaultIfNotExisting;
+		}
+
+		void RunMethod<S>(params object[] parameters)
+		{
+			if (container == null)
+				return;
+
+			var methodName = typeof(S).Name.Replace("Harmony", "");
+
+			var paramList = new List<object> { instance };
+			paramList.AddRange(parameters);
+			var paramTypes = AccessTools.GetTypes(paramList.ToArray());
+			var method = PatchTools.GetPatchMethod<S>(container, methodName, paramTypes);
+			if (method != null)
+			{
+				method.Invoke(null, paramList.ToArray());
+				return;
+			}
+
+			method = PatchTools.GetPatchMethod<S>(container, methodName, new Type[] { typeof(HarmonyInstance) });
+			if (method != null)
+			{
+				method.Invoke(null, new object[] { instance });
+				return;
+			}
+
+			method = PatchTools.GetPatchMethod<S>(container, methodName, Type.EmptyTypes);
+			if (method != null)
+			{
+				method.Invoke(null, Type.EmptyTypes);
+				return;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Priority.cs b/src/Harmony/Priority.cs
new file mode 100644
index 00000000..55f98c3b
--- /dev/null
+++ b/src/Harmony/Priority.cs
@@ -0,0 +1,15 @@
+namespace Harmony
+{
+	public static class Priority
+	{
+		public const int Last = 0;
+		public const int VeryLow = 100;
+		public const int Low = 200;
+		public const int LowerThanNormal = 300;
+		public const int Normal = 400;
+		public const int HigherThanNormal = 500;
+		public const int High = 600;
+		public const int VeryHigh = 700;
+		public const int First = 800;
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/AccessCache.cs b/src/Harmony/Tools/AccessCache.cs
new file mode 100644
index 00000000..a5b769cd
--- /dev/null
+++ b/src/Harmony/Tools/AccessCache.cs
@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Harmony
+{
+	public class AccessCache
+	{
+		Dictionary<Type, Dictionary<string, FieldInfo>> fields = new Dictionary<Type, Dictionary<string, FieldInfo>>();
+		Dictionary<Type, Dictionary<string, PropertyInfo>> properties = new Dictionary<Type, Dictionary<string, PropertyInfo>>();
+		readonly Dictionary<Type, Dictionary<string, Dictionary<int, MethodBase>>> methods = new Dictionary<Type, Dictionary<string, Dictionary<int, MethodBase>>>();
+
+		[UpgradeToLatestVersion(1)]
+		public FieldInfo GetFieldInfo(Type type, string name)
+		{
+			Dictionary<string, FieldInfo> fieldsByType = null;
+			if (fields.TryGetValue(type, out fieldsByType) == false)
+			{
+				fieldsByType = new Dictionary<string, FieldInfo>();
+				fields.Add(type, fieldsByType);
+			}
+
+			FieldInfo field = null;
+			if (fieldsByType.TryGetValue(name, out field) == false)
+			{
+				field = AccessTools.Field(type, name);
+				fieldsByType.Add(name, field);
+			}
+			return field;
+		}
+
+		public PropertyInfo GetPropertyInfo(Type type, string name)
+		{
+			Dictionary<string, PropertyInfo> propertiesByType = null;
+			if (properties.TryGetValue(type, out propertiesByType) == false)
+			{
+				propertiesByType = new Dictionary<string, PropertyInfo>();
+				properties.Add(type, propertiesByType);
+			}
+
+			PropertyInfo property = null;
+			if (propertiesByType.TryGetValue(name, out property) == false)
+			{
+				property = AccessTools.Property(type, name);
+				propertiesByType.Add(name, property);
+			}
+			return property;
+		}
+
+		static int CombinedHashCode(IEnumerable<object> objects)
+		{
+			var hash1 = (5381 << 16) + 5381;
+			var hash2 = hash1;
+			var i = 0;
+			foreach (var obj in objects)
+			{
+				if (i % 2 == 0)
+					hash1 = ((hash1 << 5) + hash1 + (hash1 >> 27)) ^ obj.GetHashCode();
+				else
+					hash2 = ((hash2 << 5) + hash2 + (hash2 >> 27)) ^ obj.GetHashCode();
+				++i;
+			}
+			return hash1 + (hash2 * 1566083941);
+		}
+
+		public MethodBase GetMethodInfo(Type type, string name, Type[] arguments)
+		{
+			Dictionary<string, Dictionary<int, MethodBase>> methodsByName = null;
+			methods.TryGetValue(type, out methodsByName);
+			if (methodsByName == null)
+			{
+				methodsByName = new Dictionary<string, Dictionary<int, MethodBase>>();
+				methods.Add(type, methodsByName);
+			}
+
+			Dictionary<int, MethodBase> methodsByArguments = null;
+			methodsByName.TryGetValue(name, out methodsByArguments);
+			if (methodsByArguments == null)
+			{
+				methodsByArguments = new Dictionary<int, MethodBase>();
+				methodsByName.Add(name, methodsByArguments);
+			}
+
+			MethodBase method = null;
+			var argumentsHash = CombinedHashCode(arguments);
+			methodsByArguments.TryGetValue(argumentsHash, out method);
+			if (method == null)
+			{
+				method = AccessTools.Method(type, name, arguments);
+				methodsByArguments.Add(argumentsHash, method);
+			}
+
+			return method;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/AccessTools.cs b/src/Harmony/Tools/AccessTools.cs
new file mode 100644
index 00000000..a2e9a461
--- /dev/null
+++ b/src/Harmony/Tools/AccessTools.cs
@@ -0,0 +1,398 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.Serialization;
+
+namespace Harmony
+{
+	public static class AccessTools
+	{
+		public static BindingFlags all = BindingFlags.Public
+			| BindingFlags.NonPublic
+			| BindingFlags.Instance
+			| BindingFlags.Static
+			| BindingFlags.GetField
+			| BindingFlags.SetField
+			| BindingFlags.GetProperty
+			| BindingFlags.SetProperty;
+
+		public static Type TypeByName(string name)
+		{
+			var type = Type.GetType(name, false);
+			if (type == null)
+				type = AppDomain.CurrentDomain.GetAssemblies()
+					.SelectMany(x => x.GetTypes())
+					.FirstOrDefault(x => x.FullName == name);
+			if (type == null)
+				type = AppDomain.CurrentDomain.GetAssemblies()
+					.SelectMany(x => x.GetTypes())
+					.FirstOrDefault(x => x.Name == name);
+			return type;
+		}
+
+		public static T FindIncludingBaseTypes<T>(Type type, Func<Type, T> action)
+		{
+			while (true)
+			{
+				var result = action(type);
+				if (result != null) return result;
+				if (type == typeof(object)) return default(T);
+				type = type.BaseType;
+			}
+		}
+
+		public static T FindIncludingInnerTypes<T>(Type type, Func<Type, T> action)
+		{
+			var result = action(type);
+			if (result != null) return result;
+			foreach (var subType in type.GetNestedTypes(all))
+			{
+				result = FindIncludingInnerTypes(subType, action);
+				if (result != null)
+					break;
+			}
+			return result;
+		}
+
+		public static FieldInfo Field(Type type, string name)
+		{
+			if (type == null || name == null) return null;
+			return FindIncludingBaseTypes(type, t => t.GetField(name, all));
+		}
+
+		public static FieldInfo Field(Type type, int idx)
+		{
+			return GetDeclaredFields(type).ElementAtOrDefault(idx);
+		}
+
+		public static PropertyInfo DeclaredProperty(Type type, string name)
+		{
+			if (type == null || name == null) return null;
+			return type.GetProperty(name, all);
+		}
+
+		public static PropertyInfo Property(Type type, string name)
+		{
+			if (type == null || name == null) return null;
+			return FindIncludingBaseTypes(type, t => t.GetProperty(name, all));
+		}
+
+		public static MethodInfo DeclaredMethod(Type type, string name, Type[] parameters = null, Type[] generics = null)
+		{
+			if (type == null || name == null) return null;
+			MethodInfo result;
+			var modifiers = new ParameterModifier[] { };
+
+			if (parameters == null)
+				result = type.GetMethod(name, all);
+			else
+				result = type.GetMethod(name, all, null, parameters, modifiers);
+
+			if (result == null) return null;
+			if (generics != null) result = result.MakeGenericMethod(generics);
+			return result;
+		}
+
+		public static MethodInfo Method(Type type, string name, Type[] parameters = null, Type[] generics = null)
+		{
+			if (type == null || name == null) return null;
+			MethodInfo result;
+			var modifiers = new ParameterModifier[] { };
+			if (parameters == null)
+			{
+				try
+				{
+					result = FindIncludingBaseTypes(type, t => t.GetMethod(name, all));
+				}
+				catch (AmbiguousMatchException)
+				{
+					result = FindIncludingBaseTypes(type, t => t.GetMethod(name, all, null, new Type[0], modifiers));
+				}
+			}
+			else
+			{
+				result = FindIncludingBaseTypes(type, t => t.GetMethod(name, all, null, parameters, modifiers));
+			}
+			if (result == null) return null;
+			if (generics != null) result = result.MakeGenericMethod(generics);
+			return result;
+		}
+
+		public static MethodInfo Method(string typeColonMethodname, Type[] parameters = null, Type[] generics = null)
+		{
+			if (typeColonMethodname == null) return null;
+			var parts = typeColonMethodname.Split(':');
+			if (parts.Length != 2)
+				throw new ArgumentException("Method must be specified as 'Namespace.Type1.Type2:MethodName", nameof(typeColonMethodname));
+
+			var type = TypeByName(parts[0]);
+			return Method(type, parts[1], parameters, generics);
+		}
+
+		public static List<string> GetMethodNames(Type type)
+		{
+			if (type == null) return new List<string>();
+			return type.GetMethods(all).Select(m => m.Name).ToList();
+		}
+
+		public static List<string> GetMethodNames(object instance)
+		{
+			if (instance == null) return new List<string>();
+			return GetMethodNames(instance.GetType());
+		}
+
+		public static ConstructorInfo DeclaredConstructor(Type type, Type[] parameters = null)
+		{
+			if (type == null) return null;
+			if (parameters == null) parameters = new Type[0];
+			return type.GetConstructor(all, null, parameters, new ParameterModifier[] { });
+		}
+
+		public static ConstructorInfo Constructor(Type type, Type[] parameters = null)
+		{
+			if (type == null) return null;
+			if (parameters == null) parameters = new Type[0];
+			return FindIncludingBaseTypes(type, t => t.GetConstructor(all, null, parameters, new ParameterModifier[] { }));
+		}
+
+		public static List<ConstructorInfo> GetDeclaredConstructors(Type type)
+		{
+			return type.GetConstructors(all).Where(method => method.DeclaringType == type).ToList();
+		}
+
+		public static List<MethodInfo> GetDeclaredMethods(Type type)
+		{
+			return type.GetMethods(all).Where(method => method.DeclaringType == type).ToList();
+		}
+
+		public static List<PropertyInfo> GetDeclaredProperties(Type type)
+		{
+			return type.GetProperties(all).Where(property => property.DeclaringType == type).ToList();
+		}
+
+		public static List<FieldInfo> GetDeclaredFields(Type type)
+		{
+			return type.GetFields(all).Where(field => field.DeclaringType == type).ToList();
+		}
+
+		public static Type GetReturnedType(MethodBase method)
+		{
+			var constructor = method as ConstructorInfo;
+			if (constructor != null) return typeof(void);
+			return ((MethodInfo)method).ReturnType;
+		}
+
+		public static Type Inner(Type type, string name)
+		{
+			if (type == null || name == null) return null;
+			return FindIncludingBaseTypes(type, t => t.GetNestedType(name, all));
+		}
+
+		public static Type FirstInner(Type type, Func<Type, bool> predicate)
+		{
+			if (type == null || predicate == null) return null;
+			return type.GetNestedTypes(all).FirstOrDefault(subType => predicate(subType));
+		}
+
+		public static MethodInfo FirstMethod(Type type, Func<MethodInfo, bool> predicate)
+		{
+			if (type == null || predicate == null) return null;
+			return type.GetMethods(all).FirstOrDefault(method => predicate(method));
+		}
+
+		public static ConstructorInfo FirstConstructor(Type type, Func<ConstructorInfo, bool> predicate)
+		{
+			if (type == null || predicate == null) return null;
+			return type.GetConstructors(all).FirstOrDefault(constructor => predicate(constructor));
+		}
+
+		public static PropertyInfo FirstProperty(Type type, Func<PropertyInfo, bool> predicate)
+		{
+			if (type == null || predicate == null) return null;
+			return type.GetProperties(all).FirstOrDefault(property => predicate(property));
+		}
+
+		public static Type[] GetTypes(object[] parameters)
+		{
+			if (parameters == null) return new Type[0];
+			return parameters.Select(p => p == null ? typeof(object) : p.GetType()).ToArray();
+		}
+
+		public static List<string> GetFieldNames(Type type)
+		{
+			if (type == null) return new List<string>();
+			return type.GetFields(all).Select(f => f.Name).ToList();
+		}
+
+		public static List<string> GetFieldNames(object instance)
+		{
+			if (instance == null) return new List<string>();
+			return GetFieldNames(instance.GetType());
+		}
+
+		public static List<string> GetPropertyNames(Type type)
+		{
+			if (type == null) return new List<string>();
+			return type.GetProperties(all).Select(f => f.Name).ToList();
+		}
+
+		public static List<string> GetPropertyNames(object instance)
+		{
+			if (instance == null) return new List<string>();
+			return GetPropertyNames(instance.GetType());
+		}
+
+		public delegate ref U FieldRef<T, U>(T obj);
+		public static FieldRef<T, U> FieldRefAccess<T, U>(string fieldName)
+		{
+			const BindingFlags bf = BindingFlags.NonPublic |
+											BindingFlags.Instance |
+											BindingFlags.DeclaredOnly;
+
+			var fi = typeof(T).GetField(fieldName, bf);
+			if (fi == null)
+				throw new MissingFieldException(typeof(T).Name, fieldName);
+
+			var s_name = "__refget_" + typeof(T).Name + "_fi_" + fi.Name;
+
+			// workaround for using ref-return with DynamicMethod:
+			// a.) initialize with dummy return value
+			var dm = new DynamicMethod(s_name, typeof(U), new[] { typeof(T) }, typeof(T), true);
+
+			// b.) replace with desired 'ByRef' return value
+			var trv = Traverse.Create(dm);
+			trv.Field("returnType").SetValue(typeof(U).MakeByRefType());
+			trv.Field("m_returnType").SetValue(typeof(U).MakeByRefType());
+
+			var il = dm.GetILGenerator();
+			il.Emit(OpCodes.Ldarg_0);
+			il.Emit(OpCodes.Ldflda, fi);
+			il.Emit(OpCodes.Ret);
+			return (FieldRef<T, U>)dm.CreateDelegate(typeof(FieldRef<T, U>));
+		}
+
+		public static ref U FieldRefAccess<T, U>(T instance, string fieldName)
+		{
+			return ref FieldRefAccess<T, U>(fieldName)(instance);
+		}
+
+		public static void ThrowMissingMemberException(Type type, params string[] names)
+		{
+			var fields = string.Join(",", GetFieldNames(type).ToArray());
+			var properties = string.Join(",", GetPropertyNames(type).ToArray());
+			throw new MissingMemberException(string.Join(",", names) + "; available fields: " + fields + "; available properties: " + properties);
+		}
+
+		public static object GetDefaultValue(Type type)
+		{
+			if (type == null) return null;
+			if (type == typeof(void)) return null;
+			if (type.IsValueType)
+				return Activator.CreateInstance(type);
+			return null;
+		}
+
+		public static object CreateInstance(Type type)
+		{
+			if (type == null)
+				throw new NullReferenceException("Cannot create instance for NULL type");
+			var ctor = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, CallingConventions.Any, new Type[0], null);
+			if (ctor != null)
+				return Activator.CreateInstance(type);
+			return FormatterServices.GetUninitializedObject(type);
+		}
+
+		public static object MakeDeepCopy(object source, Type resultType, Func<string, Traverse, Traverse, object> processor = null, string pathRoot = "")
+		{
+			if (source == null)
+				return null;
+
+			var type = source.GetType();
+
+			if (type.IsPrimitive)
+				return source;
+
+			if (type.IsEnum)
+				return Enum.ToObject(resultType, (int)source);
+
+			if (type.IsGenericType && resultType.IsGenericType)
+			{
+				var addOperation = FirstMethod(resultType, m => m.Name == "Add" && m.GetParameters().Count() == 1);
+				if (addOperation != null)
+				{
+					var addableResult = Activator.CreateInstance(resultType);
+					var addInvoker = MethodInvoker.GetHandler(addOperation);
+					var newElementType = resultType.GetGenericArguments()[0];
+					var i = 0;
+					foreach (var element in source as IEnumerable)
+					{
+						var iStr = (i++).ToString();
+						var path = pathRoot.Length > 0 ? pathRoot + "." + iStr : iStr;
+						var newElement = MakeDeepCopy(element, newElementType, processor, path);
+						addInvoker(addableResult, new object[] { newElement });
+					}
+					return addableResult;
+				}
+
+				// TODO: add dictionaries support
+				// maybe use methods in Dictionary<KeyValuePair<TKey,TVal>>
+			}
+
+			if (type.IsArray && resultType.IsArray)
+			{
+				var elementType = resultType.GetElementType();
+				var length = ((Array)source).Length;
+				var arrayResult = Activator.CreateInstance(resultType, new object[] { length }) as object[];
+				var originalArray = source as object[];
+				for (var i = 0; i < length; i++)
+				{
+					var iStr = i.ToString();
+					var path = pathRoot.Length > 0 ? pathRoot + "." + iStr : iStr;
+					arrayResult[i] = MakeDeepCopy(originalArray[i], elementType, processor, path);
+				}
+				return arrayResult;
+			}
+
+			var ns = type.Namespace;
+			if (ns == "System" || (ns?.StartsWith("System.") ?? false))
+				return source;
+
+			var result = CreateInstance(resultType);
+			Traverse.IterateFields(source, result, (name, src, dst) =>
+			{
+				var path = pathRoot.Length > 0 ? pathRoot + "." + name : name;
+				var value = processor != null ? processor(path, src, dst) : src.GetValue();
+				dst.SetValue(MakeDeepCopy(value, dst.GetValueType(), processor, path));
+			});
+			return result;
+		}
+
+		public static void MakeDeepCopy<T>(object source, out T result, Func<string, Traverse, Traverse, object> processor = null, string pathRoot = "")
+		{
+			result = (T)MakeDeepCopy(source, typeof(T), processor, pathRoot);
+		}
+
+		public static bool IsStruct(Type type)
+		{
+			return type.IsValueType && !IsValue(type) && !IsVoid(type);
+		}
+
+		public static bool IsClass(Type type)
+		{
+			return !type.IsValueType;
+		}
+
+		public static bool IsValue(Type type)
+		{
+			return type.IsPrimitive || type.IsEnum;
+		}
+
+		public static bool IsVoid(Type type)
+		{
+			return type == typeof(void);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/DynamicTools.cs b/src/Harmony/Tools/DynamicTools.cs
new file mode 100644
index 00000000..745581cf
--- /dev/null
+++ b/src/Harmony/Tools/DynamicTools.cs
@@ -0,0 +1,226 @@
+using Harmony.ILCopying;
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+
+namespace Harmony
+{
+	public static class DynamicTools
+	{
+		/* TODO add support for functions that return structs larger than 8 bytes
+		 *
+		 * https://github.com/dotnet/coreclr/issues/12503
+		 * https://stackoverflow.com/questions/44641195/what-could-cause-p-invoke-arguments-to-be-out-of-order-when-passed
+		 *
+		 * ERROR
+		 * Managed Debugging Assistant 'FatalExecutionEngineError' 
+		 * The runtime has encountered a fatal error. The address of the error was at 0x72747d0e, on thread 0x9c38. The error code is 0xc0000005. This error may be a bug in the CLR or in the unsafe or non-verifiable portions of user code. Common sources of this bug include user marshaling errors for COM-interop or PInvoke, which may corrupt the stack.
+		 *
+		 * Calling signatures change:
+		 * .NET <4.5 jits to void Func(ref LargeReturnStruct, object this, params)
+		 * .NET 4.5+ jits to Func(object this, ref LargeReturnStruct, params)
+		 * 
+		 * // Test case
+
+			[StructLayout(LayoutKind.Sequential, Pack = 8)]
+			public struct Struct1
+			{
+				 public double foo;
+				 public double bar;
+			}
+
+			public class StructTest1
+			{
+				public Struct1 PatchMe()
+				{
+					return default(Struct1);
+				}
+			}
+		 * 
+		 */
+		public static DynamicMethod CreateDynamicMethod(MethodBase original, string suffix)
+		{
+			if (original == null) throw new ArgumentNullException("original cannot be null");
+			var patchName = original.Name + suffix;
+			patchName = patchName.Replace("<>", "");
+
+			var parameters = original.GetParameters();
+			var result = parameters.Types().ToList();
+			if (original.IsStatic == false)
+				result.Insert(0, typeof(object));
+			var paramTypes = result.ToArray();
+			var returnType = AccessTools.GetReturnedType(original);
+
+			// DynamicMethod does not support byref return types
+			if (returnType == null || returnType.IsByRef)
+				return null;
+
+			DynamicMethod method;
+			try
+			{
+				method = new DynamicMethod(
+				patchName,
+				MethodAttributes.Public | MethodAttributes.Static,
+				CallingConventions.Standard,
+				returnType,
+				paramTypes,
+				original.DeclaringType,
+				true
+			);
+			}
+			catch (Exception)
+			{
+				return null;
+			}
+
+			for (var i = 0; i < parameters.Length; i++)
+				method.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
+
+			return method;
+		}
+
+		public static ILGenerator CreateSaveableMethod(MethodBase original, string suffix, out AssemblyBuilder assemblyBuilder, out TypeBuilder typeBuilder)
+		{
+			var assemblyName = new AssemblyName("DebugAssembly");
+			var path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
+			assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave, path);
+			var moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
+			typeBuilder = moduleBuilder.DefineType("Debug" + original.DeclaringType.Name, TypeAttributes.Public);
+
+			if (original == null) throw new ArgumentNullException("original cannot be null");
+			var patchName = original.Name + suffix;
+			patchName = patchName.Replace("<>", "");
+
+			var parameters = original.GetParameters();
+			var result = parameters.Types().ToList();
+			if (original.IsStatic == false)
+				result.Insert(0, typeof(object));
+			var paramTypes = result.ToArray();
+
+			var methodBuilder = typeBuilder.DefineMethod(
+				patchName,
+				MethodAttributes.Public | MethodAttributes.Static,
+				CallingConventions.Standard,
+				AccessTools.GetReturnedType(original),
+				paramTypes
+			);
+
+			return methodBuilder.GetILGenerator();
+		}
+
+		public static void SaveMethod(AssemblyBuilder assemblyBuilder, TypeBuilder typeBuilder)
+		{
+			var t = typeBuilder.CreateType();
+			assemblyBuilder.Save("HarmonyDebugAssembly.dll");
+		}
+
+		public static LocalBuilder[] DeclareLocalVariables(MethodBase original, ILGenerator il, bool logOutput = true)
+		{
+			var vars = original.GetMethodBody()?.LocalVariables;
+			if (vars == null)
+				return new LocalBuilder[0];
+			return vars.Select(lvi =>
+			{
+				var localBuilder = il.DeclareLocal(lvi.LocalType, lvi.IsPinned);
+				if (logOutput)
+					Emitter.LogLocalVariable(il, localBuilder);
+				return localBuilder;
+			}).ToArray();
+		}
+
+		public static LocalBuilder DeclareLocalVariable(ILGenerator il, Type type)
+		{
+			if (type.IsByRef) type = type.GetElementType();
+
+			if (AccessTools.IsClass(type))
+			{
+				var v = il.DeclareLocal(type);
+				Emitter.LogLocalVariable(il, v);
+				Emitter.Emit(il, OpCodes.Ldnull);
+				Emitter.Emit(il, OpCodes.Stloc, v);
+				return v;
+			}
+			if (AccessTools.IsStruct(type))
+			{
+				var v = il.DeclareLocal(type);
+				Emitter.LogLocalVariable(il, v);
+				Emitter.Emit(il, OpCodes.Ldloca, v);
+				Emitter.Emit(il, OpCodes.Initobj, type);
+				return v;
+			}
+			if (AccessTools.IsValue(type))
+			{
+				var v = il.DeclareLocal(type);
+				Emitter.LogLocalVariable(il, v);
+				if (type == typeof(float))
+					Emitter.Emit(il, OpCodes.Ldc_R4, (float)0);
+				else if (type == typeof(double))
+					Emitter.Emit(il, OpCodes.Ldc_R8, (double)0);
+				else if (type == typeof(long))
+					Emitter.Emit(il, OpCodes.Ldc_I8, (long)0);
+				else
+					Emitter.Emit(il, OpCodes.Ldc_I4, 0);
+				Emitter.Emit(il, OpCodes.Stloc, v);
+				return v;
+			}
+			return null;
+		}
+
+		public static void PrepareDynamicMethod(DynamicMethod method)
+		{
+			var nonPublicInstance = BindingFlags.NonPublic | BindingFlags.Instance;
+			var nonPublicStatic = BindingFlags.NonPublic | BindingFlags.Static;
+
+			// on mono, just call 'CreateDynMethod'
+			//
+			var m_CreateDynMethod = typeof(DynamicMethod).GetMethod("CreateDynMethod", nonPublicInstance);
+			if (m_CreateDynMethod != null)
+			{
+				m_CreateDynMethod.Invoke(method, new object[0]);
+				return;
+			}
+
+			// on all .NET Core versions, call 'RuntimeHelpers._CompileMethod' but with a different parameter:
+			//
+			var m__CompileMethod = typeof(RuntimeHelpers).GetMethod("_CompileMethod", nonPublicStatic);
+
+			var m_GetMethodDescriptor = typeof(DynamicMethod).GetMethod("GetMethodDescriptor", nonPublicInstance);
+			var handle = (RuntimeMethodHandle)m_GetMethodDescriptor.Invoke(method, new object[0]);
+
+			// 1) RuntimeHelpers._CompileMethod(handle.GetMethodInfo())
+			//
+			var m_GetMethodInfo = typeof(RuntimeMethodHandle).GetMethod("GetMethodInfo", nonPublicInstance);
+			if (m_GetMethodInfo != null)
+			{
+				var runtimeMethodInfo = m_GetMethodInfo.Invoke(handle, new object[0]);
+				try
+				{
+					// this can throw BadImageFormatException "An attempt was made to load a program with an incorrect format"
+					m__CompileMethod.Invoke(null, new object[] { runtimeMethodInfo });
+					return;
+				}
+				catch (Exception)
+				{
+				}
+			}
+
+			// 2) RuntimeHelpers._CompileMethod(handle.Value)
+			//
+			if (m__CompileMethod.GetParameters()[0].ParameterType.IsAssignableFrom(handle.Value.GetType()))
+			{
+				m__CompileMethod.Invoke(null, new object[] { handle.Value });
+				return;
+			}
+
+			// 3) RuntimeHelpers._CompileMethod(handle)
+			//
+			if (m__CompileMethod.GetParameters()[0].ParameterType.IsAssignableFrom(handle.GetType()))
+			{
+				m__CompileMethod.Invoke(null, new object[] { handle });
+				return;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/Extensions.cs b/src/Harmony/Tools/Extensions.cs
new file mode 100644
index 00000000..f52491c2
--- /dev/null
+++ b/src/Harmony/Tools/Extensions.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace Harmony
+{
+	public static class GeneralExtensions
+	{
+		public static string Join<T>(this IEnumerable<T> enumeration, Func<T, string> converter = null, string delimiter = ", ")
+		{
+			if (converter == null) converter = t => t.ToString();
+			return enumeration.Aggregate("", (prev, curr) => prev + (prev != "" ? delimiter : "") + converter(curr));
+		}
+
+		public static string Description(this Type[] parameters)
+		{
+			if (parameters == null) return "NULL";
+			var pattern = @", \w+, Version=[0-9.]+, Culture=neutral, PublicKeyToken=[0-9a-f]+";
+			return "(" + parameters.Join(p => p?.FullName == null ? "null" : Regex.Replace(p.FullName, pattern, "")) + ")";
+		}
+
+		public static string FullDescription(this MethodBase method)
+		{
+			var parameters = method.GetParameters().Select(p => p.ParameterType).ToArray();
+			return method.DeclaringType.FullName + "." + method.Name + parameters.Description();
+		}
+
+		public static Type[] Types(this ParameterInfo[] pinfo)
+		{
+			return pinfo.Select(pi => pi.ParameterType).ToArray();
+		}
+
+		public static T GetValueSafe<S, T>(this Dictionary<S, T> dictionary, S key)
+		{
+			T result;
+			if (dictionary.TryGetValue(key, out result))
+				return result;
+			return default(T);
+		}
+
+		public static T GetTypedValue<T>(this Dictionary<string, object> dictionary, string key)
+		{
+			object result;
+			if (dictionary.TryGetValue(key, out result))
+				if (result is T)
+					return (T)result;
+			return default(T);
+		}
+	}
+
+	public static class CollectionExtensions
+	{
+		public static void Do<T>(this IEnumerable<T> sequence, Action<T> action)
+		{
+			if (sequence == null) return;
+			var enumerator = sequence.GetEnumerator();
+			while (enumerator.MoveNext()) action(enumerator.Current);
+		}
+
+		public static void DoIf<T>(this IEnumerable<T> sequence, Func<T, bool> condition, Action<T> action)
+		{
+			sequence.Where(condition).Do(action);
+		}
+
+		public static IEnumerable<T> Add<T>(this IEnumerable<T> sequence, T item)
+		{
+			return (sequence ?? Enumerable.Empty<T>()).Concat(new[] { item });
+		}
+
+		public static T[] AddRangeToArray<T>(this T[] sequence, T[] items)
+		{
+			return (sequence ?? Enumerable.Empty<T>()).Concat(items).ToArray();
+		}
+
+		public static T[] AddToArray<T>(this T[] sequence, T item)
+		{
+			return Add(sequence, item).ToArray();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/FileLog.cs b/src/Harmony/Tools/FileLog.cs
new file mode 100644
index 00000000..16596762
--- /dev/null
+++ b/src/Harmony/Tools/FileLog.cs
@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Harmony
+{
+	public static class FileLog
+	{
+		public static string logPath;
+		public static char indentChar = '\t';
+		public static int indentLevel = 0;
+		static List<string> buffer = new List<string>();
+
+		[UpgradeToLatestVersion(1)]
+		static FileLog()
+		{
+			logPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + Path.DirectorySeparatorChar + "harmony.log.txt";
+		}
+
+		static string IndentString()
+		{
+			return new string(indentChar, indentLevel);
+		}
+
+		public static void ChangeIndent(int delta)
+		{
+			indentLevel = Math.Max(0, indentLevel + delta);
+		}
+
+		// use this method only if you are sure that FlushBuffer will be called
+		// or else logging information is incomplete in case of a crash
+		//
+		public static void LogBuffered(string str)
+		{
+			lock (logPath)
+			{
+				buffer.Add(IndentString() + str);
+			}
+		}
+
+		public static void FlushBuffer()
+		{
+			lock (logPath)
+			{
+				if (buffer.Count > 0)
+				{
+					using (var writer = File.AppendText(logPath))
+					{
+						foreach (var str in buffer)
+							writer.WriteLine(str);
+					}
+					buffer.Clear();
+				}
+			}
+		}
+
+		// this is the slower method that flushes changes directly to the file
+		// to prevent missing information in case of a cache
+		//
+		public static void Log(string str)
+		{
+			lock (logPath)
+			{
+				using (var writer = File.AppendText(logPath))
+				{
+					writer.WriteLine(IndentString() + str);
+				}
+			}
+		}
+
+		public static void Reset()
+		{
+			lock (logPath)
+			{
+				var path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + Path.DirectorySeparatorChar + "harmony.log.txt";
+				File.Delete(path);
+			}
+		}
+
+		public static unsafe void LogBytes(long ptr, int len)
+		{
+			lock (logPath)
+			{
+				var p = (byte*)ptr;
+				var s = "";
+				for (var i = 1; i <= len; i++)
+				{
+					if (s == "") s = "#  ";
+					s = s + (*p).ToString("X2") + " ";
+					if (i > 1 || len == 1)
+					{
+						if (i % 8 == 0 || i == len)
+						{
+							Log(s);
+							s = "";
+						}
+						else if (i % 4 == 0)
+							s = s + " ";
+					}
+					p++;
+				}
+
+				var arr = new byte[len];
+				Marshal.Copy((IntPtr)ptr, arr, 0, len);
+				var md5Hash = MD5.Create();
+				var hash = md5Hash.ComputeHash(arr);
+#pragma warning disable XS0001
+				var sBuilder = new StringBuilder();
+#pragma warning restore XS0001
+				for (var i = 0; i < hash.Length; i++)
+					sBuilder.Append(hash[i].ToString("X2"));
+				Log("HASH: " + sBuilder);
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/PatchTools.cs b/src/Harmony/Tools/PatchTools.cs
new file mode 100644
index 00000000..8d374dd1
--- /dev/null
+++ b/src/Harmony/Tools/PatchTools.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace Harmony
+{
+	public static class PatchTools
+	{
+		// this holds all the objects we want to keep alive so they don't get garbage-collected
+		static Dictionary<object, object> objectReferences = new Dictionary<object, object>();
+		public static void RememberObject(object key, object value)
+		{
+			objectReferences[key] = value;
+		}
+
+		public static MethodInfo GetPatchMethod<T>(Type patchType, string name, Type[] parameters = null)
+		{
+			var method = patchType.GetMethods(AccessTools.all)
+				.FirstOrDefault(m => m.GetCustomAttributes(typeof(T), true).Any());
+			if (method == null)
+				method = AccessTools.Method(patchType, name, parameters);
+			return method;
+		}
+
+		public static void GetPatches(Type patchType, out MethodInfo prefix, out MethodInfo postfix, out MethodInfo transpiler)
+		{
+			prefix = GetPatchMethod<HarmonyPrefix>(patchType, "Prefix");
+			postfix = GetPatchMethod<HarmonyPostfix>(patchType, "Postfix");
+			transpiler = GetPatchMethod<HarmonyTranspiler>(patchType, "Transpiler");
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/SelfPatching.cs b/src/Harmony/Tools/SelfPatching.cs
new file mode 100644
index 00000000..b586d683
--- /dev/null
+++ b/src/Harmony/Tools/SelfPatching.cs
@@ -0,0 +1,134 @@
+using Harmony.ILCopying;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+namespace Harmony.Tools
+{
+	internal class SelfPatching
+	{
+		static readonly int upgradeToLatestVersionFullNameHash = typeof(UpgradeToLatestVersion).FullName.GetHashCode();
+
+		[UpgradeToLatestVersion(1)]
+		static int GetVersion(MethodBase method)
+		{
+			var attribute = method.GetCustomAttributes(false)
+				.Where(attr => attr.GetType().FullName.GetHashCode() == upgradeToLatestVersionFullNameHash)
+				.FirstOrDefault();
+			if (attribute == null)
+				return -1;
+			return Traverse.Create(attribute).Field("version").GetValue<int>();
+		}
+
+		[UpgradeToLatestVersion(1)]
+		static string MethodKey(MethodBase method)
+		{
+			return method.FullDescription();
+		}
+
+		[UpgradeToLatestVersion(1)]
+		static bool IsHarmonyAssembly(Assembly assembly)
+		{
+			try
+			{
+				return assembly.ReflectionOnly == false && assembly.GetType(typeof(HarmonyInstance).FullName) != null;
+			}
+			catch (Exception)
+			{
+				return false;
+			}
+		}
+
+		private static List<MethodBase> GetAllMethods(Assembly assembly)
+		{
+			var types = assembly.GetTypes();
+			return types
+				.SelectMany(type => type.GetMethods(AccessTools.all).Cast<MethodBase>())
+				.Concat(types.SelectMany(type => type.GetConstructors(AccessTools.all)).Cast<MethodBase>())
+				.Concat(types.SelectMany(type => type.GetProperties(AccessTools.all)).Select(prop => prop.GetGetMethod()).Cast<MethodBase>())
+				.Concat(types.SelectMany(type => type.GetProperties(AccessTools.all)).Select(prop => prop.GetSetMethod()).Cast<MethodBase>())
+				.Where(method => method != null && method.DeclaringType.Assembly == assembly)
+				.OrderBy(method => method.FullDescription())
+				.ToList();
+		}
+
+		private static string AssemblyInfo(Assembly assembly)
+		{
+			var version = assembly.GetName().Version;
+			var location = assembly.Location;
+			if (location == null || location == "") location = new Uri(assembly.CodeBase).LocalPath;
+			return location + "(v" + version + (assembly.GlobalAssemblyCache ? ", cached" : "") + ")";
+		}
+
+		[UpgradeToLatestVersion(1)]
+		public static void PatchOldHarmonyMethods()
+		{
+			var watch = new Stopwatch();
+			watch.Start();
+
+			var ourAssembly = new StackTrace(true).GetFrame(1).GetMethod().DeclaringType.Assembly;
+			if (HarmonyInstance.DEBUG)
+			{
+				var originalVersion = ourAssembly.GetName().Version;
+				var runningVersion = typeof(SelfPatching).Assembly.GetName().Version;
+				if (runningVersion > originalVersion)
+				{
+					// log start because FileLog has not done it
+					FileLog.Log("### Harmony v" + originalVersion + " started");
+					FileLog.Log("### Self-patching unnecessary because we are already patched by v" + runningVersion);
+					FileLog.Log("### At " + DateTime.Now.ToString("yyyy-MM-dd hh.mm.ss"));
+					return;
+				}
+				FileLog.Log("Self-patching started (v" + originalVersion + ")");
+			}
+
+			var potentialMethodsToUpgrade = new Dictionary<string, MethodBase>();
+			GetAllMethods(ourAssembly)
+				.Where(method => method != null && method.GetCustomAttributes(false).Any(attr => attr is UpgradeToLatestVersion))
+				.Do(method => potentialMethodsToUpgrade.Add(MethodKey(method), method));
+
+			var otherHarmonyAssemblies = AppDomain.CurrentDomain.GetAssemblies()
+					.Where(assembly => IsHarmonyAssembly(assembly) && assembly != ourAssembly)
+					.ToList();
+
+			if (HarmonyInstance.DEBUG)
+			{
+				otherHarmonyAssemblies.Do(assembly => FileLog.Log("Found Harmony " + AssemblyInfo(assembly)));
+
+				FileLog.Log("Potential methods to upgrade:");
+				potentialMethodsToUpgrade.Values.OrderBy(method => method.FullDescription()).Do(method => FileLog.Log("- " + method.FullDescription()));
+			}
+
+			var totalCounter = 0;
+			var potentialCounter = 0;
+			var patchedCounter = 0;
+			foreach (var assembly in otherHarmonyAssemblies)
+			{
+				foreach (var oldMethod in GetAllMethods(assembly))
+				{
+					totalCounter++;
+
+					if (potentialMethodsToUpgrade.TryGetValue(MethodKey(oldMethod), out var newMethod))
+					{
+						var newVersion = GetVersion(newMethod);
+						potentialCounter++;
+
+						var oldVersion = GetVersion(oldMethod);
+						if (oldVersion < newVersion)
+						{
+							if (HarmonyInstance.DEBUG)
+								FileLog.Log("Self-patching " + oldMethod.FullDescription() + " in " + AssemblyInfo(assembly));
+							patchedCounter++;
+							Memory.DetourMethod(oldMethod, newMethod);
+						}
+					}
+				}
+			}
+
+			if (HarmonyInstance.DEBUG)
+				FileLog.Log("Self-patched " + patchedCounter + " out of " + totalCounter + " methods (" + (potentialCounter - patchedCounter) + " skipped) in " + watch.ElapsedMilliseconds + "ms");
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/SymbolExtensions.cs b/src/Harmony/Tools/SymbolExtensions.cs
new file mode 100644
index 00000000..5e5ac801
--- /dev/null
+++ b/src/Harmony/Tools/SymbolExtensions.cs
@@ -0,0 +1,61 @@
+using System.Linq.Expressions;
+using System.Reflection;
+using System;
+
+namespace Harmony
+{
+	public static class SymbolExtensions
+	{
+		/// <summary>
+		/// Given a lambda expression that calls a method, returns the method info.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="expression">The expression.</param>
+		/// <returns></returns>
+		public static MethodInfo GetMethodInfo(Expression<Action> expression)
+		{
+			return GetMethodInfo((LambdaExpression)expression);
+		}
+
+		/// <summary>
+		/// Given a lambda expression that calls a method, returns the method info.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="expression">The expression.</param>
+		/// <returns></returns>
+		public static MethodInfo GetMethodInfo<T>(Expression<Action<T>> expression)
+		{
+			return GetMethodInfo((LambdaExpression)expression);
+		}
+
+		/// <summary>
+		/// Given a lambda expression that calls a method, returns the method info.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="expression">The expression.</param>
+		/// <returns></returns>
+		public static MethodInfo GetMethodInfo<T, TResult>(Expression<Func<T, TResult>> expression)
+		{
+			return GetMethodInfo((LambdaExpression)expression);
+		}
+
+		/// <summary>
+		/// Given a lambda expression that calls a method, returns the method info.
+		/// </summary>
+		/// <param name="expression">The expression.</param>
+		/// <returns></returns>
+		public static MethodInfo GetMethodInfo(LambdaExpression expression)
+		{
+			var outermostExpression = expression.Body as MethodCallExpression;
+
+			if (outermostExpression == null)
+				throw new ArgumentException("Invalid Expression. Expression should consist of a Method call only.");
+
+			var method = outermostExpression.Method;
+			if (method == null)
+				throw new Exception("Cannot find method for expression " + expression);
+
+			return method;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Tools/Traverse.cs b/src/Harmony/Tools/Traverse.cs
new file mode 100644
index 00000000..fc4afc65
--- /dev/null
+++ b/src/Harmony/Tools/Traverse.cs
@@ -0,0 +1,298 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Harmony
+{
+	public class Traverse<T>
+	{
+		private Traverse traverse;
+
+		Traverse()
+		{
+		}
+
+		public Traverse(Traverse traverse)
+		{
+			this.traverse = traverse;
+		}
+
+		public T Value
+		{
+			get => traverse.GetValue<T>();
+			set => traverse.SetValue(value);
+		}
+	}
+
+	public class Traverse
+	{
+		static AccessCache Cache;
+
+		Type _type;
+		object _root;
+		MemberInfo _info;
+		MethodBase _method;
+		object[] _params;
+
+		[MethodImpl(MethodImplOptions.Synchronized)]
+		static Traverse()
+		{
+			if (Cache == null)
+				Cache = new AccessCache();
+		}
+
+		public static Traverse Create(Type type)
+		{
+			return new Traverse(type);
+		}
+
+		public static Traverse Create<T>()
+		{
+			return Create(typeof(T));
+		}
+
+		public static Traverse Create(object root)
+		{
+			return new Traverse(root);
+		}
+
+		public static Traverse CreateWithType(string name)
+		{
+			return new Traverse(AccessTools.TypeByName(name));
+		}
+
+		Traverse()
+		{
+		}
+
+		public Traverse(Type type)
+		{
+			_type = type;
+		}
+
+		public Traverse(object root)
+		{
+			_root = root;
+			_type = root?.GetType();
+		}
+
+		Traverse(object root, MemberInfo info, object[] index)
+		{
+			_root = root;
+			_type = root?.GetType();
+			_info = info;
+			_params = index;
+		}
+
+		Traverse(object root, MethodInfo method, object[] parameter)
+		{
+			_root = root;
+			_type = method.ReturnType;
+			_method = method;
+			_params = parameter;
+		}
+
+		public object GetValue()
+		{
+			if (_info is FieldInfo)
+				return ((FieldInfo)_info).GetValue(_root);
+			if (_info is PropertyInfo)
+				return ((PropertyInfo)_info).GetValue(_root, AccessTools.all, null, _params, CultureInfo.CurrentCulture);
+			if (_method != null)
+				return _method.Invoke(_root, _params);
+			if (_root == null && _type != null) return _type;
+			return _root;
+		}
+
+		public T GetValue<T>()
+		{
+			var value = GetValue();
+			if (value == null) return default(T);
+			return (T)value;
+		}
+
+		public object GetValue(params object[] arguments)
+		{
+			if (_method == null)
+				throw new Exception("cannot get method value without method");
+			return _method.Invoke(_root, arguments);
+		}
+
+		public T GetValue<T>(params object[] arguments)
+		{
+			if (_method == null)
+				throw new Exception("cannot get method value without method");
+			return (T)_method.Invoke(_root, arguments);
+		}
+
+		public Traverse SetValue(object value)
+		{
+			if (_info is FieldInfo)
+				((FieldInfo)_info).SetValue(_root, value, AccessTools.all, null, CultureInfo.CurrentCulture);
+			if (_info is PropertyInfo)
+				((PropertyInfo)_info).SetValue(_root, value, AccessTools.all, null, _params, CultureInfo.CurrentCulture);
+			if (_method != null)
+				throw new Exception("cannot set value of method " + _method.FullDescription());
+			return this;
+		}
+
+		public Type GetValueType()
+		{
+			if (_info is FieldInfo)
+				return ((FieldInfo)_info).FieldType;
+			if (_info is PropertyInfo)
+				return ((PropertyInfo)_info).PropertyType;
+			return null;
+		}
+
+		Traverse Resolve()
+		{
+			if (_root == null && _type != null) return this;
+			return new Traverse(GetValue());
+		}
+
+		public Traverse Type(string name)
+		{
+			if (name == null) throw new ArgumentNullException("name cannot be null");
+			if (_type == null) return new Traverse();
+			var type = AccessTools.Inner(_type, name);
+			if (type == null) return new Traverse();
+			return new Traverse(type);
+		}
+
+		public Traverse Field(string name)
+		{
+			if (name == null) throw new ArgumentNullException("name cannot be null");
+			var resolved = Resolve();
+			if (resolved._type == null) return new Traverse();
+			var info = Cache.GetFieldInfo(resolved._type, name);
+			if (info == null) return new Traverse();
+			if (info.IsStatic == false && resolved._root == null) return new Traverse();
+			return new Traverse(resolved._root, info, null);
+		}
+
+		public Traverse<T> Field<T>(string name)
+		{
+			return new Traverse<T>(Field(name));
+		}
+
+		public List<string> Fields()
+		{
+			var resolved = Resolve();
+			return AccessTools.GetFieldNames(resolved._type);
+		}
+
+		public Traverse Property(string name, object[] index = null)
+		{
+			if (name == null) throw new ArgumentNullException("name cannot be null");
+			var resolved = Resolve();
+			if (resolved._root == null || resolved._type == null) return new Traverse();
+			var info = Cache.GetPropertyInfo(resolved._type, name);
+			if (info == null) return new Traverse();
+			return new Traverse(resolved._root, info, index);
+		}
+
+		public Traverse<T> Property<T>(string name, object[] index = null)
+		{
+			return new Traverse<T>(Property(name, index));
+		}
+
+		public List<string> Properties()
+		{
+			var resolved = Resolve();
+			return AccessTools.GetPropertyNames(resolved._type);
+		}
+
+		public Traverse Method(string name, params object[] arguments)
+		{
+			if (name == null) throw new ArgumentNullException("name cannot be null");
+			var resolved = Resolve();
+			if (resolved._type == null) return new Traverse();
+			var types = AccessTools.GetTypes(arguments);
+			var method = Cache.GetMethodInfo(resolved._type, name, types);
+			if (method == null) return new Traverse();
+			return new Traverse(resolved._root, (MethodInfo)method, arguments);
+		}
+
+		public Traverse Method(string name, Type[] paramTypes, object[] arguments = null)
+		{
+			if (name == null) throw new ArgumentNullException("name cannot be null");
+			var resolved = Resolve();
+			if (resolved._type == null) return new Traverse();
+			var method = Cache.GetMethodInfo(resolved._type, name, paramTypes);
+			if (method == null) return new Traverse();
+			return new Traverse(resolved._root, (MethodInfo)method, arguments);
+		}
+
+		public List<string> Methods()
+		{
+			var resolved = Resolve();
+			return AccessTools.GetMethodNames(resolved._type);
+		}
+
+		public bool FieldExists()
+		{
+			return _info != null;
+		}
+
+		public bool MethodExists()
+		{
+			return _method != null;
+		}
+
+		public bool TypeExists()
+		{
+			return _type != null;
+		}
+
+		public static void IterateFields(object source, Action<Traverse> action)
+		{
+			var sourceTrv = Create(source);
+			AccessTools.GetFieldNames(source).ForEach(f => action(sourceTrv.Field(f)));
+		}
+
+		public static void IterateFields(object source, object target, Action<Traverse, Traverse> action)
+		{
+			var sourceTrv = Create(source);
+			var targetTrv = Create(target);
+			AccessTools.GetFieldNames(source).ForEach(f => action(sourceTrv.Field(f), targetTrv.Field(f)));
+		}
+
+		public static void IterateFields(object source, object target, Action<string, Traverse, Traverse> action)
+		{
+			var sourceTrv = Create(source);
+			var targetTrv = Create(target);
+			AccessTools.GetFieldNames(source).ForEach(f => action(f, sourceTrv.Field(f), targetTrv.Field(f)));
+		}
+
+		public static void IterateProperties(object source, Action<Traverse> action)
+		{
+			var sourceTrv = Create(source);
+			AccessTools.GetPropertyNames(source).ForEach(f => action(sourceTrv.Property(f)));
+		}
+
+		public static void IterateProperties(object source, object target, Action<Traverse, Traverse> action)
+		{
+			var sourceTrv = Create(source);
+			var targetTrv = Create(target);
+			AccessTools.GetPropertyNames(source).ForEach(f => action(sourceTrv.Property(f), targetTrv.Property(f)));
+		}
+
+		public static void IterateProperties(object source, object target, Action<string, Traverse, Traverse> action)
+		{
+			var sourceTrv = Create(source);
+			var targetTrv = Create(target);
+			AccessTools.GetPropertyNames(source).ForEach(f => action(f, sourceTrv.Property(f), targetTrv.Property(f)));
+		}
+
+		public static Action<Traverse, Traverse> CopyFields = (from, to) => { to.SetValue(from.GetValue()); };
+
+		public override string ToString()
+		{
+			var value = _method ?? GetValue();
+			return value?.ToString();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Harmony/Transpilers.cs b/src/Harmony/Transpilers.cs
new file mode 100644
index 00000000..76ac865f
--- /dev/null
+++ b/src/Harmony/Transpilers.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Harmony
+{
+	public static class Transpilers
+	{
+		public static IEnumerable<CodeInstruction> MethodReplacer(this IEnumerable<CodeInstruction> instructions, MethodBase from, MethodBase to)
+		{
+			if (from == null)
+				throw new ArgumentException("Unexpected null argument", nameof(from));
+			if (to == null)
+				throw new ArgumentException("Unexpected null argument", nameof(to));
+
+			foreach (var instruction in instructions)
+			{
+				var method = instruction.operand as MethodBase;
+				if (method == from)
+				{
+					instruction.opcode = to.IsConstructor ? OpCodes.Newobj : OpCodes.Call;
+					instruction.operand = to;
+				}
+				yield return instruction;
+			}
+		}
+
+		public static IEnumerable<CodeInstruction> DebugLogger(this IEnumerable<CodeInstruction> instructions, string text)
+		{
+			yield return new CodeInstruction(OpCodes.Ldstr, text);
+			yield return new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(FileLog), nameof(FileLog.Log)));
+			foreach (var instruction in instructions) yield return instruction;
+		}
+
+		// more added soon
+	}
+}
\ No newline at end of file
diff --git a/src/Mod.csproj b/src/Mod.csproj
new file mode 100644
index 00000000..d2c13efa
--- /dev/null
+++ b/src/Mod.csproj
@@ -0,0 +1,831 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{23B6885E-0282-435B-A854-D49ABF1391D6}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Mod</RootNamespace>
+    <AssemblyName>Mod</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>7.2</LangVersion>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>7.2</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Harmony\Attributes.cs" />
+    <Compile Include="Harmony\CodeInstruction.cs" />
+    <Compile Include="Harmony\CodeTranspiler.cs" />
+    <Compile Include="Harmony\Extras\DelegateTypeFactory.cs" />
+    <Compile Include="Harmony\Extras\FastAccess.cs" />
+    <Compile Include="Harmony\Extras\MethodInvoker.cs" />
+    <Compile Include="Harmony\GlobalSuppressions.cs" />
+    <Compile Include="Harmony\HarmonyInstance.cs" />
+    <Compile Include="Harmony\HarmonyMethod.cs" />
+    <Compile Include="Harmony\HarmonySharedState.cs" />
+    <Compile Include="Harmony\ILCopying\ByteBuffer.cs" />
+    <Compile Include="Harmony\ILCopying\Emitter.cs" />
+    <Compile Include="Harmony\ILCopying\ILInstruction.cs" />
+    <Compile Include="Harmony\ILCopying\Memory.cs" />
+    <Compile Include="Harmony\ILCopying\MethodCopier.cs" />
+    <Compile Include="Harmony\ILCopying\Signature.cs" />
+    <Compile Include="Harmony\MethodPatcher.cs" />
+    <Compile Include="Harmony\Patch.cs" />
+    <Compile Include="Harmony\PatchFunctions.cs" />
+    <Compile Include="Harmony\PatchProcessor.cs" />
+    <Compile Include="Harmony\Priority.cs" />
+    <Compile Include="Harmony\Tools\AccessCache.cs" />
+    <Compile Include="Harmony\Tools\AccessTools.cs" />
+    <Compile Include="Harmony\Tools\DynamicTools.cs" />
+    <Compile Include="Harmony\Tools\Extensions.cs" />
+    <Compile Include="Harmony\Tools\FileLog.cs" />
+    <Compile Include="Harmony\Tools\PatchTools.cs" />
+    <Compile Include="Harmony\Tools\SelfPatching.cs" />
+    <Compile Include="Harmony\Tools\SymbolExtensions.cs" />
+    <Compile Include="Harmony\Tools\Traverse.cs" />
+    <Compile Include="Harmony\Transpilers.cs" />
+    <Compile Include="ModEntry.cs" />
+    <Compile Include="Mono\Cecil\ArrayType.cs" />
+    <Compile Include="Mono\Cecil\AssemblyDefinition.cs" />
+    <Compile Include="Mono\Cecil\AssemblyFlags.cs" />
+    <Compile Include="Mono\Cecil\AssemblyHashAlgorithm.cs" />
+    <Compile Include="Mono\Cecil\AssemblyLinkedResource.cs" />
+    <Compile Include="Mono\Cecil\AssemblyNameDefinition.cs" />
+    <Compile Include="Mono\Cecil\AssemblyNameReference.cs" />
+    <Compile Include="Mono\Cecil\AssemblyReader.cs" />
+    <Compile Include="Mono\Cecil\AssemblyWriter.cs" />
+    <Compile Include="Mono\Cecil\BaseAssemblyResolver.cs" />
+    <Compile Include="Mono\Cecil\CallSite.cs" />
+    <Compile Include="Mono\Cecil\Cil\Code.cs" />
+    <Compile Include="Mono\Cecil\Cil\CodeReader.cs" />
+    <Compile Include="Mono\Cecil\Cil\CodeWriter.cs" />
+    <Compile Include="Mono\Cecil\Cil\Document.cs" />
+    <Compile Include="Mono\Cecil\Cil\ExceptionHandler.cs" />
+    <Compile Include="Mono\Cecil\Cil\ILProcessor.cs" />
+    <Compile Include="Mono\Cecil\Cil\Instruction.cs" />
+    <Compile Include="Mono\Cecil\Cil\MethodBody.cs" />
+    <Compile Include="Mono\Cecil\Cil\OpCode.cs" />
+    <Compile Include="Mono\Cecil\Cil\OpCodes.cs" />
+    <Compile Include="Mono\Cecil\Cil\PortablePdb.cs" />
+    <Compile Include="Mono\Cecil\Cil\SequencePoint.cs" />
+    <Compile Include="Mono\Cecil\Cil\Symbols.cs" />
+    <Compile Include="Mono\Cecil\Cil\VariableDefinition.cs" />
+    <Compile Include="Mono\Cecil\Cil\VariableReference.cs" />
+    <Compile Include="Mono\Cecil\Consts.cs" />
+    <Compile Include="Mono\Cecil\CustomAttribute.cs" />
+    <Compile Include="Mono\Cecil\DefaultAssemblyResolver.cs" />
+    <Compile Include="Mono\Cecil\EmbeddedResource.cs" />
+    <Compile Include="Mono\Cecil\EventAttributes.cs" />
+    <Compile Include="Mono\Cecil\EventDefinition.cs" />
+    <Compile Include="Mono\Cecil\EventReference.cs" />
+    <Compile Include="Mono\Cecil\ExportedType.cs" />
+    <Compile Include="Mono\Cecil\FieldAttributes.cs" />
+    <Compile Include="Mono\Cecil\FieldDefinition.cs" />
+    <Compile Include="Mono\Cecil\FieldReference.cs" />
+    <Compile Include="Mono\Cecil\FileAttributes.cs" />
+    <Compile Include="Mono\Cecil\FunctionPointerType.cs" />
+    <Compile Include="Mono\Cecil\GenericInstanceMethod.cs" />
+    <Compile Include="Mono\Cecil\GenericInstanceType.cs" />
+    <Compile Include="Mono\Cecil\GenericParameter.cs" />
+    <Compile Include="Mono\Cecil\GenericParameterAttributes.cs" />
+    <Compile Include="Mono\Cecil\IConstantProvider.cs" />
+    <Compile Include="Mono\Cecil\ICustomAttributeProvider.cs" />
+    <Compile Include="Mono\Cecil\IGenericInstance.cs" />
+    <Compile Include="Mono\Cecil\IGenericParameterProvider.cs" />
+    <Compile Include="Mono\Cecil\IMarshalInfoProvider.cs" />
+    <Compile Include="Mono\Cecil\IMemberDefinition.cs" />
+    <Compile Include="Mono\Cecil\IMetadataScope.cs" />
+    <Compile Include="Mono\Cecil\IMetadataTokenProvider.cs" />
+    <Compile Include="Mono\Cecil\IMethodSignature.cs" />
+    <Compile Include="Mono\Cecil\Import.cs" />
+    <Compile Include="Mono\Cecil\LinkedResource.cs" />
+    <Compile Include="Mono\Cecil\ManifestResourceAttributes.cs" />
+    <Compile Include="Mono\Cecil\MarshalInfo.cs" />
+    <Compile Include="Mono\Cecil\MemberDefinitionCollection.cs" />
+    <Compile Include="Mono\Cecil\MemberReference.cs" />
+    <Compile Include="Mono\Cecil\MetadataResolver.cs" />
+    <Compile Include="Mono\Cecil\MetadataSystem.cs" />
+    <Compile Include="Mono\Cecil\Metadata\BlobHeap.cs" />
+    <Compile Include="Mono\Cecil\Metadata\Buffers.cs" />
+    <Compile Include="Mono\Cecil\Metadata\CodedIndex.cs" />
+    <Compile Include="Mono\Cecil\Metadata\ElementType.cs" />
+    <Compile Include="Mono\Cecil\Metadata\GuidHeap.cs" />
+    <Compile Include="Mono\Cecil\Metadata\Heap.cs" />
+    <Compile Include="Mono\Cecil\Metadata\MetadataToken.cs" />
+    <Compile Include="Mono\Cecil\Metadata\PdbHeap.cs" />
+    <Compile Include="Mono\Cecil\Metadata\Row.cs" />
+    <Compile Include="Mono\Cecil\Metadata\StringHeap.cs" />
+    <Compile Include="Mono\Cecil\Metadata\TableHeap.cs" />
+    <Compile Include="Mono\Cecil\Metadata\TokenType.cs" />
+    <Compile Include="Mono\Cecil\Metadata\UserStringHeap.cs" />
+    <Compile Include="Mono\Cecil\Metadata\Utilities.cs" />
+    <Compile Include="Mono\Cecil\MethodAttributes.cs" />
+    <Compile Include="Mono\Cecil\MethodCallingConvention.cs" />
+    <Compile Include="Mono\Cecil\MethodDefinition.cs" />
+    <Compile Include="Mono\Cecil\MethodImplAttributes.cs" />
+    <Compile Include="Mono\Cecil\MethodReference.cs" />
+    <Compile Include="Mono\Cecil\MethodReturnType.cs" />
+    <Compile Include="Mono\Cecil\MethodSemanticsAttributes.cs" />
+    <Compile Include="Mono\Cecil\MethodSpecification.cs" />
+    <Compile Include="Mono\Cecil\Modifiers.cs" />
+    <Compile Include="Mono\Cecil\ModuleDefinition.cs" />
+    <Compile Include="Mono\Cecil\ModuleKind.cs" />
+    <Compile Include="Mono\Cecil\ModuleReference.cs" />
+    <Compile Include="Mono\Cecil\NativeType.cs" />
+    <Compile Include="Mono\Cecil\ParameterAttributes.cs" />
+    <Compile Include="Mono\Cecil\ParameterDefinition.cs" />
+    <Compile Include="Mono\Cecil\ParameterDefinitionCollection.cs" />
+    <Compile Include="Mono\Cecil\ParameterReference.cs" />
+    <Compile Include="Mono\Cecil\PE\BinaryStreamReader.cs" />
+    <Compile Include="Mono\Cecil\PE\BinaryStreamWriter.cs" />
+    <Compile Include="Mono\Cecil\PE\ByteBuffer.cs" />
+    <Compile Include="Mono\Cecil\PE\ByteBufferEqualityComparer.cs" />
+    <Compile Include="Mono\Cecil\PE\DataDirectory.cs" />
+    <Compile Include="Mono\Cecil\PE\Image.cs" />
+    <Compile Include="Mono\Cecil\PE\ImageReader.cs" />
+    <Compile Include="Mono\Cecil\PE\ImageWriter.cs" />
+    <Compile Include="Mono\Cecil\PE\Section.cs" />
+    <Compile Include="Mono\Cecil\PE\TextMap.cs" />
+    <Compile Include="Mono\Cecil\PinnedType.cs" />
+    <Compile Include="Mono\Cecil\PInvokeAttributes.cs" />
+    <Compile Include="Mono\Cecil\PInvokeInfo.cs" />
+    <Compile Include="Mono\Cecil\PointerType.cs" />
+    <Compile Include="Mono\Cecil\PropertyAttributes.cs" />
+    <Compile Include="Mono\Cecil\PropertyDefinition.cs" />
+    <Compile Include="Mono\Cecil\PropertyReference.cs" />
+    <Compile Include="Mono\Cecil\ReferenceType.cs" />
+    <Compile Include="Mono\Cecil\Resource.cs" />
+    <Compile Include="Mono\Cecil\SecurityDeclaration.cs" />
+    <Compile Include="Mono\Cecil\SentinelType.cs" />
+    <Compile Include="Mono\Cecil\TargetRuntime.cs" />
+    <Compile Include="Mono\Cecil\Treatments.cs" />
+    <Compile Include="Mono\Cecil\TypeAttributes.cs" />
+    <Compile Include="Mono\Cecil\TypeDefinition.cs" />
+    <Compile Include="Mono\Cecil\TypeDefinitionCollection.cs" />
+    <Compile Include="Mono\Cecil\TypeParser.cs" />
+    <Compile Include="Mono\Cecil\TypeReference.cs" />
+    <Compile Include="Mono\Cecil\TypeSpecification.cs" />
+    <Compile Include="Mono\Cecil\TypeSystem.cs" />
+    <Compile Include="Mono\Cecil\VariantType.cs" />
+    <Compile Include="Mono\Cecil\WindowsRuntimeProjections.cs" />
+    <Compile Include="Mono\Collections\Generic\Collection.cs" />
+    <Compile Include="Mono\Collections\Generic\ReadOnlyCollection.cs" />
+    <Compile Include="Mono\Disposable.cs" />
+    <Compile Include="Mono\Empty.cs" />
+    <Compile Include="Mono\MergeSort.cs" />
+    <Compile Include="Mono\Security\Cryptography\CryptoConvert.cs" />
+    <Compile Include="Mono\Security\Cryptography\CryptoService.cs" />
+    <Compile Include="Mono\Type.cs" />
+    <Compile Include="Newtonsoft.Json\Bson\BsonBinaryType.cs" />
+    <Compile Include="Newtonsoft.Json\Bson\BsonBinaryWriter.cs" />
+    <Compile Include="Newtonsoft.Json\Bson\BsonObjectId.cs" />
+    <Compile Include="Newtonsoft.Json\Bson\BsonReader.cs" />
+    <Compile Include="Newtonsoft.Json\Bson\BsonToken.cs" />
+    <Compile Include="Newtonsoft.Json\Bson\BsonType.cs" />
+    <Compile Include="Newtonsoft.Json\Bson\BsonWriter.cs" />
+    <Compile Include="Newtonsoft.Json\ConstructorHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\BinaryConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\BsonObjectIdConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\CustomCreationConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\DataSetConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\DataTableConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\DateTimeConverterBase.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\DiscriminatedUnionConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\EntityKeyMemberConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\ExpandoObjectConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\IsoDateTimeConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\JavaScriptDateTimeConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\KeyValuePairConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\RegexConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\StringEnumConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\UnixDateTimeConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\VersionConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Converters\XmlNodeConverter.cs" />
+    <Compile Include="Newtonsoft.Json\DateFormatHandling.cs" />
+    <Compile Include="Newtonsoft.Json\DateParseHandling.cs" />
+    <Compile Include="Newtonsoft.Json\DateTimeZoneHandling.cs" />
+    <Compile Include="Newtonsoft.Json\DefaultJsonNameTable.cs" />
+    <Compile Include="Newtonsoft.Json\DefaultValueHandling.cs" />
+    <Compile Include="Newtonsoft.Json\FloatFormatHandling.cs" />
+    <Compile Include="Newtonsoft.Json\FloatParseHandling.cs" />
+    <Compile Include="Newtonsoft.Json\FormatterAssemblyStyle.cs" />
+    <Compile Include="Newtonsoft.Json\Formatting.cs" />
+    <Compile Include="Newtonsoft.Json\IArrayPool.cs" />
+    <Compile Include="Newtonsoft.Json\IJsonLineInfo.cs" />
+    <Compile Include="Newtonsoft.Json\JsonArrayAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonConstructorAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonContainerAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonConvert.cs" />
+    <Compile Include="Newtonsoft.Json\JsonConverter.cs" />
+    <Compile Include="Newtonsoft.Json\JsonConverterAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonConverterCollection.cs" />
+    <Compile Include="Newtonsoft.Json\JsonDictionaryAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonException.cs" />
+    <Compile Include="Newtonsoft.Json\JsonExtensionDataAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonIgnoreAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonNameTable.cs" />
+    <Compile Include="Newtonsoft.Json\JsonObjectAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonPosition.cs" />
+    <Compile Include="Newtonsoft.Json\JsonPropertyAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonReader.Async.cs" />
+    <Compile Include="Newtonsoft.Json\JsonReader.cs" />
+    <Compile Include="Newtonsoft.Json\JsonReaderException.cs" />
+    <Compile Include="Newtonsoft.Json\JsonRequiredAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\JsonSerializationException.cs" />
+    <Compile Include="Newtonsoft.Json\JsonSerializer.cs" />
+    <Compile Include="Newtonsoft.Json\JsonSerializerSettings.cs" />
+    <Compile Include="Newtonsoft.Json\JsonTextReader.Async.cs" />
+    <Compile Include="Newtonsoft.Json\JsonTextReader.cs" />
+    <Compile Include="Newtonsoft.Json\JsonTextWriter.Async.cs" />
+    <Compile Include="Newtonsoft.Json\JsonTextWriter.cs" />
+    <Compile Include="Newtonsoft.Json\JsonToken.cs" />
+    <Compile Include="Newtonsoft.Json\JsonValidatingReader.cs" />
+    <Compile Include="Newtonsoft.Json\JsonWriter.Async.cs" />
+    <Compile Include="Newtonsoft.Json\JsonWriter.cs" />
+    <Compile Include="Newtonsoft.Json\JsonWriterException.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\CommentHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\DuplicatePropertyNameHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\Extensions.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\IJEnumerable.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JArray.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JArray.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JConstructor.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JConstructor.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JContainer.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JContainer.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JEnumerable.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JObject.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JObject.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JProperty.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JProperty.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JPropertyDescriptor.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JPropertyKeyedCollection.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JRaw.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JRaw.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonLoadSettings.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonMergeSettings.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\ArrayIndexFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\ArrayMultipleIndexFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\ArraySliceFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\FieldFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\FieldMultipleFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\JPath.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\PathFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\QueryExpression.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\QueryFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\QueryScanFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\RootFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\ScanFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JsonPath\ScanMultipleFilter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JToken.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JToken.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JTokenEqualityComparer.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JTokenReader.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JTokenType.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JTokenWriter.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JTokenWriter.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JValue.Async.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\JValue.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\LineInfoHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\MergeArrayHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Linq\MergeNullValueHandling.cs" />
+    <Compile Include="Newtonsoft.Json\MemberSerialization.cs" />
+    <Compile Include="Newtonsoft.Json\MetadataPropertyHandling.cs" />
+    <Compile Include="Newtonsoft.Json\MissingMemberHandling.cs" />
+    <Compile Include="Newtonsoft.Json\NullValueHandling.cs" />
+    <Compile Include="Newtonsoft.Json\ObjectCreationHandling.cs" />
+    <Compile Include="Newtonsoft.Json\PreserveReferencesHandling.cs" />
+    <Compile Include="Newtonsoft.Json\ReferenceLoopHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Required.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\Extensions.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchema.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaBuilder.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaConstants.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaException.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaGenerator.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaModel.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaModelBuilder.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaNode.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaNodeCollection.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaResolver.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaType.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\JsonSchemaWriter.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\UndefinedSchemaIdHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\ValidationEventArgs.cs" />
+    <Compile Include="Newtonsoft.Json\Schema\ValidationEventHandler.cs" />
+    <Compile Include="Newtonsoft.Json\SerializationBinder.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\CachedAttributeGetter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\CamelCaseNamingStrategy.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\CamelCasePropertyNamesContractResolver.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\DefaultContractResolver.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\DefaultNamingStrategy.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\DefaultReferenceResolver.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\DefaultSerializationBinder.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\DiagnosticsTraceWriter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\DynamicValueProvider.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ErrorContext.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ErrorEventArgs.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ExpressionValueProvider.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\FormatterConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\IAttributeProvider.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\IContractResolver.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\IReferenceResolver.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ISerializationBinder.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ITraceWriter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\IValueProvider.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonArrayContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonContainerContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonDictionaryContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonDynamicContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonFormatterConverter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonISerializableContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonLinqContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonObjectContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonPrimitiveContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonProperty.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonPropertyCollection.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonSerializerInternalBase.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonSerializerInternalReader.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonSerializerInternalWriter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonSerializerProxy.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonStringContract.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\JsonTypeReflector.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\MemoryTraceWriter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\NamingStrategy.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ObjectConstructor.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\OnErrorAttribute.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ReflectionAttributeProvider.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\ReflectionValueProvider.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\SerializationBinderAdapter.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\SnakeCaseNamingStrategy.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\TraceJsonReader.cs" />
+    <Compile Include="Newtonsoft.Json\Serialization\TraceJsonWriter.cs" />
+    <Compile Include="Newtonsoft.Json\StringEscapeHandling.cs" />
+    <Compile Include="Newtonsoft.Json\TraceLevel.cs" />
+    <Compile Include="Newtonsoft.Json\TypeNameAssemblyFormatHandling.cs" />
+    <Compile Include="Newtonsoft.Json\TypeNameHandling.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\AsyncUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\Base64Encoder.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\BidirectionalDictionary.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\CollectionUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\CollectionWrapper.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ConvertUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\DateTimeParser.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\DateTimeUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\DictionaryWrapper.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\DynamicProxy.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\DynamicProxyMetaObject.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\DynamicReflectionDelegateFactory.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\DynamicUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\EnumInfo.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\EnumUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ExpressionReflectionDelegateFactory.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\FSharpUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ILGeneratorExtensions.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ImmutableCollectionsUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\JavaScriptUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\JsonTokenUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\LateBoundReflectionDelegateFactory.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\LinqBridge.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\MathUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\MethodBinder.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\MethodCall.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\MiscellaneousUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ReflectionDelegateFactory.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ReflectionObject.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ReflectionUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\StringBuffer.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\StringReference.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\StringUtils.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\StructMultiKey.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ThreadSafeStore.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\TypeExtensions.cs" />
+    <Compile Include="Newtonsoft.Json\Utilities\ValidationUtils.cs" />
+    <Compile Include="Newtonsoft.Json\WriteState.cs" />
+    <Compile Include="Options\ModOptionsCheckbox.cs" />
+    <Compile Include="Options\ModOptionsSlider.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SMAPI\Constants.cs" />
+    <Compile Include="SMAPI\ContentSource.cs" />
+    <Compile Include="SMAPI\Context.cs" />
+    <Compile Include="SMAPI\Enums\LoadStage.cs" />
+    <Compile Include="SMAPI\Enums\SkillType.cs" />
+    <Compile Include="SMAPI\Events\BuildingListChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\ButtonPressedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\ButtonReleasedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\ChangeType.cs" />
+    <Compile Include="SMAPI\Events\CursorMovedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\DayEndingEventArgs.cs" />
+    <Compile Include="SMAPI\Events\DayStartedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\DebrisListChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\GameLaunchedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\IDisplayEvents.cs" />
+    <Compile Include="SMAPI\Events\IGameLoopEvents.cs" />
+    <Compile Include="SMAPI\Events\IInputEvents.cs" />
+    <Compile Include="SMAPI\Events\IModEvents.cs" />
+    <Compile Include="SMAPI\Events\IMultiplayerEvents.cs" />
+    <Compile Include="SMAPI\Events\InventoryChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\IPlayerEvents.cs" />
+    <Compile Include="SMAPI\Events\ISpecialisedEvents.cs" />
+    <Compile Include="SMAPI\Events\ItemStackChange.cs" />
+    <Compile Include="SMAPI\Events\ItemStackSizeChange.cs" />
+    <Compile Include="SMAPI\Events\IWorldEvents.cs" />
+    <Compile Include="SMAPI\Events\LargeTerrainFeatureListChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\LevelChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\LoadStageChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\LocationListChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\MenuChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\ModMessageReceivedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\MouseWheelScrolledEventArgs.cs" />
+    <Compile Include="SMAPI\Events\NpcListChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\ObjectListChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\OneSecondUpdateTickedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\OneSecondUpdateTickingEventArgs.cs" />
+    <Compile Include="SMAPI\Events\PeerContextReceivedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\PeerDisconnectedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderedActiveMenuEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderedHudEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderedWorldEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderingActiveMenuEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderingEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderingHudEventArgs.cs" />
+    <Compile Include="SMAPI\Events\RenderingWorldEventArgs.cs" />
+    <Compile Include="SMAPI\Events\ReturnedToTitleEventArgs.cs" />
+    <Compile Include="SMAPI\Events\SaveCreatedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\SaveCreatingEventArgs.cs" />
+    <Compile Include="SMAPI\Events\SavedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\SaveLoadedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\SavingEventArgs.cs" />
+    <Compile Include="SMAPI\Events\TerrainFeatureListChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\TimeChangedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\UnvalidatedUpdateTickedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\UnvalidatedUpdateTickingEventArgs.cs" />
+    <Compile Include="SMAPI\Events\UpdateTickedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\UpdateTickingEventArgs.cs" />
+    <Compile Include="SMAPI\Events\WarpedEventArgs.cs" />
+    <Compile Include="SMAPI\Events\WindowResizedEventArgs.cs" />
+    <Compile Include="SMAPI\Framework\Command.cs" />
+    <Compile Include="SMAPI\Framework\CommandManager.cs" />
+    <Compile Include="SMAPI\Framework\ContentCoordinator.cs" />
+    <Compile Include="SMAPI\Framework\ContentManagers\BaseContentManager.cs" />
+    <Compile Include="SMAPI\Framework\ContentManagers\GameContentManager.cs" />
+    <Compile Include="SMAPI\Framework\ContentManagers\IContentManager.cs" />
+    <Compile Include="SMAPI\Framework\ContentManagers\ModContentManager.cs" />
+    <Compile Include="SMAPI\Framework\ContentPack.cs" />
+    <Compile Include="SMAPI\Framework\Content\AssetData.cs" />
+    <Compile Include="SMAPI\Framework\Content\AssetDataForDictionary.cs" />
+    <Compile Include="SMAPI\Framework\Content\AssetDataForImage.cs" />
+    <Compile Include="SMAPI\Framework\Content\AssetDataForObject.cs" />
+    <Compile Include="SMAPI\Framework\Content\AssetInfo.cs" />
+    <Compile Include="SMAPI\Framework\Content\ContentCache.cs" />
+    <Compile Include="SMAPI\Framework\CursorPosition.cs" />
+    <Compile Include="SMAPI\Framework\DeprecationLevel.cs" />
+    <Compile Include="SMAPI\Framework\DeprecationManager.cs" />
+    <Compile Include="SMAPI\Framework\DeprecationWarning.cs" />
+    <Compile Include="SMAPI\Framework\Events\EventManager.cs" />
+    <Compile Include="SMAPI\Framework\Events\ManagedEvent.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModDisplayEvents.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModEvents.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModEventsBase.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModGameLoopEvents.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModInputEvents.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModMultiplayerEvents.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModPlayerEvents.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModSpecialisedEvents.cs" />
+    <Compile Include="SMAPI\Framework\Events\ModWorldEvents.cs" />
+    <Compile Include="SMAPI\Framework\Exceptions\SAssemblyLoadFailedException.cs" />
+    <Compile Include="SMAPI\Framework\Exceptions\SContentLoadException.cs" />
+    <Compile Include="SMAPI\Framework\GameVersion.cs" />
+    <Compile Include="SMAPI\Framework\IModMetadata.cs" />
+    <Compile Include="SMAPI\Framework\Input\GamePadStateBuilder.cs" />
+    <Compile Include="SMAPI\Framework\Input\InputStatus.cs" />
+    <Compile Include="SMAPI\Framework\Input\SInputState.cs" />
+    <Compile Include="SMAPI\Framework\InternalExtensions.cs" />
+    <Compile Include="SMAPI\Framework\Logging\ConsoleInterceptionManager.cs" />
+    <Compile Include="SMAPI\Framework\Logging\InterceptingTextWriter.cs" />
+    <Compile Include="SMAPI\Framework\Logging\LogFileManager.cs" />
+    <Compile Include="SMAPI\Framework\Models\ModFolderExport.cs" />
+    <Compile Include="SMAPI\Framework\Models\SConfig.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\BaseHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\CommandHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\ContentHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\ContentPackHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\DataHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\InputHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\ModHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\ModRegistryHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\ReflectionHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModHelpers\TranslationHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\AssemblyDefinitionResolver.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\AssemblyLoader.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\AssemblyLoadStatus.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\AssemblyParseResult.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Finders\EventFinder.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Finders\FieldFinder.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Finders\MethodFinder.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Finders\PropertyFinder.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Finders\ReferenceToMemberWithUnexpectedTypeFinder.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Finders\ReferenceToMissingMemberFinder.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Finders\TypeFinder.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\IInstructionHandler.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\IncompatibleInstructionException.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\InstructionHandleResult.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\InvalidModStateException.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\ModDependencyStatus.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\ModMetadata.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\ModMetadataStatus.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\ModResolver.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\PlatformAssemblyMap.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\RewriteHelper.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Rewriters\FieldReplaceRewriter.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Rewriters\FieldToPropertyRewriter.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Rewriters\MethodParentRewriter.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Rewriters\StaticFieldToConstantRewriter.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\Rewriters\TypeReferenceRewriter.cs" />
+    <Compile Include="SMAPI\Framework\ModLoading\TypeReferenceComparer.cs" />
+    <Compile Include="SMAPI\Framework\ModRegistry.cs" />
+    <Compile Include="SMAPI\Framework\Monitor.cs" />
+    <Compile Include="SMAPI\Framework\Networking\MessageType.cs" />
+    <Compile Include="SMAPI\Framework\Networking\ModMessageModel.cs" />
+    <Compile Include="SMAPI\Framework\Networking\MultiplayerPeer.cs" />
+    <Compile Include="SMAPI\Framework\Networking\MultiplayerPeerMod.cs" />
+    <Compile Include="SMAPI\Framework\Networking\RemoteContextModel.cs" />
+    <Compile Include="SMAPI\Framework\Networking\RemoteContextModModel.cs" />
+    <Compile Include="SMAPI\Framework\Patching\GamePatcher.cs" />
+    <Compile Include="SMAPI\Framework\Patching\IHarmonyPatch.cs" />
+    <Compile Include="SMAPI\Framework\Reflection\CacheEntry.cs" />
+    <Compile Include="SMAPI\Framework\Reflection\InterfaceProxyBuilder.cs" />
+    <Compile Include="SMAPI\Framework\Reflection\InterfaceProxyFactory.cs" />
+    <Compile Include="SMAPI\Framework\Reflection\ReflectedField.cs" />
+    <Compile Include="SMAPI\Framework\Reflection\ReflectedMethod.cs" />
+    <Compile Include="SMAPI\Framework\Reflection\ReflectedProperty.cs" />
+    <Compile Include="SMAPI\Framework\Reflection\Reflector.cs" />
+    <Compile Include="SMAPI\Framework\RequestExitDelegate.cs" />
+    <Compile Include="SMAPI\Framework\RewriteFacades\SpriteBatchMethods.cs" />
+    <Compile Include="SMAPI\Framework\SCore.cs" />
+    <Compile Include="SMAPI\Framework\Serialisation\ColorConverter.cs" />
+    <Compile Include="SMAPI\Framework\Serialisation\PointConverter.cs" />
+    <Compile Include="SMAPI\Framework\Serialisation\RectangleConverter.cs" />
+    <Compile Include="SMAPI\Framework\SGame.cs" />
+    <Compile Include="SMAPI\Framework\SGameConstructorHack.cs" />
+    <Compile Include="SMAPI\Framework\Singleton.cs" />
+    <Compile Include="SMAPI\Framework\SModHooks.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\Comparers\EquatableComparer.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\Comparers\GenericEqualsComparer.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\Comparers\ObjectReferenceComparer.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\BaseDisposableWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\ComparableListWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\ComparableWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\NetCollectionWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\NetDictionaryWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\NetValueWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\ObservableCollectionWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\FieldWatchers\WatcherFactory.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\ICollectionWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\IDictionaryWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\IValueWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\IWatcher.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\LocationTracker.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\PlayerTracker.cs" />
+    <Compile Include="SMAPI\Framework\StateTracking\WorldLocationsTracker.cs" />
+    <Compile Include="SMAPI\Framework\Utilities\ContextHash.cs" />
+    <Compile Include="SMAPI\Framework\Utilities\Countdown.cs" />
+    <Compile Include="SMAPI\Framework\WatcherCore.cs" />
+    <Compile Include="SMAPI\GamePlatform.cs" />
+    <Compile Include="SMAPI\IAssetData.cs" />
+    <Compile Include="SMAPI\IAssetDataForDictionary.cs" />
+    <Compile Include="SMAPI\IAssetDataForImage.cs" />
+    <Compile Include="SMAPI\IAssetEditor.cs" />
+    <Compile Include="SMAPI\IAssetInfo.cs" />
+    <Compile Include="SMAPI\IAssetLoader.cs" />
+    <Compile Include="SMAPI\ICommandHelper.cs" />
+    <Compile Include="SMAPI\IContentHelper.cs" />
+    <Compile Include="SMAPI\IContentPack.cs" />
+    <Compile Include="SMAPI\IContentPackHelper.cs" />
+    <Compile Include="SMAPI\ICursorPosition.cs" />
+    <Compile Include="SMAPI\IDataHelper.cs" />
+    <Compile Include="SMAPI\IInputHelper.cs" />
+    <Compile Include="SMAPI\IMod.cs" />
+    <Compile Include="SMAPI\IModHelper.cs" />
+    <Compile Include="SMAPI\IModInfo.cs" />
+    <Compile Include="SMAPI\IModLinked.cs" />
+    <Compile Include="SMAPI\IModRegistry.cs" />
+    <Compile Include="SMAPI\IMonitor.cs" />
+    <Compile Include="SMAPI\IMultiplayerPeer.cs" />
+    <Compile Include="SMAPI\IMultiplayerPeerMod.cs" />
+    <Compile Include="SMAPI\Internal\ConsoleWriting\ColorfulConsoleWriter.cs" />
+    <Compile Include="SMAPI\Internal\ConsoleWriting\LogLevel.cs" />
+    <Compile Include="SMAPI\Internal\ConsoleWriting\MonitorColorScheme.cs" />
+    <Compile Include="SMAPI\Internal\EnvironmentUtility.cs" />
+    <Compile Include="SMAPI\Internal\Platform.cs" />
+    <Compile Include="SMAPI\IReflectedField.cs" />
+    <Compile Include="SMAPI\IReflectedMethod.cs" />
+    <Compile Include="SMAPI\IReflectedProperty.cs" />
+    <Compile Include="SMAPI\IReflectionHelper.cs" />
+    <Compile Include="SMAPI\ITranslationHelper.cs" />
+    <Compile Include="SMAPI\LogLevel.cs" />
+    <Compile Include="SMAPI\Metadata\CoreAssetPropagator.cs" />
+    <Compile Include="SMAPI\Metadata\InstructionMetadata.cs" />
+    <Compile Include="SMAPI\Mod.cs" />
+    <Compile Include="SMAPI\Patches\DialogueErrorPatch.cs" />
+    <Compile Include="SMAPI\Patches\LoadForNewGamePatch.cs" />
+    <Compile Include="SMAPI\Patches\ObjectErrorPatch.cs" />
+    <Compile Include="SMAPI\PatchMode.cs" />
+    <Compile Include="SMAPI\Program.cs" />
+    <Compile Include="SMAPI\SButton.cs" />
+    <Compile Include="SMAPI\SemanticVersion.cs" />
+    <Compile Include="SMAPI\Toolkit\CoreInterfaces\IManifest.cs" />
+    <Compile Include="SMAPI\Toolkit\CoreInterfaces\IManifestContentPackFor.cs" />
+    <Compile Include="SMAPI\Toolkit\CoreInterfaces\IManifestDependency.cs" />
+    <Compile Include="SMAPI\Toolkit\CoreInterfaces\ISemanticVersion.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\MetadataModel.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModDatabase.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModDataField.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModDataFieldKey.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModDataModel.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModDataRecord.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModDataRecordVersionedFields.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModStatus.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModData\ModWarning.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModScanning\ModFolder.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\ModScanning\ModScanner.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\UpdateData\ModRepositoryKey.cs" />
+    <Compile Include="SMAPI\Toolkit\Framework\UpdateData\UpdateKey.cs" />
+    <Compile Include="SMAPI\Toolkit\ModToolkit.cs" />
+    <Compile Include="SMAPI\Toolkit\SemanticVersion.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\Converters\ManifestContentPackForConverter.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\Converters\ManifestDependencyArrayConverter.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\Converters\SemanticVersionConverter.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\Converters\SimpleReadOnlyConverter.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\InternalExtensions.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\JsonHelper.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\Models\Manifest.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\Models\ManifestContentPackFor.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\Models\ManifestDependency.cs" />
+    <Compile Include="SMAPI\Toolkit\Serialisation\SParseException.cs" />
+    <Compile Include="SMAPI\Toolkit\Utilities\FileUtilities.cs" />
+    <Compile Include="SMAPI\Toolkit\Utilities\PathUtilities.cs" />
+    <Compile Include="SMAPI\Translation.cs" />
+    <Compile Include="SMAPI\Utilities\SDate.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="BmFont, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\BmFont.dll</HintPath>
+    </Reference>
+    <Reference Include="Google.Android.Vending.Expansion.Downloader, Version=2.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Google.Android.Vending.Expansion.Downloader.dll</HintPath>
+    </Reference>
+    <Reference Include="Google.Android.Vending.Expansion.ZipFile, Version=2.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Google.Android.Vending.Expansion.ZipFile.dll</HintPath>
+    </Reference>
+    <Reference Include="Google.Android.Vending.Licensing, Version=2.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Google.Android.Vending.Licensing.dll</HintPath>
+    </Reference>
+    <Reference Include="Java.Interop, Version=0.1.0.0, Culture=neutral, PublicKeyToken=84e04ff9cfb79065, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Java.Interop.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.AppCenter, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Microsoft.AppCenter.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.AppCenter.Analytics, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Microsoft.AppCenter.Analytics.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.AppCenter.Analytics.Android.Bindings, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Microsoft.AppCenter.Analytics.Android.Bindings.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.AppCenter.Android.Bindings, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Microsoft.AppCenter.Android.Bindings.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.AppCenter.Crashes, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Microsoft.AppCenter.Crashes.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.AppCenter.Crashes.Android.Bindings, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Microsoft.AppCenter.Crashes.Android.Bindings.dll</HintPath>
+    </Reference>
+    <Reference Include="Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=84e04ff9cfb79065, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Mono.Android.dll</HintPath>
+    </Reference>
+    <Reference Include="Mono.Security, Version=2.0.5.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Mono.Security.dll</HintPath>
+    </Reference>
+    <Reference Include="MonoGame.Framework, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\MonoGame.Framework.dll</HintPath>
+    </Reference>
+    <Reference Include="StardewValley.Mod, Version=1.3.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\StardewValley.Mod.dll</HintPath>
+    </Reference>
+    <Reference Include="System, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e">
+      <HintPath>..\..\assemblies\System.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e">
+      <HintPath>..\..\assemblies\System.Xml</HintPath>
+    </Reference>
+    <Reference Include="System.Net.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+      <HintPath>..\..\assemblies\System.Net.Http</HintPath>
+    </Reference>
+    <Reference Include="System.Runtime.Serialization, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e">
+      <HintPath>..\..\assemblies\System.Runtime.Serialization</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Arch.Core.Common, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Arch.Core.Common.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Arch.Lifecycle.Common, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Arch.Lifecycle.Common.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Arch.Lifecycle.Runtime, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Arch.Lifecycle.Runtime.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Support.Annotations, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Support.Annotations.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Support.Compat, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Support.Compat.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Support.Core.UI, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Support.Core.UI.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Support.Core.Utils, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Support.Core.Utils.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Support.Fragment, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Support.Fragment.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Support.Media.Compat, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Support.Media.Compat.dll</HintPath>
+    </Reference>
+    <Reference Include="Xamarin.Android.Support.v4, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\Xamarin.Android.Support.v4.dll</HintPath>
+    </Reference>
+    <Reference Include="xTile, Version=1.0.7033.16602, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\assemblies\xTile.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Newtonsoft.Json\Dynamic.snk" />
+    <None Include="Newtonsoft.Json\Newtonsoft.Json.ruleset" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Newtonsoft.Json\Newtonsoft.Json.csproj" />
+    <Content Include="SMAPI\icon.ico" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/src/Mod.sln b/src/Mod.sln
new file mode 100644
index 00000000..0bacb992
--- /dev/null
+++ b/src/Mod.sln
@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.28307.572
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mod", "Mod.csproj", "{23B6885E-0282-435B-A854-D49ABF1391D6}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{23B6885E-0282-435B-A854-D49ABF1391D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{23B6885E-0282-435B-A854-D49ABF1391D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{23B6885E-0282-435B-A854-D49ABF1391D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{23B6885E-0282-435B-A854-D49ABF1391D6}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C26EAB4E-1CDD-43D2-98C8-69FEC9AAC386}
+	EndGlobalSection
+EndGlobal
diff --git a/src/ModEntry.cs b/src/ModEntry.cs
new file mode 100644
index 00000000..c5d675df
--- /dev/null
+++ b/src/ModEntry.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using StardewValley;
+using StardewValley.Menus;
+using StardewModdingAPI.Framework;
+using StardewModdingAPI.Framework.Events;
+using StardewModdingAPI.Framework.ModHelpers;
+using StardewModdingAPI.Framework.Reflection;
+using StardewModdingAPI;
+using StardewModdingAPI.Events;
+using StardewModdingAPI.Framework.Logging;
+using System.Threading;
+using StardewModdingAPI.Internal.ConsoleWriting;
+using StardewModdingAPI.Toolkit.Serialisation;
+using StardewModdingAPI.Framework.Input;
+
+namespace SMDroid
+{
+    public class ModEntry : ModHooks
+    {
+
+        private SCore core;
+        /// <summary>Whether the next content manager requested by the game will be for <see cref="Game1.content"/>.</summary>
+        private bool NextContentManagerIsMain;
+        /// <summary>SMAPI's content manager.</summary>
+        private ContentCoordinator ContentCore { get; set; }
+
+
+        public ModEntry()
+        {
+            this.core = new SCore("/sdcard/SMDroid/Mods", false);
+        }
+        public override LocalizedContentManager OnGame1_CreateContentManager(IServiceProvider serviceProvider, string rootDirectory)
+        {
+            // Game1._temporaryContent initialising from SGame constructor
+            // NOTE: this method is called before the SGame constructor runs. Don't depend on anything being initialised at this point.
+            if (this.ContentCore == null)
+            {
+                this.ContentCore = new ContentCoordinator(serviceProvider, rootDirectory, Thread.CurrentThread.CurrentUICulture, SGame.ConstructorHack.Monitor, SGame.ConstructorHack.Reflection, SGame.ConstructorHack.JsonHelper, SGame.OnLoadingFirstAsset ?? SGame.ConstructorHack?.OnLoadingFirstAsset);
+                this.NextContentManagerIsMain = true;
+                this.core.RunInteractively(this.ContentCore);
+                return this.ContentCore.CreateGameContentManager("Game1._temporaryContent");
+            }
+
+            // Game1.content initialising from LoadContent
+            if (this.NextContentManagerIsMain)
+            {
+                this.NextContentManagerIsMain = false;
+                return this.ContentCore.MainContentManager;
+            }
+
+            // any other content manager
+            return this.ContentCore.CreateGameContentManager("(generated)");
+        }
+        public override void OnGame1_Update(GameTime time)
+        {
+            this.core.GameInstance.Update(time);
+        }
+        public override void OnGame1_NewDayAfterFade(Action action)
+        {
+            this.core.GameInstance.OnNewDayAfterFade();
+            base.OnGame1_NewDayAfterFade(action);
+        }
+    }
+}
diff --git a/src/Mono/Cecil/ArrayType.cs b/src/Mono/Cecil/ArrayType.cs
new file mode 100644
index 00000000..010049cc
--- /dev/null
+++ b/src/Mono/Cecil/ArrayType.cs
@@ -0,0 +1,141 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+using Mono.Collections.Generic;
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public struct ArrayDimension {
+
+		int? lower_bound;
+		int? upper_bound;
+
+		public int? LowerBound {
+			get { return lower_bound; }
+			set { lower_bound = value; }
+		}
+
+		public int? UpperBound {
+			get { return upper_bound; }
+			set { upper_bound = value; }
+		}
+
+		public bool IsSized {
+			get { return lower_bound.HasValue || upper_bound.HasValue; }
+		}
+
+		public ArrayDimension (int? lowerBound, int? upperBound)
+		{
+			this.lower_bound = lowerBound;
+			this.upper_bound = upperBound;
+		}
+
+		public override string ToString ()
+		{
+			return !IsSized
+				? string.Empty
+				: lower_bound + "..." + upper_bound;
+		}
+	}
+
+	public sealed class ArrayType : TypeSpecification {
+
+		Collection<ArrayDimension> dimensions;
+
+		public Collection<ArrayDimension> Dimensions {
+			get {
+				if (dimensions != null)
+					return dimensions;
+
+				dimensions = new Collection<ArrayDimension> ();
+				dimensions.Add (new ArrayDimension ());
+				return dimensions;
+			}
+		}
+
+		public int Rank {
+			get { return dimensions == null ? 1 : dimensions.Count; }
+		}
+
+		public bool IsVector {
+			get {
+				if (dimensions == null)
+					return true;
+
+				if (dimensions.Count > 1)
+					return false;
+
+				var dimension = dimensions [0];
+
+				return !dimension.IsSized;
+			}
+		}
+
+		public override bool IsValueType {
+			get { return false; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override string Name {
+			get { return base.Name + Suffix; }
+		}
+
+		public override string FullName {
+			get { return base.FullName + Suffix; }
+		}
+
+		string Suffix {
+			get {
+				if (IsVector)
+					return "[]";
+
+				var suffix = new StringBuilder ();
+				suffix.Append ("[");
+				for (int i = 0; i < dimensions.Count; i++) {
+					if (i > 0)
+						suffix.Append (",");
+
+					suffix.Append (dimensions [i].ToString ());
+				}
+				suffix.Append ("]");
+
+				return suffix.ToString ();
+			}
+		}
+
+		public override bool IsArray {
+			get { return true; }
+		}
+
+		public ArrayType (TypeReference type)
+			: base (type)
+		{
+			Mixin.CheckType (type);
+			this.etype = MD.ElementType.Array;
+		}
+
+		public ArrayType (TypeReference type, int rank)
+			: this (type)
+		{
+			Mixin.CheckType (type);
+
+			if (rank == 1)
+				return;
+
+			dimensions = new Collection<ArrayDimension> (rank);
+			for (int i = 0; i < rank; i++)
+				dimensions.Add (new ArrayDimension ());
+			this.etype = MD.ElementType.Array;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyDefinition.cs b/src/Mono/Cecil/AssemblyDefinition.cs
new file mode 100644
index 00000000..f02b93f2
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyDefinition.cs
@@ -0,0 +1,194 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.IO;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class AssemblyDefinition : ICustomAttributeProvider, ISecurityDeclarationProvider, IDisposable {
+
+		AssemblyNameDefinition name;
+
+		internal ModuleDefinition main_module;
+		Collection<ModuleDefinition> modules;
+		Collection<CustomAttribute> custom_attributes;
+		Collection<SecurityDeclaration> security_declarations;
+
+		public AssemblyNameDefinition Name {
+			get { return name; }
+			set { name = value; }
+		}
+
+		public string FullName {
+			get { return name != null ? name.FullName : string.Empty; }
+		}
+
+		public MetadataToken MetadataToken {
+			get { return new MetadataToken (TokenType.Assembly, 1); }
+			set { }
+		}
+
+		public Collection<ModuleDefinition> Modules {
+			get {
+				if (modules != null)
+					return modules;
+
+				if (main_module.HasImage)
+					return main_module.Read (ref modules, this, (_, reader) => reader.ReadModules ());
+
+				return modules = new Collection<ModuleDefinition> (1) { main_module };
+			}
+		}
+
+		public ModuleDefinition MainModule {
+			get { return main_module; }
+		}
+
+		public MethodDefinition EntryPoint {
+			get { return main_module.EntryPoint; }
+			set { main_module.EntryPoint = value; }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (main_module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, main_module)); }
+		}
+
+		public bool HasSecurityDeclarations {
+			get {
+				if (security_declarations != null)
+					return security_declarations.Count > 0;
+
+				return this.GetHasSecurityDeclarations (main_module);
+			}
+		}
+
+		public Collection<SecurityDeclaration> SecurityDeclarations {
+			get { return security_declarations ?? (this.GetSecurityDeclarations (ref security_declarations, main_module)); }
+		}
+
+		internal AssemblyDefinition ()
+		{
+		}
+
+		public void Dispose ()
+		{
+			if (this.modules == null) {
+				main_module.Dispose ();
+				return;
+			}
+
+			var modules = this.Modules;
+			for (int i = 0; i < modules.Count; i++)
+				modules [i].Dispose ();
+		}
+
+#if !READ_ONLY
+		public static AssemblyDefinition CreateAssembly (AssemblyNameDefinition assemblyName, string moduleName, ModuleKind kind)
+		{
+			return CreateAssembly (assemblyName, moduleName, new ModuleParameters { Kind = kind });
+		}
+
+		public static AssemblyDefinition CreateAssembly (AssemblyNameDefinition assemblyName, string moduleName, ModuleParameters parameters)
+		{
+			if (assemblyName == null)
+				throw new ArgumentNullException ("assemblyName");
+			if (moduleName == null)
+				throw new ArgumentNullException ("moduleName");
+			Mixin.CheckParameters (parameters);
+			if (parameters.Kind == ModuleKind.NetModule)
+				throw new ArgumentException ("kind");
+
+			var assembly = ModuleDefinition.CreateModule (moduleName, parameters).Assembly;
+			assembly.Name = assemblyName;
+
+			return assembly;
+		}
+#endif
+
+		public static AssemblyDefinition ReadAssembly (string fileName)
+		{
+			return ReadAssembly (ModuleDefinition.ReadModule (fileName));
+		}
+
+		public static AssemblyDefinition ReadAssembly (string fileName, ReaderParameters parameters)
+		{
+			return ReadAssembly (ModuleDefinition.ReadModule (fileName, parameters));
+		}
+
+		public static AssemblyDefinition ReadAssembly (Stream stream)
+		{
+			return ReadAssembly (ModuleDefinition.ReadModule (stream));
+		}
+
+		public static AssemblyDefinition ReadAssembly (Stream stream, ReaderParameters parameters)
+		{
+			return ReadAssembly (ModuleDefinition.ReadModule (stream, parameters));
+		}
+
+		static AssemblyDefinition ReadAssembly (ModuleDefinition module)
+		{
+			var assembly = module.Assembly;
+			if (assembly == null)
+				throw new ArgumentException ();
+
+			return assembly;
+		}
+
+#if !READ_ONLY
+
+		public void Write (string fileName)
+		{
+			Write (fileName, new WriterParameters ());
+		}
+
+		public void Write (string fileName, WriterParameters parameters)
+		{
+			main_module.Write (fileName, parameters);
+		}
+
+		public void Write ()
+		{
+			main_module.Write ();
+		}
+
+		public void Write (WriterParameters parameters)
+		{
+			main_module.Write (parameters);
+		}
+
+		public void Write (Stream stream)
+		{
+			Write (stream, new WriterParameters ());
+		}
+
+		public void Write (Stream stream, WriterParameters parameters)
+		{
+			main_module.Write (stream, parameters);
+		}
+#endif
+
+		public override string ToString ()
+		{
+			return this.FullName;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyFlags.cs b/src/Mono/Cecil/AssemblyFlags.cs
new file mode 100644
index 00000000..6ca5bc27
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyFlags.cs
@@ -0,0 +1,24 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum AssemblyAttributes : uint {
+		PublicKey					 	= 0x0001,
+		SideBySideCompatible			= 0x0000,
+		Retargetable					= 0x0100,
+		WindowsRuntime					= 0x0200,
+		DisableJITCompileOptimizer		= 0x4000,
+		EnableJITCompileTracking		= 0x8000,
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyHashAlgorithm.cs b/src/Mono/Cecil/AssemblyHashAlgorithm.cs
new file mode 100644
index 00000000..66ef4cbb
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyHashAlgorithm.cs
@@ -0,0 +1,18 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum AssemblyHashAlgorithm : uint {
+		None		= 0x0000,
+		Reserved	= 0x8003,	// MD5
+		SHA1		= 0x8004
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyLinkedResource.cs b/src/Mono/Cecil/AssemblyLinkedResource.cs
new file mode 100644
index 00000000..f4896bd2
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyLinkedResource.cs
@@ -0,0 +1,39 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public sealed class AssemblyLinkedResource : Resource {
+
+		AssemblyNameReference reference;
+
+		public AssemblyNameReference Assembly {
+			get { return reference; }
+			set { reference = value; }
+		}
+
+		public override ResourceType ResourceType {
+			get { return ResourceType.AssemblyLinked; }
+		}
+
+		public AssemblyLinkedResource (string name, ManifestResourceAttributes flags)
+			: base (name, flags)
+		{
+		}
+
+		public AssemblyLinkedResource (string name, ManifestResourceAttributes flags, AssemblyNameReference reference)
+			: base (name, flags)
+		{
+			this.reference = reference;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyNameDefinition.cs b/src/Mono/Cecil/AssemblyNameDefinition.cs
new file mode 100644
index 00000000..2511d793
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyNameDefinition.cs
@@ -0,0 +1,32 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public sealed class AssemblyNameDefinition : AssemblyNameReference {
+
+		public override byte [] Hash {
+			get { return Empty<byte>.Array; }
+		}
+
+		internal AssemblyNameDefinition ()
+		{
+			this.token = new MetadataToken (TokenType.Assembly, 1);
+		}
+
+		public AssemblyNameDefinition (string name, Version version)
+			: base (name, version)
+		{
+			this.token = new MetadataToken (TokenType.Assembly, 1);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyNameReference.cs b/src/Mono/Cecil/AssemblyNameReference.cs
new file mode 100644
index 00000000..1d12cc16
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyNameReference.cs
@@ -0,0 +1,266 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Globalization;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Mono.Cecil {
+
+	public class AssemblyNameReference : IMetadataScope {
+
+		string name;
+		string culture;
+		Version version;
+		uint attributes;
+		byte [] public_key;
+		byte [] public_key_token;
+		AssemblyHashAlgorithm hash_algorithm;
+		byte [] hash;
+
+		internal MetadataToken token;
+
+		string full_name;
+
+		public string Name {
+			get { return name; }
+			set {
+				name = value;
+				full_name = null;
+			}
+		}
+
+		public string Culture {
+			get { return culture; }
+			set {
+				culture = value;
+				full_name = null;
+			}
+		}
+
+		public Version Version {
+			get { return version; }
+			set {
+				version = Mixin.CheckVersion (value);
+				full_name = null;
+			}
+		}
+
+		public AssemblyAttributes Attributes {
+			get { return (AssemblyAttributes) attributes; }
+			set { attributes = (uint) value; }
+		}
+
+		public bool HasPublicKey {
+			get { return attributes.GetAttributes ((uint) AssemblyAttributes.PublicKey); }
+			set { attributes = attributes.SetAttributes ((uint) AssemblyAttributes.PublicKey, value); }
+		}
+
+		public bool IsSideBySideCompatible {
+			get { return attributes.GetAttributes ((uint) AssemblyAttributes.SideBySideCompatible); }
+			set { attributes = attributes.SetAttributes ((uint) AssemblyAttributes.SideBySideCompatible, value); }
+		}
+
+		public bool IsRetargetable {
+			get { return attributes.GetAttributes ((uint) AssemblyAttributes.Retargetable); }
+			set { attributes = attributes.SetAttributes ((uint) AssemblyAttributes.Retargetable, value); }
+		}
+
+		public bool IsWindowsRuntime {
+			get { return attributes.GetAttributes ((uint) AssemblyAttributes.WindowsRuntime); }
+			set { attributes = attributes.SetAttributes ((uint) AssemblyAttributes.WindowsRuntime, value); }
+		}
+
+		public byte [] PublicKey {
+			get { return public_key ?? Empty<byte>.Array; }
+			set {
+				public_key = value;
+				HasPublicKey = !public_key.IsNullOrEmpty ();
+				public_key_token = Empty<byte>.Array;
+				full_name = null;
+			}
+		}
+
+		public byte [] PublicKeyToken {
+			get {
+				if (public_key_token.IsNullOrEmpty () && !public_key.IsNullOrEmpty ()) {
+					var hash = HashPublicKey ();
+					// we need the last 8 bytes in reverse order
+					var local_public_key_token = new byte [8];
+					Array.Copy (hash, (hash.Length - 8), local_public_key_token, 0, 8);
+					Array.Reverse (local_public_key_token, 0, 8);
+					public_key_token = local_public_key_token; // publish only once finished (required for thread-safety)
+				}
+				return public_key_token ?? Empty<byte>.Array;
+			}
+			set {
+				public_key_token = value;
+				full_name = null;
+			}
+		}
+
+		byte [] HashPublicKey ()
+		{
+			HashAlgorithm algorithm;
+
+			switch (hash_algorithm) {
+			case AssemblyHashAlgorithm.Reserved:
+				algorithm = MD5.Create ();
+				break;
+			default:
+				// None default to SHA1
+				algorithm = SHA1.Create ();
+				break;
+			}
+
+			using (algorithm)
+				return algorithm.ComputeHash (public_key);
+		}
+
+		public virtual MetadataScopeType MetadataScopeType {
+			get { return MetadataScopeType.AssemblyNameReference; }
+		}
+
+		public string FullName {
+			get {
+				if (full_name != null)
+					return full_name;
+
+				const string sep = ", ";
+
+				var builder = new StringBuilder ();
+				builder.Append (name);
+				builder.Append (sep);
+				builder.Append ("Version=");
+				builder.Append (version.ToString (fieldCount: 4));
+				builder.Append (sep);
+				builder.Append ("Culture=");
+				builder.Append (string.IsNullOrEmpty (culture) ? "neutral" : culture);
+				builder.Append (sep);
+				builder.Append ("PublicKeyToken=");
+
+				var pk_token = PublicKeyToken;
+				if (!pk_token.IsNullOrEmpty () && pk_token.Length > 0) {
+					for (int i = 0 ; i < pk_token.Length ; i++) {
+						builder.Append (pk_token [i].ToString ("x2"));
+					}
+				} else
+					builder.Append ("null");
+
+				if (IsRetargetable) {
+					builder.Append (sep);
+					builder.Append ("Retargetable=Yes");
+				}
+
+				return full_name = builder.ToString ();
+			}
+		}
+
+		public static AssemblyNameReference Parse (string fullName)
+		{
+			if (fullName == null)
+				throw new ArgumentNullException ("fullName");
+			if (fullName.Length == 0)
+				throw new ArgumentException ("Name can not be empty");
+
+			var name = new AssemblyNameReference ();
+			var tokens = fullName.Split (',');
+			for (int i = 0; i < tokens.Length; i++) {
+				var token = tokens [i].Trim ();
+
+				if (i == 0) {
+					name.Name = token;
+					continue;
+				}
+
+				var parts = token.Split ('=');
+				if (parts.Length != 2)
+					throw new ArgumentException ("Malformed name");
+
+				switch (parts [0].ToLowerInvariant ()) {
+				case "version":
+					name.Version = new Version (parts [1]);
+					break;
+				case "culture":
+					name.Culture = parts [1] == "neutral" ? "" : parts [1];
+					break;
+				case "publickeytoken":
+					var pk_token = parts [1];
+					if (pk_token == "null")
+						break;
+
+					name.PublicKeyToken = new byte [pk_token.Length / 2];
+					for (int j = 0; j < name.PublicKeyToken.Length; j++)
+						name.PublicKeyToken [j] = Byte.Parse (pk_token.Substring (j * 2, 2), NumberStyles.HexNumber);
+
+					break;
+				}
+			}
+
+			return name;
+		}
+
+		public AssemblyHashAlgorithm HashAlgorithm {
+			get { return hash_algorithm; }
+			set { hash_algorithm = value; }
+		}
+
+		public virtual byte [] Hash {
+			get { return hash; }
+			set { hash = value; }
+		}
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		internal AssemblyNameReference ()
+		{
+			this.version = Mixin.ZeroVersion;
+			this.token = new MetadataToken (TokenType.AssemblyRef);
+		}
+
+		public AssemblyNameReference (string name, Version version)
+		{
+			Mixin.CheckName (name);
+
+			this.name = name;
+			this.version = Mixin.CheckVersion (version);
+			this.hash_algorithm = AssemblyHashAlgorithm.None;
+			this.token = new MetadataToken (TokenType.AssemblyRef);
+		}
+
+		public override string ToString ()
+		{
+			return this.FullName;
+		}
+	}
+
+	partial class Mixin {
+
+		public static Version ZeroVersion = new Version (0, 0, 0 ,0);
+
+		public static Version CheckVersion (Version version)
+		{
+			if (version == null)
+				return ZeroVersion;
+
+			if (version.Build == -1)
+				return new Version (version.Major, version.Minor, 0, 0);
+
+			if (version.Revision == -1)
+				return new Version (version.Major, version.Minor, version.Build, 0);
+
+			return version;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyReader.cs b/src/Mono/Cecil/AssemblyReader.cs
new file mode 100644
index 00000000..bf16b8a6
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyReader.cs
@@ -0,0 +1,3862 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Text;
+
+using Mono.Collections.Generic;
+using Mono.Cecil.Cil;
+using Mono.Cecil.Metadata;
+using Mono.Cecil.PE;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil {
+
+	abstract class ModuleReader {
+
+		readonly protected ModuleDefinition module;
+
+		protected ModuleReader (Image image, ReadingMode mode)
+		{
+			this.module = new ModuleDefinition (image);
+			this.module.ReadingMode = mode;
+		}
+
+		protected abstract void ReadModule ();
+		public abstract void ReadSymbols (ModuleDefinition module);
+
+		protected void ReadModuleManifest (MetadataReader reader)
+		{
+			reader.Populate (module);
+
+			ReadAssembly (reader);
+		}
+
+		void ReadAssembly (MetadataReader reader)
+		{
+			var name = reader.ReadAssemblyNameDefinition ();
+			if (name == null) {
+				module.kind = ModuleKind.NetModule;
+				return;
+			}
+
+			var assembly = new AssemblyDefinition ();
+			assembly.Name = name;
+
+			module.assembly = assembly;
+			assembly.main_module = module;
+		}
+
+		public static ModuleDefinition CreateModule (Image image, ReaderParameters parameters)
+		{
+			var reader = CreateModuleReader (image, parameters.ReadingMode);
+			var module = reader.module;
+
+			if (parameters.assembly_resolver != null)
+				module.assembly_resolver = Disposable.NotOwned (parameters.assembly_resolver);
+
+			if (parameters.metadata_resolver != null)
+				module.metadata_resolver = parameters.metadata_resolver;
+
+#if !READ_ONLY
+			if (parameters.metadata_importer_provider != null)
+				module.metadata_importer = parameters.metadata_importer_provider.GetMetadataImporter (module);
+			if (parameters.reflection_importer_provider != null)
+				module.reflection_importer = parameters.reflection_importer_provider.GetReflectionImporter (module);
+#endif
+
+			GetMetadataKind (module, parameters);
+
+			reader.ReadModule ();
+
+			ReadSymbols (module, parameters);
+
+			reader.ReadSymbols (module);
+
+			if (parameters.ReadingMode == ReadingMode.Immediate)
+				module.MetadataSystem.Clear ();
+
+			return module;
+		}
+
+		static void ReadSymbols (ModuleDefinition module, ReaderParameters parameters)
+		{
+			var symbol_reader_provider = parameters.SymbolReaderProvider;
+
+			if (symbol_reader_provider == null && parameters.ReadSymbols)
+				symbol_reader_provider = new DefaultSymbolReaderProvider ();
+
+			if (symbol_reader_provider != null) {
+				module.SymbolReaderProvider = symbol_reader_provider;
+
+				var reader = parameters.SymbolStream != null
+					? symbol_reader_provider.GetSymbolReader (module, parameters.SymbolStream)
+					: symbol_reader_provider.GetSymbolReader (module, module.FileName);
+
+				if (reader != null)
+					module.ReadSymbols (reader, parameters.ThrowIfSymbolsAreNotMatching);
+			}
+
+			if (module.Image.HasDebugTables ())
+				module.ReadSymbols (new PortablePdbReader (module.Image, module));
+		}
+
+		static void GetMetadataKind (ModuleDefinition module, ReaderParameters parameters)
+		{
+			if (!parameters.ApplyWindowsRuntimeProjections) {
+				module.MetadataKind = MetadataKind.Ecma335;
+				return;
+			}
+
+			var runtime_version = module.RuntimeVersion;
+
+			if (!runtime_version.Contains ("WindowsRuntime"))
+				module.MetadataKind = MetadataKind.Ecma335;
+			else if (runtime_version.Contains ("CLR"))
+				module.MetadataKind = MetadataKind.ManagedWindowsMetadata;
+			else
+				module.MetadataKind = MetadataKind.WindowsMetadata;
+		}
+
+		static ModuleReader CreateModuleReader (Image image, ReadingMode mode)
+		{
+			switch (mode) {
+			case ReadingMode.Immediate:
+				return new ImmediateModuleReader (image);
+			case ReadingMode.Deferred:
+				return new DeferredModuleReader (image);
+			default:
+				throw new ArgumentException ();
+			}
+		}
+	}
+
+	sealed class ImmediateModuleReader : ModuleReader {
+
+		bool resolve_attributes;
+
+		public ImmediateModuleReader (Image image)
+			: base (image, ReadingMode.Immediate)
+		{
+		}
+
+		protected override void ReadModule ()
+		{
+			this.module.Read (this.module, (module, reader) => {
+				ReadModuleManifest (reader);
+				ReadModule (module, resolve_attributes: true);
+			});
+		}
+
+		public void ReadModule (ModuleDefinition module, bool resolve_attributes)
+		{
+			this.resolve_attributes = resolve_attributes;
+
+			if (module.HasAssemblyReferences)
+				Mixin.Read (module.AssemblyReferences);
+			if (module.HasResources)
+				Mixin.Read (module.Resources);
+			if (module.HasModuleReferences)
+				Mixin.Read (module.ModuleReferences);
+			if (module.HasTypes)
+				ReadTypes (module.Types);
+			if (module.HasExportedTypes)
+				Mixin.Read (module.ExportedTypes);
+
+			ReadCustomAttributes (module);
+
+			var assembly = module.Assembly;
+			if (assembly == null)
+				return;
+
+			ReadCustomAttributes (assembly);
+			ReadSecurityDeclarations (assembly);
+		}
+
+		void ReadTypes (Collection<TypeDefinition> types)
+		{
+			for (int i = 0; i < types.Count; i++)
+				ReadType (types [i]);
+		}
+
+		void ReadType (TypeDefinition type)
+		{
+			ReadGenericParameters (type);
+
+			if (type.HasInterfaces)
+				ReadInterfaces (type);
+
+			if (type.HasNestedTypes)
+				ReadTypes (type.NestedTypes);
+
+			if (type.HasLayoutInfo)
+				Mixin.Read (type.ClassSize);
+
+			if (type.HasFields)
+				ReadFields (type);
+
+			if (type.HasMethods)
+				ReadMethods (type);
+
+			if (type.HasProperties)
+				ReadProperties (type);
+
+			if (type.HasEvents)
+				ReadEvents (type);
+
+			ReadSecurityDeclarations (type);
+			ReadCustomAttributes (type);
+		}
+
+		void ReadInterfaces (TypeDefinition type)
+		{
+			var interfaces = type.Interfaces;
+
+			for (int i = 0; i < interfaces.Count; i++)
+				ReadCustomAttributes (interfaces [i]);
+		}
+
+		void ReadGenericParameters (IGenericParameterProvider provider)
+		{
+			if (!provider.HasGenericParameters)
+				return;
+
+			var parameters = provider.GenericParameters;
+
+			for (int i = 0; i < parameters.Count; i++) {
+				var parameter = parameters [i];
+
+				if (parameter.HasConstraints)
+					Mixin.Read (parameter.Constraints);
+
+				ReadCustomAttributes (parameter);
+			}
+		}
+
+		void ReadSecurityDeclarations (ISecurityDeclarationProvider provider)
+		{
+			if (!provider.HasSecurityDeclarations)
+				return;
+
+			var security_declarations = provider.SecurityDeclarations;
+
+			if (!resolve_attributes)
+				return;
+
+			for (int i = 0; i < security_declarations.Count; i++) {
+				var security_declaration = security_declarations [i];
+
+				Mixin.Read (security_declaration.SecurityAttributes);
+			}
+		}
+
+		void ReadCustomAttributes (ICustomAttributeProvider provider)
+		{
+			if (!provider.HasCustomAttributes)
+				return;
+
+			var custom_attributes = provider.CustomAttributes;
+
+			if (!resolve_attributes)
+				return;
+
+			for (int i = 0; i < custom_attributes.Count; i++) {
+				var custom_attribute = custom_attributes [i];
+
+				Mixin.Read (custom_attribute.ConstructorArguments);
+			}
+		}
+
+		void ReadFields (TypeDefinition type)
+		{
+			var fields = type.Fields;
+
+			for (int i = 0; i < fields.Count; i++) {
+				var field = fields [i];
+
+				if (field.HasConstant)
+					Mixin.Read (field.Constant);
+
+				if (field.HasLayoutInfo)
+					Mixin.Read (field.Offset);
+
+				if (field.RVA > 0)
+					Mixin.Read (field.InitialValue);
+
+				if (field.HasMarshalInfo)
+					Mixin.Read (field.MarshalInfo);
+
+				ReadCustomAttributes (field);
+			}
+		}
+
+		void ReadMethods (TypeDefinition type)
+		{
+			var methods = type.Methods;
+
+			for (int i = 0; i < methods.Count; i++) {
+				var method = methods [i];
+
+				ReadGenericParameters (method);
+
+				if (method.HasParameters)
+					ReadParameters (method);
+
+				if (method.HasOverrides)
+					Mixin.Read (method.Overrides);
+
+				if (method.IsPInvokeImpl)
+					Mixin.Read (method.PInvokeInfo);
+
+				ReadSecurityDeclarations (method);
+				ReadCustomAttributes (method);
+
+				var return_type = method.MethodReturnType;
+				if (return_type.HasConstant)
+					Mixin.Read (return_type.Constant);
+
+				if (return_type.HasMarshalInfo)
+					Mixin.Read (return_type.MarshalInfo);
+
+				ReadCustomAttributes (return_type);
+			}
+		}
+
+		void ReadParameters (MethodDefinition method)
+		{
+			var parameters = method.Parameters;
+
+			for (int i = 0; i < parameters.Count; i++) {
+				var parameter = parameters [i];
+
+				if (parameter.HasConstant)
+					Mixin.Read (parameter.Constant);
+
+				if (parameter.HasMarshalInfo)
+					Mixin.Read (parameter.MarshalInfo);
+
+				ReadCustomAttributes (parameter);
+			}
+		}
+
+		void ReadProperties (TypeDefinition type)
+		{
+			var properties = type.Properties;
+
+			for (int i = 0; i < properties.Count; i++) {
+				var property = properties [i];
+
+				Mixin.Read (property.GetMethod);
+
+				if (property.HasConstant)
+					Mixin.Read (property.Constant);
+
+				ReadCustomAttributes (property);
+			}
+		}
+
+		void ReadEvents (TypeDefinition type)
+		{
+			var events = type.Events;
+
+			for (int i = 0; i < events.Count; i++) {
+				var @event = events [i];
+
+				Mixin.Read (@event.AddMethod);
+
+				ReadCustomAttributes (@event);
+			}
+		}
+
+		public override void ReadSymbols (ModuleDefinition module)
+		{
+			if (module.symbol_reader == null)
+				return;
+
+			ReadTypesSymbols (module.Types, module.symbol_reader);
+		}
+
+		void ReadTypesSymbols (Collection<TypeDefinition> types, ISymbolReader symbol_reader)
+		{
+			for (int i = 0; i < types.Count; i++) {
+				var type = types [i];
+
+				if (type.HasNestedTypes)
+					ReadTypesSymbols (type.NestedTypes, symbol_reader);
+
+				if (type.HasMethods)
+					ReadMethodsSymbols (type, symbol_reader);
+			}
+		}
+
+		void ReadMethodsSymbols (TypeDefinition type, ISymbolReader symbol_reader)
+		{
+			var methods = type.Methods;
+			for (int i = 0; i < methods.Count; i++) {
+				var method = methods [i];
+
+				if (method.HasBody && method.token.RID != 0 && method.debug_info == null)
+					method.debug_info = symbol_reader.Read (method);
+			}
+		}
+	}
+
+	sealed class DeferredModuleReader : ModuleReader {
+
+		public DeferredModuleReader (Image image)
+			: base (image, ReadingMode.Deferred)
+		{
+		}
+
+		protected override void ReadModule ()
+		{
+			this.module.Read (this.module, (_, reader) => ReadModuleManifest (reader));
+		}
+
+		public override void ReadSymbols (ModuleDefinition module)
+		{
+		}
+	}
+
+	sealed class MetadataReader : ByteBuffer {
+
+		readonly internal Image image;
+		readonly internal ModuleDefinition module;
+		readonly internal MetadataSystem metadata;
+
+		internal CodeReader code;
+		internal IGenericContext context;
+
+		readonly MetadataReader metadata_reader;
+
+		public MetadataReader (ModuleDefinition module)
+			: base (module.Image.TableHeap.data)
+		{
+			this.image = module.Image;
+			this.module = module;
+			this.metadata = module.MetadataSystem;
+			this.code = new CodeReader (this);
+		}
+
+		public MetadataReader (Image image, ModuleDefinition module, MetadataReader metadata_reader)
+			: base (image.TableHeap.data)
+		{
+			this.image = image;
+			this.module = module;
+			this.metadata = module.MetadataSystem;
+			this.metadata_reader = metadata_reader;
+		}
+
+		int GetCodedIndexSize (CodedIndex index)
+		{
+			return image.GetCodedIndexSize (index);
+		}
+
+		uint ReadByIndexSize (int size)
+		{
+			if (size == 4)
+				return ReadUInt32 ();
+			else
+				return ReadUInt16 ();
+		}
+
+		byte [] ReadBlob ()
+		{
+			var blob_heap = image.BlobHeap;
+			if (blob_heap == null) {
+				position += 2;
+				return Empty<byte>.Array;
+			}
+
+			return blob_heap.Read (ReadBlobIndex ());
+		}
+
+		byte [] ReadBlob (uint signature)
+		{
+			var blob_heap = image.BlobHeap;
+			if (blob_heap == null)
+				return Empty<byte>.Array;
+
+			return blob_heap.Read (signature);
+		}
+
+		uint ReadBlobIndex ()
+		{
+			var blob_heap = image.BlobHeap;
+			return ReadByIndexSize (blob_heap != null ? blob_heap.IndexSize : 2);
+		}
+
+		void GetBlobView (uint signature, out byte [] blob, out int index, out int count)
+		{
+			var blob_heap = image.BlobHeap;
+			if (blob_heap == null) {
+				blob = null;
+				index = count = 0;
+				return;
+			}
+
+			blob_heap.GetView (signature, out blob, out index, out count);
+		}
+
+		string ReadString ()
+		{
+			return image.StringHeap.Read (ReadByIndexSize (image.StringHeap.IndexSize));
+		}
+
+		uint ReadStringIndex ()
+		{
+			return ReadByIndexSize (image.StringHeap.IndexSize);
+		}
+
+		Guid ReadGuid ()
+		{
+			return image.GuidHeap.Read (ReadByIndexSize (image.GuidHeap.IndexSize));
+		}
+
+		uint ReadTableIndex (Table table)
+		{
+			return ReadByIndexSize (image.GetTableIndexSize (table));
+		}
+
+		MetadataToken ReadMetadataToken (CodedIndex index)
+		{
+			return index.GetMetadataToken (ReadByIndexSize (GetCodedIndexSize (index)));
+		}
+
+		int MoveTo (Table table)
+		{
+			var info = image.TableHeap [table];
+			if (info.Length != 0)
+				this.position = (int) info.Offset;
+
+			return (int) info.Length;
+		}
+
+		bool MoveTo (Table table, uint row)
+		{
+			var info = image.TableHeap [table];
+			var length = info.Length;
+			if (length == 0 || row > length)
+				return false;
+
+			this.position = (int) (info.Offset + (info.RowSize * (row - 1)));
+			return true;
+		}
+
+		public AssemblyNameDefinition ReadAssemblyNameDefinition ()
+		{
+			if (MoveTo (Table.Assembly) == 0)
+				return null;
+
+			var name = new AssemblyNameDefinition ();
+
+			name.HashAlgorithm = (AssemblyHashAlgorithm) ReadUInt32 ();
+
+			PopulateVersionAndFlags (name);
+
+			name.PublicKey = ReadBlob ();
+
+			PopulateNameAndCulture (name);
+
+			return name;
+		}
+
+		public ModuleDefinition Populate (ModuleDefinition module)
+		{
+			if (MoveTo (Table.Module) == 0)
+				return module;
+
+			Advance (2); // Generation
+
+			module.Name = ReadString ();
+			module.Mvid = ReadGuid ();
+
+			return module;
+		}
+
+		void InitializeAssemblyReferences ()
+		{
+			if (metadata.AssemblyReferences != null)
+				return;
+
+			int length = MoveTo (Table.AssemblyRef);
+			var references = metadata.AssemblyReferences = new AssemblyNameReference [length];
+
+			for (uint i = 0; i < length; i++) {
+				var reference = new AssemblyNameReference ();
+				reference.token = new MetadataToken (TokenType.AssemblyRef, i + 1);
+
+				PopulateVersionAndFlags (reference);
+
+				var key_or_token = ReadBlob ();
+
+				if (reference.HasPublicKey)
+					reference.PublicKey = key_or_token;
+				else
+					reference.PublicKeyToken = key_or_token;
+
+				PopulateNameAndCulture (reference);
+
+				reference.Hash = ReadBlob ();
+
+				references [i] = reference;
+			}
+		}
+
+		public Collection<AssemblyNameReference> ReadAssemblyReferences ()
+		{
+			InitializeAssemblyReferences ();
+
+			var references = new Collection<AssemblyNameReference> (metadata.AssemblyReferences);
+			if (module.IsWindowsMetadata ())
+				module.Projections.AddVirtualReferences (references);
+
+			return references;
+		}
+
+		public MethodDefinition ReadEntryPoint ()
+		{
+			if (module.Image.EntryPointToken == 0)
+				return null;
+
+			var token = new MetadataToken (module.Image.EntryPointToken);
+			return GetMethodDefinition (token.RID);
+		}
+
+		public Collection<ModuleDefinition> ReadModules ()
+		{
+			var modules = new Collection<ModuleDefinition> (1);
+			modules.Add (this.module);
+
+			int length = MoveTo (Table.File);
+			for (uint i = 1; i <= length; i++) {
+				var attributes = (FileAttributes) ReadUInt32 ();
+				var name = ReadString ();
+				ReadBlobIndex ();
+
+				if (attributes != FileAttributes.ContainsMetaData)
+					continue;
+
+				var parameters = new ReaderParameters {
+					ReadingMode = module.ReadingMode,
+					SymbolReaderProvider = module.SymbolReaderProvider,
+					AssemblyResolver = module.AssemblyResolver
+				};
+
+				modules.Add (ModuleDefinition.ReadModule (
+					GetModuleFileName (name), parameters));
+			}
+
+			return modules;
+		}
+
+		string GetModuleFileName (string name)
+		{
+			if (module.FileName == null)
+				throw new NotSupportedException ();
+
+			var path = Path.GetDirectoryName (module.FileName);
+			return Path.Combine (path, name);
+		}
+
+		void InitializeModuleReferences ()
+		{
+			if (metadata.ModuleReferences != null)
+				return;
+
+			int length = MoveTo (Table.ModuleRef);
+			var references = metadata.ModuleReferences = new ModuleReference [length];
+
+			for (uint i = 0; i < length; i++) {
+				var reference = new ModuleReference (ReadString ());
+				reference.token = new MetadataToken (TokenType.ModuleRef, i + 1);
+
+				references [i] = reference;
+			}
+		}
+
+		public Collection<ModuleReference> ReadModuleReferences ()
+		{
+			InitializeModuleReferences ();
+
+			return new Collection<ModuleReference> (metadata.ModuleReferences);
+		}
+
+		public bool HasFileResource ()
+		{
+			int length = MoveTo (Table.File);
+			if (length == 0)
+				return false;
+
+			for (uint i = 1; i <= length; i++)
+				if (ReadFileRecord (i).Col1 == FileAttributes.ContainsNoMetaData)
+					return true;
+
+			return false;
+		}
+
+		public Collection<Resource> ReadResources ()
+		{
+			int length = MoveTo (Table.ManifestResource);
+			var resources = new Collection<Resource> (length);
+
+			for (int i = 1; i <= length; i++) {
+				var offset = ReadUInt32 ();
+				var flags = (ManifestResourceAttributes) ReadUInt32 ();
+				var name = ReadString ();
+				var implementation = ReadMetadataToken (CodedIndex.Implementation);
+
+				Resource resource;
+
+				if (implementation.RID == 0) {
+					resource = new EmbeddedResource (name, flags, offset, this);
+				} else if (implementation.TokenType == TokenType.AssemblyRef) {
+					resource = new AssemblyLinkedResource (name, flags) {
+						Assembly = (AssemblyNameReference) GetTypeReferenceScope (implementation),
+					};
+				} else if (implementation.TokenType == TokenType.File) {
+					var file_record = ReadFileRecord (implementation.RID);
+
+					resource = new LinkedResource (name, flags) {
+						File = file_record.Col2,
+						hash = ReadBlob (file_record.Col3)
+					};
+				} else
+					continue;
+
+				resources.Add (resource);
+			}
+
+			return resources;
+		}
+
+		Row<FileAttributes, string, uint> ReadFileRecord (uint rid)
+		{
+			var position = this.position;
+
+			if (!MoveTo (Table.File, rid))
+				throw new ArgumentException ();
+
+			var record = new Row<FileAttributes, string, uint> (
+				(FileAttributes) ReadUInt32 (),
+				ReadString (),
+				ReadBlobIndex ());
+
+			this.position = position;
+
+			return record;
+		}
+
+		public byte [] GetManagedResource (uint offset)
+		{
+			return image.GetReaderAt (image.Resources.VirtualAddress, offset, (o, reader) => {
+				reader.Advance ((int) o);
+				return reader.ReadBytes (reader.ReadInt32 ());
+			}) ?? Empty<byte>.Array;
+		}
+
+		void PopulateVersionAndFlags (AssemblyNameReference name)
+		{
+			name.Version = new Version (
+				ReadUInt16 (),
+				ReadUInt16 (),
+				ReadUInt16 (),
+				ReadUInt16 ());
+
+			name.Attributes = (AssemblyAttributes) ReadUInt32 ();
+		}
+
+		void PopulateNameAndCulture (AssemblyNameReference name)
+		{
+			name.Name = ReadString ();
+			name.Culture = ReadString ();
+		}
+
+		public TypeDefinitionCollection ReadTypes ()
+		{
+			InitializeTypeDefinitions ();
+			var mtypes = metadata.Types;
+			var type_count = mtypes.Length - metadata.NestedTypes.Count;
+			var types = new TypeDefinitionCollection (module, type_count);
+
+			for (int i = 0; i < mtypes.Length; i++) {
+				var type = mtypes [i];
+				if (IsNested (type.Attributes))
+					continue;
+
+				types.Add (type);
+			}
+
+			if (image.HasTable (Table.MethodPtr) || image.HasTable (Table.FieldPtr))
+				CompleteTypes ();
+
+			return types;
+		}
+
+		void CompleteTypes ()
+		{
+			var types = metadata.Types;
+
+			for (int i = 0; i < types.Length; i++) {
+				var type = types [i];
+
+				Mixin.Read (type.Fields);
+				Mixin.Read (type.Methods);
+			}
+		}
+
+		void InitializeTypeDefinitions ()
+		{
+			if (metadata.Types != null)
+				return;
+
+			InitializeNestedTypes ();
+			InitializeFields ();
+			InitializeMethods ();
+
+			int length = MoveTo (Table.TypeDef);
+			var types = metadata.Types = new TypeDefinition [length];
+
+			for (uint i = 0; i < length; i++) {
+				if (types [i] != null)
+					continue;
+
+				types [i] = ReadType (i + 1);
+			}
+
+			if (module.IsWindowsMetadata ()) {
+				for (uint i = 0; i < length; i++) {
+					WindowsRuntimeProjections.Project (types [i]);
+				}
+			}
+		}
+
+		static bool IsNested (TypeAttributes attributes)
+		{
+			switch (attributes & TypeAttributes.VisibilityMask) {
+			case TypeAttributes.NestedAssembly:
+			case TypeAttributes.NestedFamANDAssem:
+			case TypeAttributes.NestedFamily:
+			case TypeAttributes.NestedFamORAssem:
+			case TypeAttributes.NestedPrivate:
+			case TypeAttributes.NestedPublic:
+				return true;
+			default:
+				return false;
+			}
+		}
+
+		public bool HasNestedTypes (TypeDefinition type)
+		{
+			Collection<uint> mapping;
+			InitializeNestedTypes ();
+
+			if (!metadata.TryGetNestedTypeMapping (type, out mapping))
+				return false;
+
+			return mapping.Count > 0;
+		}
+
+		public Collection<TypeDefinition> ReadNestedTypes (TypeDefinition type)
+		{
+			InitializeNestedTypes ();
+			Collection<uint> mapping;
+			if (!metadata.TryGetNestedTypeMapping (type, out mapping))
+				return new MemberDefinitionCollection<TypeDefinition> (type);
+
+			var nested_types = new MemberDefinitionCollection<TypeDefinition> (type, mapping.Count);
+
+			for (int i = 0; i < mapping.Count; i++) {
+				var nested_type = GetTypeDefinition (mapping [i]);
+
+				if (nested_type != null)
+					nested_types.Add (nested_type);
+			}
+
+			metadata.RemoveNestedTypeMapping (type);
+
+			return nested_types;
+		}
+
+		void InitializeNestedTypes ()
+		{
+			if (metadata.NestedTypes != null)
+				return;
+
+			var length = MoveTo (Table.NestedClass);
+
+			metadata.NestedTypes = new Dictionary<uint, Collection<uint>> (length);
+			metadata.ReverseNestedTypes = new Dictionary<uint, uint> (length);
+
+			if (length == 0)
+				return;
+
+			for (int i = 1; i <= length; i++) {
+				var nested = ReadTableIndex (Table.TypeDef);
+				var declaring = ReadTableIndex (Table.TypeDef);
+
+				AddNestedMapping (declaring, nested);
+			}
+		}
+
+		void AddNestedMapping (uint declaring, uint nested)
+		{
+			metadata.SetNestedTypeMapping (declaring, AddMapping (metadata.NestedTypes, declaring, nested));
+			metadata.SetReverseNestedTypeMapping (nested, declaring);
+		}
+
+		static Collection<TValue> AddMapping<TKey, TValue> (Dictionary<TKey, Collection<TValue>> cache, TKey key, TValue value)
+		{
+			Collection<TValue> mapped;
+			if (!cache.TryGetValue (key, out mapped)) {
+				mapped = new Collection<TValue> ();
+			}
+			mapped.Add (value);
+			return mapped;
+		}
+
+		TypeDefinition ReadType (uint rid)
+		{
+			if (!MoveTo (Table.TypeDef, rid))
+				return null;
+
+			var attributes = (TypeAttributes) ReadUInt32 ();
+			var name = ReadString ();
+			var @namespace = ReadString ();
+			var type = new TypeDefinition (@namespace, name, attributes);
+			type.token = new MetadataToken (TokenType.TypeDef, rid);
+			type.scope = module;
+			type.module = module;
+
+			metadata.AddTypeDefinition (type);
+
+			this.context = type;
+
+			type.BaseType = GetTypeDefOrRef (ReadMetadataToken (CodedIndex.TypeDefOrRef));
+
+			type.fields_range = ReadListRange (rid, Table.TypeDef, Table.Field);
+			type.methods_range = ReadListRange (rid, Table.TypeDef, Table.Method);
+
+			if (IsNested (attributes))
+				type.DeclaringType = GetNestedTypeDeclaringType (type);
+
+			return type;
+		}
+
+		TypeDefinition GetNestedTypeDeclaringType (TypeDefinition type)
+		{
+			uint declaring_rid;
+			if (!metadata.TryGetReverseNestedTypeMapping (type, out declaring_rid))
+				return null;
+
+			metadata.RemoveReverseNestedTypeMapping (type);
+			return GetTypeDefinition (declaring_rid);
+		}
+
+		Range ReadListRange (uint current_index, Table current, Table target)
+		{
+			var list = new Range ();
+
+			var start = ReadTableIndex (target);
+			if (start == 0)
+				return list;
+
+			uint next_index;
+			var current_table = image.TableHeap [current];
+
+			if (current_index == current_table.Length)
+				next_index = image.TableHeap [target].Length + 1;
+			else {
+				var position = this.position;
+				this.position += (int) (current_table.RowSize - image.GetTableIndexSize (target));
+				next_index = ReadTableIndex (target);
+				this.position = position;
+			}
+
+			list.Start = start;
+			list.Length = next_index - start;
+
+			return list;
+		}
+
+		public Row<short, int> ReadTypeLayout (TypeDefinition type)
+		{
+			InitializeTypeLayouts ();
+			Row<ushort, uint> class_layout;
+			var rid = type.token.RID;
+			if (!metadata.ClassLayouts.TryGetValue (rid, out class_layout))
+				return new Row<short, int> (Mixin.NoDataMarker, Mixin.NoDataMarker);
+
+			type.PackingSize = (short) class_layout.Col1;
+			type.ClassSize = (int) class_layout.Col2;
+
+			metadata.ClassLayouts.Remove (rid);
+
+			return new Row<short, int> ((short) class_layout.Col1, (int) class_layout.Col2);
+		}
+
+		void InitializeTypeLayouts ()
+		{
+			if (metadata.ClassLayouts != null)
+				return;
+
+			int length = MoveTo (Table.ClassLayout);
+
+			var class_layouts = metadata.ClassLayouts = new Dictionary<uint, Row<ushort, uint>> (length);
+
+			for (uint i = 0; i < length; i++) {
+				var packing_size = ReadUInt16 ();
+				var class_size = ReadUInt32 ();
+
+				var parent = ReadTableIndex (Table.TypeDef);
+
+				class_layouts.Add (parent, new Row<ushort, uint> (packing_size, class_size));
+			}
+		}
+
+		public TypeReference GetTypeDefOrRef (MetadataToken token)
+		{
+			return (TypeReference) LookupToken (token);
+		}
+
+		public TypeDefinition GetTypeDefinition (uint rid)
+		{
+			InitializeTypeDefinitions ();
+
+			var type = metadata.GetTypeDefinition (rid);
+			if (type != null)
+				return type;
+
+			type = ReadTypeDefinition (rid);
+
+			if (module.IsWindowsMetadata ())
+				WindowsRuntimeProjections.Project (type);
+
+			return type;
+		}
+
+		TypeDefinition ReadTypeDefinition (uint rid)
+		{
+			if (!MoveTo (Table.TypeDef, rid))
+				return null;
+
+			return ReadType (rid);
+		}
+
+		void InitializeTypeReferences ()
+		{
+			if (metadata.TypeReferences != null)
+				return;
+
+			metadata.TypeReferences = new TypeReference [image.GetTableLength (Table.TypeRef)];
+		}
+
+		public TypeReference GetTypeReference (string scope, string full_name)
+		{
+			InitializeTypeReferences ();
+
+			var length = metadata.TypeReferences.Length;
+
+			for (uint i = 1; i <= length; i++) {
+				var type = GetTypeReference (i);
+
+				if (type.FullName != full_name)
+					continue;
+
+				if (string.IsNullOrEmpty (scope))
+					return type;
+
+				if (type.Scope.Name == scope)
+					return type;
+			}
+
+			return null;
+		}
+
+		TypeReference GetTypeReference (uint rid)
+		{
+			InitializeTypeReferences ();
+
+			var type = metadata.GetTypeReference (rid);
+			if (type != null)
+				return type;
+
+			return ReadTypeReference (rid);
+		}
+
+		TypeReference ReadTypeReference (uint rid)
+		{
+			if (!MoveTo (Table.TypeRef, rid))
+				return null;
+
+			TypeReference declaring_type = null;
+			IMetadataScope scope;
+
+			var scope_token = ReadMetadataToken (CodedIndex.ResolutionScope);
+
+			var name = ReadString ();
+			var @namespace = ReadString ();
+
+			var type = new TypeReference (
+				@namespace,
+				name,
+				module,
+				null);
+
+			type.token = new MetadataToken (TokenType.TypeRef, rid);
+
+			metadata.AddTypeReference (type);
+
+			if (scope_token.TokenType == TokenType.TypeRef) {
+				if (scope_token.RID != rid) {
+					declaring_type = GetTypeDefOrRef (scope_token);
+
+					scope = declaring_type != null
+						? declaring_type.Scope
+						: module;
+				} else // obfuscated typeref row pointing to self
+					scope = module;
+			} else
+				scope = GetTypeReferenceScope (scope_token);
+
+			type.scope = scope;
+			type.DeclaringType = declaring_type;
+
+			MetadataSystem.TryProcessPrimitiveTypeReference (type);
+
+			if (type.Module.IsWindowsMetadata ())
+				WindowsRuntimeProjections.Project (type);
+
+			return type;
+		}
+
+		IMetadataScope GetTypeReferenceScope (MetadataToken scope)
+		{
+			if (scope.TokenType == TokenType.Module)
+				return module;
+
+			IMetadataScope[] scopes;
+
+			switch (scope.TokenType) {
+			case TokenType.AssemblyRef:
+				InitializeAssemblyReferences ();
+				scopes = metadata.AssemblyReferences;
+				break;
+			case TokenType.ModuleRef:
+				InitializeModuleReferences ();
+				scopes = metadata.ModuleReferences;
+				break;
+			default:
+				throw new NotSupportedException ();
+			}
+
+			var index = scope.RID - 1;
+			if (index < 0 || index >= scopes.Length)
+				return null;
+
+			return scopes [index];
+		}
+
+		public IEnumerable<TypeReference> GetTypeReferences ()
+		{
+			InitializeTypeReferences ();
+
+			var length = image.GetTableLength (Table.TypeRef);
+
+			var type_references = new TypeReference [length];
+
+			for (uint i = 1; i <= length; i++)
+				type_references [i - 1] = GetTypeReference (i);
+
+			return type_references;
+		}
+
+		TypeReference GetTypeSpecification (uint rid)
+		{
+			if (!MoveTo (Table.TypeSpec, rid))
+				return null;
+
+			var reader = ReadSignature (ReadBlobIndex ());
+			var type = reader.ReadTypeSignature ();
+			if (type.token.RID == 0)
+				type.token = new MetadataToken (TokenType.TypeSpec, rid);
+
+			return type;
+		}
+
+		SignatureReader ReadSignature (uint signature)
+		{
+			return new SignatureReader (signature, this);
+		}
+
+		public bool HasInterfaces (TypeDefinition type)
+		{
+			InitializeInterfaces ();
+			Collection<Row<uint, MetadataToken>> mapping;
+
+			return metadata.TryGetInterfaceMapping (type, out mapping);
+		}
+
+		public InterfaceImplementationCollection ReadInterfaces (TypeDefinition type)
+		{
+			InitializeInterfaces ();
+			Collection<Row<uint, MetadataToken>> mapping;
+
+			if (!metadata.TryGetInterfaceMapping (type, out mapping))
+				return new InterfaceImplementationCollection (type);
+
+			var interfaces = new InterfaceImplementationCollection (type, mapping.Count);
+
+			this.context = type;
+
+			for (int i = 0; i < mapping.Count; i++) {
+				interfaces.Add (
+					new InterfaceImplementation (
+						GetTypeDefOrRef (mapping [i].Col2),
+						new MetadataToken(TokenType.InterfaceImpl, mapping [i].Col1)));
+			}
+
+			metadata.RemoveInterfaceMapping (type);
+
+			return interfaces;
+		}
+
+		void InitializeInterfaces ()
+		{
+			if (metadata.Interfaces != null)
+				return;
+
+			int length = MoveTo (Table.InterfaceImpl);
+
+			metadata.Interfaces = new Dictionary<uint, Collection<Row<uint, MetadataToken>>> (length);
+
+			for (uint i = 1; i <= length; i++) {
+				var type = ReadTableIndex (Table.TypeDef);
+				var @interface = ReadMetadataToken (CodedIndex.TypeDefOrRef);
+
+				AddInterfaceMapping (type, new Row<uint, MetadataToken> (i, @interface));
+			}
+		}
+
+		void AddInterfaceMapping (uint type, Row<uint, MetadataToken> @interface)
+		{
+			metadata.SetInterfaceMapping (type, AddMapping (metadata.Interfaces, type, @interface));
+		}
+
+		public Collection<FieldDefinition> ReadFields (TypeDefinition type)
+		{
+			var fields_range = type.fields_range;
+			if (fields_range.Length == 0)
+				return new MemberDefinitionCollection<FieldDefinition> (type);
+
+			var fields = new MemberDefinitionCollection<FieldDefinition> (type, (int) fields_range.Length);
+			this.context = type;
+
+			if (!MoveTo (Table.FieldPtr, fields_range.Start)) {
+				if (!MoveTo (Table.Field, fields_range.Start))
+					return fields;
+
+				for (uint i = 0; i < fields_range.Length; i++)
+					ReadField (fields_range.Start + i, fields);
+			} else
+				ReadPointers (Table.FieldPtr, Table.Field, fields_range, fields, ReadField);
+
+			return fields;
+		}
+
+		void ReadField (uint field_rid, Collection<FieldDefinition> fields)
+		{
+			var attributes = (FieldAttributes) ReadUInt16 ();
+			var name = ReadString ();
+			var signature = ReadBlobIndex ();
+
+			var field = new FieldDefinition (name, attributes, ReadFieldType (signature));
+			field.token = new MetadataToken (TokenType.Field, field_rid);
+			metadata.AddFieldDefinition (field);
+
+			if (IsDeleted (field))
+				return;
+
+			fields.Add (field);
+
+			if (module.IsWindowsMetadata ())
+				WindowsRuntimeProjections.Project (field);
+		}
+
+		void InitializeFields ()
+		{
+			if (metadata.Fields != null)
+				return;
+
+			metadata.Fields = new FieldDefinition [image.GetTableLength (Table.Field)];
+		}
+
+		TypeReference ReadFieldType (uint signature)
+		{
+			var reader = ReadSignature (signature);
+
+			const byte field_sig = 0x6;
+
+			if (reader.ReadByte () != field_sig)
+				throw new NotSupportedException ();
+
+			return reader.ReadTypeSignature ();
+		}
+
+		public int ReadFieldRVA (FieldDefinition field)
+		{
+			InitializeFieldRVAs ();
+			var rid = field.token.RID;
+
+			RVA rva;
+			if (!metadata.FieldRVAs.TryGetValue (rid, out rva))
+				return 0;
+
+			var size = GetFieldTypeSize (field.FieldType);
+
+			if (size == 0 || rva == 0)
+				return 0;
+
+			metadata.FieldRVAs.Remove (rid);
+
+			field.InitialValue = GetFieldInitializeValue (size, rva);
+
+			return (int) rva;
+		}
+
+		byte [] GetFieldInitializeValue (int size, RVA rva)
+		{
+			return image.GetReaderAt (rva, size, (s, reader) => reader.ReadBytes (s)) ?? Empty<byte>.Array;
+		}
+
+		static int GetFieldTypeSize (TypeReference type)
+		{
+			int size = 0;
+
+			switch (type.etype) {
+			case ElementType.Boolean:
+			case ElementType.U1:
+			case ElementType.I1:
+				size = 1;
+				break;
+			case ElementType.U2:
+			case ElementType.I2:
+			case ElementType.Char:
+				size = 2;
+				break;
+			case ElementType.U4:
+			case ElementType.I4:
+			case ElementType.R4:
+				size = 4;
+				break;
+			case ElementType.U8:
+			case ElementType.I8:
+			case ElementType.R8:
+				size = 8;
+				break;
+			case ElementType.Ptr:
+			case ElementType.FnPtr:
+				size = IntPtr.Size;
+				break;
+			case ElementType.CModOpt:
+			case ElementType.CModReqD:
+				return GetFieldTypeSize (((IModifierType) type).ElementType);
+			default:
+				var field_type = type.Resolve ();
+				if (field_type != null && field_type.HasLayoutInfo)
+					size = field_type.ClassSize;
+
+				break;
+			}
+
+			return size;
+		}
+
+		void InitializeFieldRVAs ()
+		{
+			if (metadata.FieldRVAs != null)
+				return;
+
+			int length = MoveTo (Table.FieldRVA);
+
+			var field_rvas = metadata.FieldRVAs = new Dictionary<uint, uint> (length);
+
+			for (int i = 0; i < length; i++) {
+				var rva = ReadUInt32 ();
+				var field = ReadTableIndex (Table.Field);
+
+				field_rvas.Add (field, rva);
+			}
+		}
+
+		public int ReadFieldLayout (FieldDefinition field)
+		{
+			InitializeFieldLayouts ();
+			var rid = field.token.RID;
+			uint offset;
+			if (!metadata.FieldLayouts.TryGetValue (rid, out offset))
+				return Mixin.NoDataMarker;
+
+			metadata.FieldLayouts.Remove (rid);
+
+			return (int) offset;
+		}
+
+		void InitializeFieldLayouts ()
+		{
+			if (metadata.FieldLayouts != null)
+				return;
+
+			int length = MoveTo (Table.FieldLayout);
+
+			var field_layouts = metadata.FieldLayouts = new Dictionary<uint, uint> (length);
+
+			for (int i = 0; i < length; i++) {
+				var offset = ReadUInt32 ();
+				var field = ReadTableIndex (Table.Field);
+
+				field_layouts.Add (field, offset);
+			}
+		}
+
+		public bool HasEvents (TypeDefinition type)
+		{
+			InitializeEvents ();
+
+			Range range;
+			if (!metadata.TryGetEventsRange (type, out range))
+				return false;
+
+			return range.Length > 0;
+		}
+
+		public Collection<EventDefinition> ReadEvents (TypeDefinition type)
+		{
+			InitializeEvents ();
+			Range range;
+
+			if (!metadata.TryGetEventsRange (type, out range))
+				return new MemberDefinitionCollection<EventDefinition> (type);
+
+			var events = new MemberDefinitionCollection<EventDefinition> (type, (int) range.Length);
+
+			metadata.RemoveEventsRange (type);
+
+			if (range.Length == 0)
+				return events;
+
+			this.context = type;
+
+			if (!MoveTo (Table.EventPtr, range.Start)) {
+				if (!MoveTo (Table.Event, range.Start))
+					return events;
+
+				for (uint i = 0; i < range.Length; i++)
+					ReadEvent (range.Start + i, events);
+			} else
+				ReadPointers (Table.EventPtr, Table.Event, range, events, ReadEvent);
+
+			return events;
+		}
+
+		void ReadEvent (uint event_rid, Collection<EventDefinition> events)
+		{
+			var attributes = (EventAttributes) ReadUInt16 ();
+			var name = ReadString ();
+			var event_type = GetTypeDefOrRef (ReadMetadataToken (CodedIndex.TypeDefOrRef));
+
+			var @event = new EventDefinition (name, attributes, event_type);
+			@event.token = new MetadataToken (TokenType.Event, event_rid);
+
+			if (IsDeleted (@event))
+				return;
+
+			events.Add (@event);
+		}
+
+		void InitializeEvents ()
+		{
+			if (metadata.Events != null)
+				return;
+
+			int length = MoveTo (Table.EventMap);
+
+			metadata.Events = new Dictionary<uint, Range> (length);
+
+			for (uint i = 1; i <= length; i++) {
+				var type_rid = ReadTableIndex (Table.TypeDef);
+				Range events_range = ReadListRange (i, Table.EventMap, Table.Event);
+				metadata.AddEventsRange (type_rid, events_range);
+			}
+		}
+
+		public bool HasProperties (TypeDefinition type)
+		{
+			InitializeProperties ();
+
+			Range range;
+			if (!metadata.TryGetPropertiesRange (type, out range))
+				return false;
+
+			return range.Length > 0;
+		}
+
+		public Collection<PropertyDefinition> ReadProperties (TypeDefinition type)
+		{
+			InitializeProperties ();
+
+			Range range;
+
+			if (!metadata.TryGetPropertiesRange (type, out range))
+				return new MemberDefinitionCollection<PropertyDefinition> (type);
+
+			metadata.RemovePropertiesRange (type);
+
+			var properties = new MemberDefinitionCollection<PropertyDefinition> (type, (int) range.Length);
+
+			if (range.Length == 0)
+				return properties;
+
+			this.context = type;
+
+			if (!MoveTo (Table.PropertyPtr, range.Start)) {
+				if (!MoveTo (Table.Property, range.Start))
+					return properties;
+				for (uint i = 0; i < range.Length; i++)
+					ReadProperty (range.Start + i, properties);
+			} else
+				ReadPointers (Table.PropertyPtr, Table.Property, range, properties, ReadProperty);
+
+			return properties;
+		}
+
+		void ReadProperty (uint property_rid, Collection<PropertyDefinition> properties)
+		{
+			var attributes = (PropertyAttributes) ReadUInt16 ();
+			var name = ReadString ();
+			var signature = ReadBlobIndex ();
+
+			var reader = ReadSignature (signature);
+			const byte property_signature = 0x8;
+
+			var calling_convention = reader.ReadByte ();
+
+			if ((calling_convention & property_signature) == 0)
+				throw new NotSupportedException ();
+
+			var has_this = (calling_convention & 0x20) != 0;
+
+			reader.ReadCompressedUInt32 (); // count
+
+			var property = new PropertyDefinition (name, attributes, reader.ReadTypeSignature ());
+			property.HasThis = has_this;
+			property.token = new MetadataToken (TokenType.Property, property_rid);
+
+			if (IsDeleted (property))
+				return;
+
+			properties.Add (property);
+		}
+
+		void InitializeProperties ()
+		{
+			if (metadata.Properties != null)
+				return;
+
+			int length = MoveTo (Table.PropertyMap);
+
+			metadata.Properties = new Dictionary<uint, Range> (length);
+
+			for (uint i = 1; i <= length; i++) {
+				var type_rid = ReadTableIndex (Table.TypeDef);
+				var properties_range = ReadListRange (i, Table.PropertyMap, Table.Property);
+				metadata.AddPropertiesRange (type_rid, properties_range);
+			}
+		}
+
+		MethodSemanticsAttributes ReadMethodSemantics (MethodDefinition method)
+		{
+			InitializeMethodSemantics ();
+			Row<MethodSemanticsAttributes, MetadataToken> row;
+			if (!metadata.Semantics.TryGetValue (method.token.RID, out row))
+				return MethodSemanticsAttributes.None;
+
+			var type = method.DeclaringType;
+
+			switch (row.Col1) {
+			case MethodSemanticsAttributes.AddOn:
+				GetEvent (type, row.Col2).add_method = method;
+				break;
+			case MethodSemanticsAttributes.Fire:
+				GetEvent (type, row.Col2).invoke_method = method;
+				break;
+			case MethodSemanticsAttributes.RemoveOn:
+				GetEvent (type, row.Col2).remove_method = method;
+				break;
+			case MethodSemanticsAttributes.Getter:
+				GetProperty (type, row.Col2).get_method = method;
+				break;
+			case MethodSemanticsAttributes.Setter:
+				GetProperty (type, row.Col2).set_method = method;
+				break;
+			case MethodSemanticsAttributes.Other:
+				switch (row.Col2.TokenType) {
+				case TokenType.Event: {
+					var @event = GetEvent (type, row.Col2);
+					if (@event.other_methods == null)
+						@event.other_methods = new Collection<MethodDefinition> ();
+
+					@event.other_methods.Add (method);
+					break;
+				}
+				case TokenType.Property: {
+					var property = GetProperty (type, row.Col2);
+					if (property.other_methods == null)
+						property.other_methods = new Collection<MethodDefinition> ();
+
+					property.other_methods.Add (method);
+
+					break;
+				}
+				default:
+					throw new NotSupportedException ();
+				}
+				break;
+			default:
+				throw new NotSupportedException ();
+			}
+
+			metadata.Semantics.Remove (method.token.RID);
+
+			return row.Col1;
+		}
+
+		static EventDefinition GetEvent (TypeDefinition type, MetadataToken token)
+		{
+			if (token.TokenType != TokenType.Event)
+				throw new ArgumentException ();
+
+			return GetMember (type.Events, token);
+		}
+
+		static PropertyDefinition GetProperty (TypeDefinition type, MetadataToken token)
+		{
+			if (token.TokenType != TokenType.Property)
+				throw new ArgumentException ();
+
+			return GetMember (type.Properties, token);
+		}
+
+		static TMember GetMember<TMember> (Collection<TMember> members, MetadataToken token) where TMember : IMemberDefinition
+		{
+			for (int i = 0; i < members.Count; i++) {
+				var member = members [i];
+				if (member.MetadataToken == token)
+					return member;
+			}
+
+			throw new ArgumentException ();
+		}
+
+		void InitializeMethodSemantics ()
+		{
+			if (metadata.Semantics != null)
+				return;
+
+			int length = MoveTo (Table.MethodSemantics);
+
+			var semantics = metadata.Semantics = new Dictionary<uint, Row<MethodSemanticsAttributes, MetadataToken>> (0);
+
+			for (uint i = 0; i < length; i++) {
+				var attributes = (MethodSemanticsAttributes) ReadUInt16 ();
+				var method_rid = ReadTableIndex (Table.Method);
+				var association = ReadMetadataToken (CodedIndex.HasSemantics);
+
+				semantics [method_rid] = new Row<MethodSemanticsAttributes, MetadataToken> (attributes, association);
+			}
+		}
+
+		public void ReadMethods (PropertyDefinition property)
+		{
+			ReadAllSemantics (property.DeclaringType);
+		}
+
+		public void ReadMethods (EventDefinition @event)
+		{
+			ReadAllSemantics (@event.DeclaringType);
+		}
+
+		public void ReadAllSemantics (MethodDefinition method)
+		{
+			ReadAllSemantics (method.DeclaringType);
+		}
+
+		void ReadAllSemantics (TypeDefinition type)
+		{
+			var methods = type.Methods;
+			for (int i = 0; i < methods.Count; i++) {
+				var method = methods [i];
+				if (method.sem_attrs_ready)
+					continue;
+
+				method.sem_attrs = ReadMethodSemantics (method);
+				method.sem_attrs_ready = true;
+			}
+		}
+
+		public Collection<MethodDefinition> ReadMethods (TypeDefinition type)
+		{
+			var methods_range = type.methods_range;
+			if (methods_range.Length == 0)
+				return new MemberDefinitionCollection<MethodDefinition> (type);
+
+			var methods = new MemberDefinitionCollection<MethodDefinition> (type, (int) methods_range.Length);
+			if (!MoveTo (Table.MethodPtr, methods_range.Start)) {
+				if (!MoveTo (Table.Method, methods_range.Start))
+					return methods;
+
+				for (uint i = 0; i < methods_range.Length; i++)
+					ReadMethod (methods_range.Start + i, methods);
+			} else
+				ReadPointers (Table.MethodPtr, Table.Method, methods_range, methods, ReadMethod);
+
+			return methods;
+		}
+
+		void ReadPointers<TMember> (Table ptr, Table table, Range range, Collection<TMember> members, Action<uint, Collection<TMember>> reader)
+			where TMember : IMemberDefinition
+		{
+			for (uint i = 0; i < range.Length; i++) {
+				MoveTo (ptr, range.Start + i);
+
+				var rid = ReadTableIndex (table);
+				MoveTo (table, rid);
+
+				reader (rid, members);
+			}
+		}
+
+		static bool IsDeleted (IMemberDefinition member)
+		{
+			return member.IsSpecialName && member.Name == "_Deleted";
+		}
+
+		void InitializeMethods ()
+		{
+			if (metadata.Methods != null)
+				return;
+
+			metadata.Methods = new MethodDefinition [image.GetTableLength (Table.Method)];
+		}
+
+		void ReadMethod (uint method_rid, Collection<MethodDefinition> methods)
+		{
+			var method = new MethodDefinition ();
+			method.rva = ReadUInt32 ();
+			method.ImplAttributes = (MethodImplAttributes) ReadUInt16 ();
+			method.Attributes = (MethodAttributes) ReadUInt16 ();
+			method.Name = ReadString ();
+			method.token = new MetadataToken (TokenType.Method, method_rid);
+
+			if (IsDeleted (method))
+				return;
+
+			methods.Add (method); // attach method
+
+			var signature = ReadBlobIndex ();
+			var param_range = ReadListRange (method_rid, Table.Method, Table.Param);
+
+			this.context = method;
+
+			ReadMethodSignature (signature, method);
+			metadata.AddMethodDefinition (method);
+
+			if (param_range.Length != 0) {
+				var position = base.position;
+				ReadParameters (method, param_range);
+				base.position = position;
+			}
+
+			if (module.IsWindowsMetadata ())
+				WindowsRuntimeProjections.Project (method);
+		}
+
+		void ReadParameters (MethodDefinition method, Range param_range)
+		{
+			if (!MoveTo (Table.ParamPtr, param_range.Start)) {
+				if (!MoveTo (Table.Param, param_range.Start))
+					return;
+
+				for (uint i = 0; i < param_range.Length; i++)
+					ReadParameter (param_range.Start + i, method);
+			} else
+				ReadParameterPointers (method, param_range);
+		}
+
+		void ReadParameterPointers (MethodDefinition method, Range range)
+		{
+			for (uint i = 0; i < range.Length; i++) {
+				MoveTo (Table.ParamPtr, range.Start + i);
+
+				var rid = ReadTableIndex (Table.Param);
+
+				MoveTo (Table.Param, rid);
+
+				ReadParameter (rid, method);
+			}
+		}
+
+		void ReadParameter (uint param_rid, MethodDefinition method)
+		{
+			var attributes = (ParameterAttributes) ReadUInt16 ();
+			var sequence = ReadUInt16 ();
+			var name = ReadString ();
+
+			var parameter = sequence == 0
+				? method.MethodReturnType.Parameter
+				: method.Parameters [sequence - 1];
+
+			parameter.token = new MetadataToken (TokenType.Param, param_rid);
+			parameter.Name = name;
+			parameter.Attributes = attributes;
+		}
+
+		void ReadMethodSignature (uint signature, IMethodSignature method)
+		{
+			var reader = ReadSignature (signature);
+			reader.ReadMethodSignature (method);
+		}
+
+		public PInvokeInfo ReadPInvokeInfo (MethodDefinition method)
+		{
+			InitializePInvokes ();
+			Row<PInvokeAttributes, uint, uint> row;
+
+			var rid = method.token.RID;
+
+			if (!metadata.PInvokes.TryGetValue (rid, out row))
+				return null;
+
+			metadata.PInvokes.Remove (rid);
+
+			return new PInvokeInfo (
+				row.Col1,
+				image.StringHeap.Read (row.Col2),
+				module.ModuleReferences [(int) row.Col3 - 1]);
+		}
+
+		void InitializePInvokes ()
+		{
+			if (metadata.PInvokes != null)
+				return;
+
+			int length = MoveTo (Table.ImplMap);
+
+			var pinvokes = metadata.PInvokes = new Dictionary<uint, Row<PInvokeAttributes, uint, uint>> (length);
+
+			for (int i = 1; i <= length; i++) {
+				var attributes = (PInvokeAttributes) ReadUInt16 ();
+				var method = ReadMetadataToken (CodedIndex.MemberForwarded);
+				var name = ReadStringIndex ();
+				var scope = ReadTableIndex (Table.File);
+
+				if (method.TokenType != TokenType.Method)
+					continue;
+
+				pinvokes.Add (method.RID, new Row<PInvokeAttributes, uint, uint> (attributes, name, scope));
+			}
+		}
+
+		public bool HasGenericParameters (IGenericParameterProvider provider)
+		{
+			InitializeGenericParameters ();
+
+			Range [] ranges;
+			if (!metadata.TryGetGenericParameterRanges (provider, out ranges))
+				return false;
+
+			return RangesSize (ranges) > 0;
+		}
+
+		public Collection<GenericParameter> ReadGenericParameters (IGenericParameterProvider provider)
+		{
+			InitializeGenericParameters ();
+
+			Range [] ranges;
+			if (!metadata.TryGetGenericParameterRanges (provider, out ranges))
+				return new GenericParameterCollection (provider);
+
+			metadata.RemoveGenericParameterRange (provider);
+
+			var generic_parameters = new GenericParameterCollection (provider, RangesSize (ranges));
+
+			for (int i = 0; i < ranges.Length; i++)
+				ReadGenericParametersRange (ranges [i], provider, generic_parameters);
+
+			return generic_parameters;
+		}
+
+		void ReadGenericParametersRange (Range range, IGenericParameterProvider provider, GenericParameterCollection generic_parameters)
+		{
+			if (!MoveTo (Table.GenericParam, range.Start))
+				return;
+
+			for (uint i = 0; i < range.Length; i++) {
+				ReadUInt16 (); // index
+				var flags = (GenericParameterAttributes) ReadUInt16 ();
+				ReadMetadataToken (CodedIndex.TypeOrMethodDef);
+				var name = ReadString ();
+
+				var parameter = new GenericParameter (name, provider);
+				parameter.token = new MetadataToken (TokenType.GenericParam, range.Start + i);
+				parameter.Attributes = flags;
+
+				generic_parameters.Add (parameter);
+			}
+		}
+
+		void InitializeGenericParameters ()
+		{
+			if (metadata.GenericParameters != null)
+				return;
+
+			metadata.GenericParameters = InitializeRanges (
+				Table.GenericParam, () => {
+					Advance (4);
+					var next = ReadMetadataToken (CodedIndex.TypeOrMethodDef);
+					ReadStringIndex ();
+					return next;
+			});
+		}
+
+		Dictionary<MetadataToken, Range []> InitializeRanges (Table table, Func<MetadataToken> get_next)
+		{
+			int length = MoveTo (table);
+			var ranges = new Dictionary<MetadataToken, Range []> (length);
+
+			if (length == 0)
+				return ranges;
+
+			MetadataToken owner = MetadataToken.Zero;
+			Range range = new Range (1, 0);
+
+			for (uint i = 1; i <= length; i++) {
+				var next = get_next ();
+
+				if (i == 1) {
+					owner = next;
+					range.Length++;
+				} else if (next != owner) {
+					AddRange (ranges, owner, range);
+					range = new Range (i, 1);
+					owner = next;
+				} else
+					range.Length++;
+			}
+
+			AddRange (ranges, owner, range);
+
+			return ranges;
+		}
+
+		static void AddRange (Dictionary<MetadataToken, Range []> ranges, MetadataToken owner, Range range)
+		{
+			if (owner.RID == 0)
+				return;
+
+			Range [] slots;
+			if (!ranges.TryGetValue (owner, out slots)) {
+				ranges.Add (owner, new [] { range });
+				return;
+			}
+
+			ranges [owner] = slots.Add(range);
+		}
+
+		public bool HasGenericConstraints (GenericParameter generic_parameter)
+		{
+			InitializeGenericConstraints ();
+
+			Collection<MetadataToken> mapping;
+			if (!metadata.TryGetGenericConstraintMapping (generic_parameter, out mapping))
+				return false;
+
+			return mapping.Count > 0;
+		}
+
+		public Collection<TypeReference> ReadGenericConstraints (GenericParameter generic_parameter)
+		{
+			InitializeGenericConstraints ();
+
+			Collection<MetadataToken> mapping;
+			if (!metadata.TryGetGenericConstraintMapping (generic_parameter, out mapping))
+				return new Collection<TypeReference> ();
+
+			var constraints = new Collection<TypeReference> (mapping.Count);
+
+			this.context = (IGenericContext) generic_parameter.Owner;
+
+			for (int i = 0; i < mapping.Count; i++)
+				constraints.Add (GetTypeDefOrRef (mapping [i]));
+
+			metadata.RemoveGenericConstraintMapping (generic_parameter);
+
+			return constraints;
+		}
+
+		void InitializeGenericConstraints ()
+		{
+			if (metadata.GenericConstraints != null)
+				return;
+
+			var length = MoveTo (Table.GenericParamConstraint);
+
+			metadata.GenericConstraints = new Dictionary<uint, Collection<MetadataToken>> (length);
+
+			for (int i = 1; i <= length; i++)
+				AddGenericConstraintMapping (
+					ReadTableIndex (Table.GenericParam),
+					ReadMetadataToken (CodedIndex.TypeDefOrRef));
+		}
+
+		void AddGenericConstraintMapping (uint generic_parameter, MetadataToken constraint)
+		{
+			metadata.SetGenericConstraintMapping (
+				generic_parameter,
+				AddMapping (metadata.GenericConstraints, generic_parameter, constraint));
+		}
+
+		public bool HasOverrides (MethodDefinition method)
+		{
+			InitializeOverrides ();
+			Collection<MetadataToken> mapping;
+
+			if (!metadata.TryGetOverrideMapping (method, out mapping))
+				return false;
+
+			return mapping.Count > 0;
+		}
+
+		public Collection<MethodReference> ReadOverrides (MethodDefinition method)
+		{
+			InitializeOverrides ();
+
+			Collection<MetadataToken> mapping;
+			if (!metadata.TryGetOverrideMapping (method, out mapping))
+				return new Collection<MethodReference> ();
+
+			var overrides = new Collection<MethodReference> (mapping.Count);
+
+			this.context = method;
+
+			for (int i = 0; i < mapping.Count; i++)
+				overrides.Add ((MethodReference) LookupToken (mapping [i]));
+
+			metadata.RemoveOverrideMapping (method);
+
+			return overrides;
+		}
+
+		void InitializeOverrides ()
+		{
+			if (metadata.Overrides != null)
+				return;
+
+			var length = MoveTo (Table.MethodImpl);
+
+			metadata.Overrides = new Dictionary<uint, Collection<MetadataToken>> (length);
+
+			for (int i = 1; i <= length; i++) {
+				ReadTableIndex (Table.TypeDef);
+
+				var method = ReadMetadataToken (CodedIndex.MethodDefOrRef);
+				if (method.TokenType != TokenType.Method)
+					throw new NotSupportedException ();
+
+				var @override = ReadMetadataToken (CodedIndex.MethodDefOrRef);
+
+				AddOverrideMapping (method.RID, @override);
+			}
+		}
+
+		void AddOverrideMapping (uint method_rid, MetadataToken @override)
+		{
+			metadata.SetOverrideMapping (
+				method_rid,
+				AddMapping (metadata.Overrides, method_rid, @override));
+		}
+
+		public MethodBody ReadMethodBody (MethodDefinition method)
+		{
+			return code.ReadMethodBody (method);
+		}
+
+		public int ReadCodeSize (MethodDefinition method)
+		{
+			return code.ReadCodeSize (method);
+		}
+
+		public CallSite ReadCallSite (MetadataToken token)
+		{
+			if (!MoveTo (Table.StandAloneSig, token.RID))
+				return null;
+
+			var signature = ReadBlobIndex ();
+
+			var call_site = new CallSite ();
+
+			ReadMethodSignature (signature, call_site);
+
+			call_site.MetadataToken = token;
+
+			return call_site;
+		}
+
+		public VariableDefinitionCollection ReadVariables (MetadataToken local_var_token)
+		{
+			if (!MoveTo (Table.StandAloneSig, local_var_token.RID))
+				return null;
+
+			var reader = ReadSignature (ReadBlobIndex ());
+			const byte local_sig = 0x7;
+
+			if (reader.ReadByte () != local_sig)
+				throw new NotSupportedException ();
+
+			var count = reader.ReadCompressedUInt32 ();
+			if (count == 0)
+				return null;
+
+			var variables = new VariableDefinitionCollection ((int) count);
+
+			for (int i = 0; i < count; i++)
+				variables.Add (new VariableDefinition (reader.ReadTypeSignature ()));
+
+			return variables;
+		}
+
+		public IMetadataTokenProvider LookupToken (MetadataToken token)
+		{
+			var rid = token.RID;
+
+			if (rid == 0)
+				return null;
+
+			if (metadata_reader != null)
+				return metadata_reader.LookupToken (token);
+
+			IMetadataTokenProvider element;
+			var position = this.position;
+			var context = this.context;
+
+			switch (token.TokenType) {
+			case TokenType.TypeDef:
+				element = GetTypeDefinition (rid);
+				break;
+			case TokenType.TypeRef:
+				element = GetTypeReference (rid);
+				break;
+			case TokenType.TypeSpec:
+				element = GetTypeSpecification (rid);
+				break;
+			case TokenType.Field:
+				element = GetFieldDefinition (rid);
+				break;
+			case TokenType.Method:
+				element = GetMethodDefinition (rid);
+				break;
+			case TokenType.MemberRef:
+				element = GetMemberReference (rid);
+				break;
+			case TokenType.MethodSpec:
+				element = GetMethodSpecification (rid);
+				break;
+			default:
+				return null;
+			}
+
+			this.position = position;
+			this.context = context;
+
+			return element;
+		}
+
+		public FieldDefinition GetFieldDefinition (uint rid)
+		{
+			InitializeTypeDefinitions ();
+
+			var field = metadata.GetFieldDefinition (rid);
+			if (field != null)
+				return field;
+
+			return LookupField (rid);
+		}
+
+		FieldDefinition LookupField (uint rid)
+		{
+			var type = metadata.GetFieldDeclaringType (rid);
+			if (type == null)
+				return null;
+
+			Mixin.Read (type.Fields);
+
+			return metadata.GetFieldDefinition (rid);
+		}
+
+		public MethodDefinition GetMethodDefinition (uint rid)
+		{
+			InitializeTypeDefinitions ();
+
+			var method = metadata.GetMethodDefinition (rid);
+			if (method != null)
+				return method;
+
+			return LookupMethod (rid);
+		}
+
+		MethodDefinition LookupMethod (uint rid)
+		{
+			var type = metadata.GetMethodDeclaringType (rid);
+			if (type == null)
+				return null;
+
+			Mixin.Read (type.Methods);
+
+			return metadata.GetMethodDefinition (rid);
+		}
+
+		MethodSpecification GetMethodSpecification (uint rid)
+		{
+			if (!MoveTo (Table.MethodSpec, rid))
+				return null;
+
+			var element_method = (MethodReference) LookupToken (
+				ReadMetadataToken (CodedIndex.MethodDefOrRef));
+			var signature = ReadBlobIndex ();
+
+			var method_spec = ReadMethodSpecSignature (signature, element_method);
+			method_spec.token = new MetadataToken (TokenType.MethodSpec, rid);
+			return method_spec;
+		}
+
+		MethodSpecification ReadMethodSpecSignature (uint signature, MethodReference method)
+		{
+			var reader = ReadSignature (signature);
+			const byte methodspec_sig = 0x0a;
+
+			var call_conv = reader.ReadByte ();
+
+			if (call_conv != methodspec_sig)
+				throw new NotSupportedException ();
+
+			var instance = new GenericInstanceMethod (method);
+
+			reader.ReadGenericInstanceSignature (method, instance);
+
+			return instance;
+		}
+
+		MemberReference GetMemberReference (uint rid)
+		{
+			InitializeMemberReferences ();
+
+			var member = metadata.GetMemberReference (rid);
+			if (member != null)
+				return member;
+
+			member = ReadMemberReference (rid);
+			if (member != null && !member.ContainsGenericParameter)
+				metadata.AddMemberReference (member);
+			return member;
+		}
+
+		MemberReference ReadMemberReference (uint rid)
+		{
+			if (!MoveTo (Table.MemberRef, rid))
+				return null;
+
+			var token = ReadMetadataToken (CodedIndex.MemberRefParent);
+			var name = ReadString ();
+			var signature = ReadBlobIndex ();
+
+			MemberReference member;
+
+			switch (token.TokenType) {
+			case TokenType.TypeDef:
+			case TokenType.TypeRef:
+			case TokenType.TypeSpec:
+				member = ReadTypeMemberReference (token, name, signature);
+				break;
+			case TokenType.Method:
+				member = ReadMethodMemberReference (token, name, signature);
+				break;
+			default:
+				throw new NotSupportedException ();
+			}
+
+			member.token = new MetadataToken (TokenType.MemberRef, rid);
+
+			if (module.IsWindowsMetadata ())
+				WindowsRuntimeProjections.Project (member);
+
+			return member;
+		}
+
+		MemberReference ReadTypeMemberReference (MetadataToken type, string name, uint signature)
+		{
+			var declaring_type = GetTypeDefOrRef (type);
+
+			if (!declaring_type.IsArray)
+				this.context = declaring_type;
+
+			var member = ReadMemberReferenceSignature (signature, declaring_type);
+			member.Name = name;
+
+			return member;
+		}
+
+		MemberReference ReadMemberReferenceSignature (uint signature, TypeReference declaring_type)
+		{
+			var reader = ReadSignature (signature);
+			const byte field_sig = 0x6;
+
+			if (reader.buffer [reader.position] == field_sig) {
+				reader.position++;
+				var field = new FieldReference ();
+				field.DeclaringType = declaring_type;
+				field.FieldType = reader.ReadTypeSignature ();
+				return field;
+			} else {
+				var method = new MethodReference ();
+				method.DeclaringType = declaring_type;
+				reader.ReadMethodSignature (method);
+				return method;
+			}
+		}
+
+		MemberReference ReadMethodMemberReference (MetadataToken token, string name, uint signature)
+		{
+			var method = GetMethodDefinition (token.RID);
+
+			this.context = method;
+
+			var member = ReadMemberReferenceSignature (signature, method.DeclaringType);
+			member.Name = name;
+
+			return member;
+		}
+
+		void InitializeMemberReferences ()
+		{
+			if (metadata.MemberReferences != null)
+				return;
+
+			metadata.MemberReferences = new MemberReference [image.GetTableLength (Table.MemberRef)];
+		}
+
+		public IEnumerable<MemberReference> GetMemberReferences ()
+		{
+			InitializeMemberReferences ();
+
+			var length = image.GetTableLength (Table.MemberRef);
+
+			var type_system = module.TypeSystem;
+
+			var context = new MethodDefinition (string.Empty, MethodAttributes.Static, type_system.Void);
+			context.DeclaringType = new TypeDefinition (string.Empty, string.Empty, TypeAttributes.Public);
+
+			var member_references = new MemberReference [length];
+
+			for (uint i = 1; i <= length; i++) {
+				this.context = context;
+				member_references [i - 1] = GetMemberReference (i);
+			}
+
+			return member_references;
+		}
+
+		void InitializeConstants ()
+		{
+			if (metadata.Constants != null)
+				return;
+
+			var length = MoveTo (Table.Constant);
+
+			var constants = metadata.Constants = new Dictionary<MetadataToken, Row<ElementType, uint>> (length);
+
+			for (uint i = 1; i <= length; i++) {
+				var type = (ElementType) ReadUInt16 ();
+				var owner = ReadMetadataToken (CodedIndex.HasConstant);
+				var signature = ReadBlobIndex ();
+
+				constants.Add (owner, new Row<ElementType, uint> (type, signature));
+			}
+		}
+
+		public TypeReference ReadConstantSignature (MetadataToken token)
+		{
+			if (token.TokenType != TokenType.Signature)
+				throw new NotSupportedException ();
+
+			if (token.RID == 0)
+				return null;
+
+			if (!MoveTo (Table.StandAloneSig, token.RID))
+				return null;
+
+			return ReadFieldType (ReadBlobIndex ());
+		}
+
+		public object ReadConstant (IConstantProvider owner)
+		{
+			InitializeConstants ();
+
+			Row<ElementType, uint> row;
+			if (!metadata.Constants.TryGetValue (owner.MetadataToken, out row))
+				return Mixin.NoValue;
+
+			metadata.Constants.Remove (owner.MetadataToken);
+
+			return ReadConstantValue (row.Col1, row.Col2);
+		}
+
+		object ReadConstantValue (ElementType etype, uint signature)
+		{
+			switch (etype) {
+			case ElementType.Class:
+			case ElementType.Object:
+				return null;
+			case ElementType.String:
+				return ReadConstantString (signature);
+			default:
+				return ReadConstantPrimitive (etype, signature);
+			}
+		}
+
+		string ReadConstantString (uint signature)
+		{
+			byte [] blob;
+			int index, count;
+
+			GetBlobView (signature, out blob, out index, out count);
+			if (count == 0)
+				return string.Empty;
+
+			if ((count & 1) == 1)
+				count--;
+
+			return Encoding.Unicode.GetString (blob, index, count);
+		}
+
+		object ReadConstantPrimitive (ElementType type, uint signature)
+		{
+			var reader = ReadSignature (signature);
+			return reader.ReadConstantSignature (type);
+		}
+
+		internal void InitializeCustomAttributes ()
+		{
+			if (metadata.CustomAttributes != null)
+				return;
+
+			metadata.CustomAttributes = InitializeRanges (
+				Table.CustomAttribute, () => {
+					var next = ReadMetadataToken (CodedIndex.HasCustomAttribute);
+					ReadMetadataToken (CodedIndex.CustomAttributeType);
+					ReadBlobIndex ();
+					return next;
+			});
+		}
+
+		public bool HasCustomAttributes (ICustomAttributeProvider owner)
+		{
+			InitializeCustomAttributes ();
+
+			Range [] ranges;
+			if (!metadata.TryGetCustomAttributeRanges (owner, out ranges))
+				return false;
+
+			return RangesSize (ranges) > 0;
+		}
+
+		public Collection<CustomAttribute> ReadCustomAttributes (ICustomAttributeProvider owner)
+		{
+			InitializeCustomAttributes ();
+
+			Range [] ranges;
+			if (!metadata.TryGetCustomAttributeRanges (owner, out ranges))
+				return new Collection<CustomAttribute> ();
+
+			var custom_attributes = new Collection<CustomAttribute> (RangesSize (ranges));
+
+			for (int i = 0; i < ranges.Length; i++)
+				ReadCustomAttributeRange (ranges [i], custom_attributes);
+
+			metadata.RemoveCustomAttributeRange (owner);
+
+			if (module.IsWindowsMetadata ())
+				foreach (var custom_attribute in custom_attributes)
+					WindowsRuntimeProjections.Project (owner, custom_attribute);
+
+			return custom_attributes;
+		}
+
+		void ReadCustomAttributeRange (Range range, Collection<CustomAttribute> custom_attributes)
+		{
+			if (!MoveTo (Table.CustomAttribute, range.Start))
+				return;
+
+			for (var i = 0; i < range.Length; i++) {
+				ReadMetadataToken (CodedIndex.HasCustomAttribute);
+
+				var constructor = (MethodReference) LookupToken (
+					ReadMetadataToken (CodedIndex.CustomAttributeType));
+
+				var signature = ReadBlobIndex ();
+
+				custom_attributes.Add (new CustomAttribute (signature, constructor));
+			}
+		}
+
+		static int RangesSize (Range [] ranges)
+		{
+			uint size = 0;
+			for (int i = 0; i < ranges.Length; i++)
+				size += ranges [i].Length;
+
+			return (int) size;
+		}
+
+		public IEnumerable<CustomAttribute> GetCustomAttributes ()
+		{
+			InitializeTypeDefinitions ();
+
+			var length = image.TableHeap [Table.CustomAttribute].Length;
+			var custom_attributes = new Collection<CustomAttribute> ((int) length);
+			ReadCustomAttributeRange (new Range (1, length), custom_attributes);
+
+			return custom_attributes;
+		}
+
+		public byte [] ReadCustomAttributeBlob (uint signature)
+		{
+			return ReadBlob (signature);
+		}
+
+		public void ReadCustomAttributeSignature (CustomAttribute attribute)
+		{
+			var reader = ReadSignature (attribute.signature);
+
+			if (!reader.CanReadMore ())
+				return;
+
+			if (reader.ReadUInt16 () != 0x0001)
+				throw new InvalidOperationException ();
+
+			var constructor = attribute.Constructor;
+			if (constructor.HasParameters)
+				reader.ReadCustomAttributeConstructorArguments (attribute, constructor.Parameters);
+
+			if (!reader.CanReadMore ())
+				return;
+
+			var named = reader.ReadUInt16 ();
+
+			if (named == 0)
+				return;
+
+			reader.ReadCustomAttributeNamedArguments (named, ref attribute.fields, ref attribute.properties);
+		}
+
+		void InitializeMarshalInfos ()
+		{
+			if (metadata.FieldMarshals != null)
+				return;
+
+			var length = MoveTo (Table.FieldMarshal);
+
+			var marshals = metadata.FieldMarshals = new Dictionary<MetadataToken, uint> (length);
+
+			for (int i = 0; i < length; i++) {
+				var token = ReadMetadataToken (CodedIndex.HasFieldMarshal);
+				var signature = ReadBlobIndex ();
+				if (token.RID == 0)
+					continue;
+
+				marshals.Add (token, signature);
+			}
+		}
+
+		public bool HasMarshalInfo (IMarshalInfoProvider owner)
+		{
+			InitializeMarshalInfos ();
+
+			return metadata.FieldMarshals.ContainsKey (owner.MetadataToken);
+		}
+
+		public MarshalInfo ReadMarshalInfo (IMarshalInfoProvider owner)
+		{
+			InitializeMarshalInfos ();
+
+			uint signature;
+			if (!metadata.FieldMarshals.TryGetValue (owner.MetadataToken, out signature))
+				return null;
+
+			var reader = ReadSignature (signature);
+
+			metadata.FieldMarshals.Remove (owner.MetadataToken);
+
+			return reader.ReadMarshalInfo ();
+		}
+
+		void InitializeSecurityDeclarations ()
+		{
+			if (metadata.SecurityDeclarations != null)
+				return;
+
+			metadata.SecurityDeclarations = InitializeRanges (
+				Table.DeclSecurity, () => {
+					ReadUInt16 ();
+					var next = ReadMetadataToken (CodedIndex.HasDeclSecurity);
+					ReadBlobIndex ();
+					return next;
+			});
+		}
+
+		public bool HasSecurityDeclarations (ISecurityDeclarationProvider owner)
+		{
+			InitializeSecurityDeclarations ();
+
+			Range [] ranges;
+			if (!metadata.TryGetSecurityDeclarationRanges (owner, out ranges))
+				return false;
+
+			return RangesSize (ranges) > 0;
+		}
+
+		public Collection<SecurityDeclaration> ReadSecurityDeclarations (ISecurityDeclarationProvider owner)
+		{
+			InitializeSecurityDeclarations ();
+
+			Range [] ranges;
+			if (!metadata.TryGetSecurityDeclarationRanges (owner, out ranges))
+				return new Collection<SecurityDeclaration> ();
+
+			var security_declarations = new Collection<SecurityDeclaration> (RangesSize (ranges));
+
+			for (int i = 0; i < ranges.Length; i++)
+				ReadSecurityDeclarationRange (ranges [i], security_declarations);
+
+			metadata.RemoveSecurityDeclarationRange (owner);
+
+			return security_declarations;
+		}
+
+		void ReadSecurityDeclarationRange (Range range, Collection<SecurityDeclaration> security_declarations)
+		{
+			if (!MoveTo (Table.DeclSecurity, range.Start))
+				return;
+
+			for (int i = 0; i < range.Length; i++) {
+				var action = (SecurityAction) ReadUInt16 ();
+				ReadMetadataToken (CodedIndex.HasDeclSecurity);
+				var signature = ReadBlobIndex ();
+
+				security_declarations.Add (new SecurityDeclaration (action, signature, module));
+			}
+		}
+
+		public byte [] ReadSecurityDeclarationBlob (uint signature)
+		{
+			return ReadBlob (signature);
+		}
+
+		public void ReadSecurityDeclarationSignature (SecurityDeclaration declaration)
+		{
+			var signature = declaration.signature;
+			var reader = ReadSignature (signature);
+
+			if (reader.buffer [reader.position] != '.') {
+				ReadXmlSecurityDeclaration (signature, declaration);
+				return;
+			}
+
+			reader.position++;
+			var count = reader.ReadCompressedUInt32 ();
+			var attributes = new Collection<SecurityAttribute> ((int) count);
+
+			for (int i = 0; i < count; i++)
+				attributes.Add (reader.ReadSecurityAttribute ());
+
+			declaration.security_attributes = attributes;
+		}
+
+		void ReadXmlSecurityDeclaration (uint signature, SecurityDeclaration declaration)
+		{
+			var attributes = new Collection<SecurityAttribute> (1);
+
+			var attribute = new SecurityAttribute (
+				module.TypeSystem.LookupType ("System.Security.Permissions", "PermissionSetAttribute"));
+
+			attribute.properties = new Collection<CustomAttributeNamedArgument> (1);
+			attribute.properties.Add (
+				new CustomAttributeNamedArgument (
+					"XML",
+					new CustomAttributeArgument (
+						module.TypeSystem.String,
+						ReadUnicodeStringBlob (signature))));
+
+			attributes.Add (attribute);
+
+			declaration.security_attributes = attributes;
+		}
+
+		public Collection<ExportedType> ReadExportedTypes ()
+		{
+			var length = MoveTo (Table.ExportedType);
+			if (length == 0)
+				return new Collection<ExportedType> ();
+
+			var exported_types = new Collection<ExportedType> (length);
+
+			for (int i = 1; i <= length; i++) {
+				var attributes = (TypeAttributes) ReadUInt32 ();
+				var identifier = ReadUInt32 ();
+				var name = ReadString ();
+				var @namespace = ReadString ();
+				var implementation = ReadMetadataToken (CodedIndex.Implementation);
+
+				ExportedType declaring_type = null;
+				IMetadataScope scope = null;
+
+				switch (implementation.TokenType) {
+				case TokenType.AssemblyRef:
+				case TokenType.File:
+					scope = GetExportedTypeScope (implementation);
+					break;
+				case TokenType.ExportedType:
+					// FIXME: if the table is not properly sorted
+					declaring_type = exported_types [(int) implementation.RID - 1];
+					break;
+				}
+
+				var exported_type = new ExportedType (@namespace, name, module, scope) {
+					Attributes = attributes,
+					Identifier = (int) identifier,
+					DeclaringType = declaring_type,
+				};
+				exported_type.token = new MetadataToken (TokenType.ExportedType, i);
+
+				exported_types.Add (exported_type);
+			}
+
+			return exported_types;
+		}
+
+		IMetadataScope GetExportedTypeScope (MetadataToken token)
+		{
+			var position = this.position;
+			IMetadataScope scope;
+
+			switch (token.TokenType) {
+			case TokenType.AssemblyRef:
+				InitializeAssemblyReferences ();
+				scope = metadata.GetAssemblyNameReference (token.RID);
+				break;
+			case TokenType.File:
+				InitializeModuleReferences ();
+				scope = GetModuleReferenceFromFile (token);
+				break;
+			default:
+				throw new NotSupportedException ();
+			}
+
+			this.position = position;
+			return scope;
+		}
+
+		ModuleReference GetModuleReferenceFromFile (MetadataToken token)
+		{
+			if (!MoveTo (Table.File, token.RID))
+				return null;
+
+			ReadUInt32 ();
+			var file_name = ReadString ();
+			var modules = module.ModuleReferences;
+
+			ModuleReference reference;
+			for (int i = 0; i < modules.Count; i++) {
+				reference = modules [i];
+				if (reference.Name == file_name)
+					return reference;
+			}
+
+			reference = new ModuleReference (file_name);
+			modules.Add (reference);
+			return reference;
+		}
+
+		void InitializeDocuments ()
+		{
+			if (metadata.Documents != null)
+				return;
+
+			int length = MoveTo (Table.Document);
+
+			var documents = metadata.Documents = new Document [length];
+
+			for (uint i = 1; i <= length; i++) {
+				var name_index = ReadBlobIndex ();
+				var hash_algorithm = ReadGuid ();
+				var hash = ReadBlob ();
+				var language = ReadGuid ();
+
+				var signature = ReadSignature (name_index);
+				var name = signature.ReadDocumentName ();
+
+				documents [i - 1] = new Document (name) {
+					HashAlgorithmGuid = hash_algorithm,
+					Hash = hash,
+					LanguageGuid = language,
+					token = new MetadataToken (TokenType.Document, i),
+				};
+			}
+		}
+
+		public Collection<SequencePoint> ReadSequencePoints (MethodDefinition method)
+		{
+			InitializeDocuments ();
+
+			if (!MoveTo (Table.MethodDebugInformation, method.MetadataToken.RID))
+				return new Collection<SequencePoint> (0);
+
+			var document_index = ReadTableIndex (Table.Document);
+			var signature = ReadBlobIndex ();
+			if (signature == 0)
+				return new Collection<SequencePoint> (0);
+
+			var document = GetDocument (document_index);
+			var reader = ReadSignature (signature);
+
+			return reader.ReadSequencePoints (document);
+		}
+
+		public Document GetDocument (uint rid)
+		{
+			var document = metadata.GetDocument (rid);
+			if (document == null)
+				return null;
+
+			document.custom_infos = GetCustomDebugInformation (document);
+			return document;
+		}
+
+		void InitializeLocalScopes ()
+		{
+			if (metadata.LocalScopes != null)
+				return;
+
+			InitializeMethods ();
+
+			int length = MoveTo (Table.LocalScope);
+
+			metadata.LocalScopes = new Dictionary<uint, Collection<Row<uint, Range, Range, uint, uint, uint>>> ();
+
+			for (uint i = 1; i <= length; i++) {
+				var method = ReadTableIndex (Table.Method);
+				var import = ReadTableIndex (Table.ImportScope);
+				var variables = ReadListRange (i, Table.LocalScope, Table.LocalVariable);
+				var constants = ReadListRange (i, Table.LocalScope, Table.LocalConstant);
+				var scope_start = ReadUInt32 ();
+				var scope_length = ReadUInt32 ();
+
+				metadata.SetLocalScopes (method, AddMapping (metadata.LocalScopes, method, new Row<uint, Range, Range, uint, uint, uint> (import, variables, constants, scope_start, scope_length, i)));
+			}
+		}
+
+		public ScopeDebugInformation ReadScope (MethodDefinition method)
+		{
+			InitializeLocalScopes ();
+			InitializeImportScopes ();
+
+			Collection<Row<uint, Range, Range, uint, uint, uint>> records;
+			if (!metadata.TryGetLocalScopes (method, out records))
+				return null;
+
+			var method_scope = null as ScopeDebugInformation;
+
+			for (int i = 0; i < records.Count; i++) {
+				var scope = ReadLocalScope (records [i]);
+
+				if (i == 0) {
+					method_scope = scope;
+					continue;
+				}
+
+				if (!AddScope (method_scope.scopes, scope))
+					method_scope.Scopes.Add (scope);
+			}
+
+			return method_scope;
+		}
+
+		static bool AddScope (Collection<ScopeDebugInformation> scopes, ScopeDebugInformation scope)
+		{
+			if (scopes.IsNullOrEmpty ())
+				return false;
+
+			foreach (var sub_scope in scopes) {
+				if (sub_scope.HasScopes && AddScope (sub_scope.Scopes, scope))
+					return true;
+
+				if (scope.Start.Offset >= sub_scope.Start.Offset && scope.End.Offset <= sub_scope.End.Offset) {
+					sub_scope.Scopes.Add (scope);
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		ScopeDebugInformation ReadLocalScope (Row<uint, Range, Range, uint, uint, uint> record)
+		{
+			var scope = new ScopeDebugInformation
+			{
+				start = new InstructionOffset ((int) record.Col4),
+				end = new InstructionOffset ((int) (record.Col4 + record.Col5)),
+				token = new MetadataToken (TokenType.LocalScope, record.Col6),
+			};
+
+			if (record.Col1 > 0)
+				scope.import = metadata.GetImportScope (record.Col1);
+
+			if (record.Col2.Length > 0) {
+				scope.variables = new Collection<VariableDebugInformation> ((int) record.Col2.Length);
+				for (uint i = 0; i < record.Col2.Length; i++) {
+					var variable = ReadLocalVariable (record.Col2.Start + i);
+					if (variable != null)
+						scope.variables.Add (variable);
+				}
+			}
+
+			if (record.Col3.Length > 0) {
+				scope.constants = new Collection<ConstantDebugInformation> ((int) record.Col3.Length);
+				for (uint i = 0; i < record.Col3.Length; i++) {
+					var constant = ReadLocalConstant (record.Col3.Start + i);
+					if (constant != null)
+						scope.constants.Add (constant);
+				}
+			}
+
+			return scope;
+		}
+
+		VariableDebugInformation ReadLocalVariable (uint rid)
+		{
+			if (!MoveTo (Table.LocalVariable, rid))
+				return null;
+
+			var attributes = (VariableAttributes) ReadUInt16 ();
+			var index = ReadUInt16 ();
+			var name = ReadString ();
+
+			var variable = new VariableDebugInformation (index, name) { Attributes = attributes, token = new MetadataToken (TokenType.LocalVariable, rid) };
+			variable.custom_infos = GetCustomDebugInformation (variable);
+			return variable;
+		}
+
+		ConstantDebugInformation ReadLocalConstant (uint rid)
+		{
+			if (!MoveTo (Table.LocalConstant, rid))
+				return null;
+
+			var name = ReadString ();
+			var signature = ReadSignature (ReadBlobIndex ());
+			var type = signature.ReadTypeSignature ();
+
+			object value;
+			if (type.etype == ElementType.String) {
+				if (signature.buffer [signature.position] != 0xff) {
+					var bytes = signature.ReadBytes ((int) (signature.sig_length - (signature.position - signature.start)));
+					value = Encoding.Unicode.GetString (bytes, 0, bytes.Length);
+				} else
+					value = null;
+			} else if (type.IsTypeOf ("System", "Decimal")) {
+				var b = signature.ReadByte ();
+				value = new decimal (signature.ReadInt32 (), signature.ReadInt32 (), signature.ReadInt32 (), (b & 0x80) != 0, (byte) (b & 0x7f));
+			} else if (type.IsTypeOf ("System", "DateTime")) {
+				value = new DateTime (signature.ReadInt64());
+			} else if (type.etype == ElementType.Object || type.etype == ElementType.None || type.etype == ElementType.Class) {
+				value = null;
+			} else
+				value = signature.ReadConstantSignature (type.etype);
+
+			var constant = new ConstantDebugInformation (name, type, value) { token = new MetadataToken (TokenType.LocalConstant, rid) };
+			constant.custom_infos = GetCustomDebugInformation (constant);
+			return constant;
+		}
+
+		void InitializeImportScopes ()
+		{
+			if (metadata.ImportScopes != null)
+				return;
+
+			var length = MoveTo (Table.ImportScope);
+
+			metadata.ImportScopes = new ImportDebugInformation [length];
+
+			for (int i = 1; i <= length; i++) {
+				ReadTableIndex (Table.ImportScope);
+
+				var import = new ImportDebugInformation ();
+				import.token = new MetadataToken (TokenType.ImportScope, i);
+
+				var signature = ReadSignature (ReadBlobIndex ());
+				while (signature.CanReadMore ())
+					import.Targets.Add (ReadImportTarget (signature));
+
+				metadata.ImportScopes [i - 1] = import;
+			}
+
+			MoveTo (Table.ImportScope);
+
+			for (int i = 0; i < length; i++) {
+				var parent = ReadTableIndex (Table.ImportScope);
+
+				ReadBlobIndex ();
+
+				if (parent != 0)
+					metadata.ImportScopes [i].Parent = metadata.GetImportScope (parent);
+			}
+		}
+
+		public string ReadUTF8StringBlob (uint signature)
+		{
+			return ReadStringBlob (signature, Encoding.UTF8);
+		}
+
+		string ReadUnicodeStringBlob (uint signature)
+		{
+			return ReadStringBlob (signature, Encoding.Unicode);
+		}
+
+		string ReadStringBlob (uint signature, Encoding encoding)
+		{
+			byte [] blob;
+			int index, count;
+
+			GetBlobView (signature, out blob, out index, out count);
+			if (count == 0)
+				return string.Empty;
+
+			return encoding.GetString (blob, index, count);
+		}
+
+		ImportTarget ReadImportTarget (SignatureReader signature)
+		{
+			AssemblyNameReference reference = null;
+			string @namespace = null;
+			string alias = null;
+			TypeReference type = null;
+
+			var kind = (ImportTargetKind) signature.ReadCompressedUInt32 ();
+			switch (kind) {
+			case ImportTargetKind.ImportNamespace:
+				@namespace = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				break;
+			case ImportTargetKind.ImportNamespaceInAssembly:
+				reference = metadata.GetAssemblyNameReference (signature.ReadCompressedUInt32 ());
+				@namespace = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				break;
+			case ImportTargetKind.ImportType:
+				type = signature.ReadTypeToken ();
+				break;
+			case ImportTargetKind.ImportXmlNamespaceWithAlias:
+				alias = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				@namespace = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				break;
+			case ImportTargetKind.ImportAlias:
+				alias = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				break;
+			case ImportTargetKind.DefineAssemblyAlias:
+				alias = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				reference = metadata.GetAssemblyNameReference (signature.ReadCompressedUInt32 ());
+				break;
+			case ImportTargetKind.DefineNamespaceAlias:
+				alias = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				@namespace = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				break;
+			case ImportTargetKind.DefineNamespaceInAssemblyAlias:
+				alias = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				reference = metadata.GetAssemblyNameReference (signature.ReadCompressedUInt32 ());
+				@namespace = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				break;
+			case ImportTargetKind.DefineTypeAlias:
+				alias = ReadUTF8StringBlob (signature.ReadCompressedUInt32 ());
+				type = signature.ReadTypeToken ();
+				break;
+			}
+
+			return new ImportTarget (kind) {
+				alias = alias,
+				type = type,
+				@namespace = @namespace,
+				reference = reference,
+			};
+		}
+
+		void InitializeStateMachineMethods ()
+		{
+			if (metadata.StateMachineMethods != null)
+				return;
+
+			var length = MoveTo (Table.StateMachineMethod);
+
+			metadata.StateMachineMethods = new Dictionary<uint, uint> (length);
+
+			for (int i = 0; i < length; i++)
+				metadata.StateMachineMethods.Add (ReadTableIndex (Table.Method), ReadTableIndex (Table.Method));
+		}
+
+		public MethodDefinition ReadStateMachineKickoffMethod (MethodDefinition method)
+		{
+			InitializeStateMachineMethods ();
+
+			uint rid;
+			if (!metadata.TryGetStateMachineKickOffMethod (method, out rid))
+				return null;
+
+			return GetMethodDefinition (rid);
+		}
+
+		void InitializeCustomDebugInformations ()
+		{
+			if (metadata.CustomDebugInformations != null)
+				return;
+
+			var length = MoveTo (Table.CustomDebugInformation);
+
+			metadata.CustomDebugInformations = new Dictionary<MetadataToken, Row<Guid, uint, uint> []> ();
+
+			for (uint i = 1; i <= length; i++) {
+				var token = ReadMetadataToken (CodedIndex.HasCustomDebugInformation);
+				var info = new Row<Guid, uint, uint> (ReadGuid (), ReadBlobIndex (), i);
+
+				Row<Guid, uint, uint> [] infos;
+				metadata.CustomDebugInformations.TryGetValue (token, out infos);
+				metadata.CustomDebugInformations [token] = infos.Add (info);
+			}
+		}
+
+		public Collection<CustomDebugInformation> GetCustomDebugInformation (ICustomDebugInformationProvider provider)
+		{
+			InitializeCustomDebugInformations ();
+
+			Row<Guid, uint, uint> [] rows;
+			if (!metadata.CustomDebugInformations.TryGetValue (provider.MetadataToken, out rows))
+				return null;
+
+			var infos = new Collection<CustomDebugInformation> (rows.Length);
+
+			for (int i = 0; i < rows.Length; i++) {
+				if (rows [i].Col1 == StateMachineScopeDebugInformation.KindIdentifier) {
+					var signature = ReadSignature (rows [i].Col2);
+					var scopes = new Collection<StateMachineScope> ();
+
+					while (signature.CanReadMore ()) {
+						var start = signature.ReadInt32 ();
+						var end = start + signature.ReadInt32 ();
+						scopes.Add (new StateMachineScope (start, end));
+					}
+
+					var state_machine = new StateMachineScopeDebugInformation ();
+					state_machine.scopes = scopes;
+
+					infos.Add (state_machine);
+				} else if (rows [i].Col1 == AsyncMethodBodyDebugInformation.KindIdentifier) {
+					var signature = ReadSignature (rows [i].Col2);
+
+					var catch_offset = signature.ReadInt32 () - 1;
+					var yields = new Collection<InstructionOffset> ();
+					var resumes = new Collection<InstructionOffset> ();
+					var resume_methods = new Collection<MethodDefinition> ();
+
+					while (signature.CanReadMore ()) {
+						yields.Add (new InstructionOffset (signature.ReadInt32 ()));
+						resumes.Add (new InstructionOffset (signature.ReadInt32 ()));
+						resume_methods.Add (GetMethodDefinition (signature.ReadCompressedUInt32 ()));
+					}
+
+					var async_body = new AsyncMethodBodyDebugInformation (catch_offset);
+					async_body.yields = yields;
+					async_body.resumes = resumes;
+					async_body.resume_methods = resume_methods;
+
+					infos.Add (async_body);
+				} else if (rows [i].Col1 == EmbeddedSourceDebugInformation.KindIdentifier) {
+					var signature = ReadSignature (rows [i].Col2);
+					var format = signature.ReadInt32 ();
+					var length = signature.sig_length - 4;
+
+					var info = null as CustomDebugInformation;
+
+					if (format == 0) {
+						info = new EmbeddedSourceDebugInformation (signature.ReadBytes ((int) length), compress: false);
+					} else if (format > 0) {
+						var compressed_stream = new MemoryStream (signature.ReadBytes ((int) length));
+						var decompressed_document = new byte [format]; // if positive, format is the decompressed length of the document
+						var decompressed_stream = new MemoryStream (decompressed_document);
+
+						using (var deflate_stream = new DeflateStream (compressed_stream, CompressionMode.Decompress, leaveOpen: true))
+							deflate_stream.CopyTo (decompressed_stream);
+
+						info = new EmbeddedSourceDebugInformation (decompressed_document, compress: true);
+					} else if (format < 0) {
+						info = new BinaryCustomDebugInformation (rows [i].Col1, ReadBlob (rows [i].Col2));
+					}
+
+					infos.Add (info);
+				} else if (rows [i].Col1 == SourceLinkDebugInformation.KindIdentifier) {
+					infos.Add (new SourceLinkDebugInformation (Encoding.UTF8.GetString (ReadBlob (rows [i].Col2))));
+				} else {
+					infos.Add (new BinaryCustomDebugInformation (rows [i].Col1, ReadBlob (rows [i].Col2)));
+				}
+
+				infos [i].token = new MetadataToken (TokenType.CustomDebugInformation, rows [i].Col3);
+			}
+
+			return infos;
+		}
+	}
+
+	sealed class SignatureReader : ByteBuffer {
+
+		readonly MetadataReader reader;
+		readonly internal uint start, sig_length;
+
+		TypeSystem TypeSystem {
+			get { return reader.module.TypeSystem; }
+		}
+
+		public SignatureReader (uint blob, MetadataReader reader)
+			: base (reader.image.BlobHeap.data)
+		{
+			this.reader = reader;
+			this.position = (int) blob;
+			this.sig_length = ReadCompressedUInt32();
+			this.start = (uint) this.position;
+		}
+
+		MetadataToken ReadTypeTokenSignature ()
+		{
+			return CodedIndex.TypeDefOrRef.GetMetadataToken (ReadCompressedUInt32 ());
+		}
+
+		GenericParameter GetGenericParameter (GenericParameterType type, uint var)
+		{
+			var context = reader.context;
+			int index = (int) var;
+
+			if (context == null)
+				return GetUnboundGenericParameter (type, index);
+
+			IGenericParameterProvider provider;
+
+			switch (type) {
+			case GenericParameterType.Type:
+				provider = context.Type;
+				break;
+			case GenericParameterType.Method:
+				provider = context.Method;
+				break;
+			default:
+				throw new NotSupportedException ();
+			}
+
+			if (!context.IsDefinition)
+				CheckGenericContext (provider, index);
+
+			if (index >= provider.GenericParameters.Count)
+				return GetUnboundGenericParameter (type, index);
+
+			return provider.GenericParameters [index];
+		}
+
+		GenericParameter GetUnboundGenericParameter (GenericParameterType type, int index)
+		{
+			return new GenericParameter (index, type, reader.module);
+		}
+
+		static void CheckGenericContext (IGenericParameterProvider owner, int index)
+		{
+			var owner_parameters = owner.GenericParameters;
+
+			for (int i = owner_parameters.Count; i <= index; i++)
+				owner_parameters.Add (new GenericParameter (owner));
+		}
+
+		public void ReadGenericInstanceSignature (IGenericParameterProvider provider, IGenericInstance instance)
+		{
+			var arity = ReadCompressedUInt32 ();
+
+			if (!provider.IsDefinition)
+				CheckGenericContext (provider, (int) arity - 1);
+
+			var instance_arguments = instance.GenericArguments;
+
+			for (int i = 0; i < arity; i++)
+				instance_arguments.Add (ReadTypeSignature ());
+		}
+
+		ArrayType ReadArrayTypeSignature ()
+		{
+			var array = new ArrayType (ReadTypeSignature ());
+
+			var rank = ReadCompressedUInt32 ();
+
+			var sizes = new uint [ReadCompressedUInt32 ()];
+			for (int i = 0; i < sizes.Length; i++)
+				sizes [i] = ReadCompressedUInt32 ();
+
+			var low_bounds = new int [ReadCompressedUInt32 ()];
+			for (int i = 0; i < low_bounds.Length; i++)
+				low_bounds [i] = ReadCompressedInt32 ();
+
+			array.Dimensions.Clear ();
+
+			for (int i = 0; i < rank; i++) {
+				int? lower = null, upper = null;
+
+				if (i < low_bounds.Length)
+					lower = low_bounds [i];
+
+				if (i < sizes.Length)
+					upper = lower + (int) sizes [i] - 1;
+
+				array.Dimensions.Add (new ArrayDimension (lower, upper));
+			}
+
+			return array;
+		}
+
+		TypeReference GetTypeDefOrRef (MetadataToken token)
+		{
+			return reader.GetTypeDefOrRef (token);
+		}
+
+		public TypeReference ReadTypeSignature ()
+		{
+			return ReadTypeSignature ((ElementType) ReadByte ());
+		}
+
+		public TypeReference ReadTypeToken ()
+		{
+			return GetTypeDefOrRef (ReadTypeTokenSignature ());
+		}
+
+		TypeReference ReadTypeSignature (ElementType etype)
+		{
+			switch (etype) {
+			case ElementType.ValueType: {
+				var value_type = GetTypeDefOrRef (ReadTypeTokenSignature ());
+				value_type.KnownValueType ();
+				return value_type;
+			}
+			case ElementType.Class:
+				return GetTypeDefOrRef (ReadTypeTokenSignature ());
+			case ElementType.Ptr:
+				return new PointerType (ReadTypeSignature ());
+			case ElementType.FnPtr: {
+				var fptr = new FunctionPointerType ();
+				ReadMethodSignature (fptr);
+				return fptr;
+			}
+			case ElementType.ByRef:
+				return new ByReferenceType (ReadTypeSignature ());
+			case ElementType.Pinned:
+				return new PinnedType (ReadTypeSignature ());
+			case ElementType.SzArray:
+				return new ArrayType (ReadTypeSignature ());
+			case ElementType.Array:
+				return ReadArrayTypeSignature ();
+			case ElementType.CModOpt:
+				return new OptionalModifierType (
+					GetTypeDefOrRef (ReadTypeTokenSignature ()), ReadTypeSignature ());
+			case ElementType.CModReqD:
+				return new RequiredModifierType (
+					GetTypeDefOrRef (ReadTypeTokenSignature ()), ReadTypeSignature ());
+			case ElementType.Sentinel:
+				return new SentinelType (ReadTypeSignature ());
+			case ElementType.Var:
+				return GetGenericParameter (GenericParameterType.Type, ReadCompressedUInt32 ());
+			case ElementType.MVar:
+				return GetGenericParameter (GenericParameterType.Method, ReadCompressedUInt32 ());
+			case ElementType.GenericInst: {
+				var is_value_type = ReadByte () == (byte) ElementType.ValueType;
+				var element_type = GetTypeDefOrRef (ReadTypeTokenSignature ());
+				var generic_instance = new GenericInstanceType (element_type);
+
+				ReadGenericInstanceSignature (element_type, generic_instance);
+
+				if (is_value_type) {
+					generic_instance.KnownValueType ();
+					element_type.GetElementType ().KnownValueType ();
+				}
+
+				return generic_instance;
+			}
+			case ElementType.Object: return TypeSystem.Object;
+			case ElementType.Void: return TypeSystem.Void;
+			case ElementType.TypedByRef: return TypeSystem.TypedReference;
+			case ElementType.I: return TypeSystem.IntPtr;
+			case ElementType.U: return TypeSystem.UIntPtr;
+			default: return GetPrimitiveType (etype);
+			}
+		}
+
+		public void ReadMethodSignature (IMethodSignature method)
+		{
+			var calling_convention = ReadByte ();
+
+			const byte has_this = 0x20;
+			const byte explicit_this = 0x40;
+
+			if ((calling_convention & has_this) != 0) {
+				method.HasThis = true;
+				calling_convention = (byte) (calling_convention & ~has_this);
+			}
+
+			if ((calling_convention & explicit_this) != 0) {
+				method.ExplicitThis = true;
+				calling_convention = (byte) (calling_convention & ~explicit_this);
+			}
+
+			method.CallingConvention = (MethodCallingConvention) calling_convention;
+
+			var generic_context = method as MethodReference;
+			if (generic_context != null && !generic_context.DeclaringType.IsArray)
+				reader.context = generic_context;
+
+			if ((calling_convention & 0x10) != 0) {
+				var arity = ReadCompressedUInt32 ();
+
+				if (generic_context != null && !generic_context.IsDefinition)
+					CheckGenericContext (generic_context, (int) arity -1 );
+			}
+
+			var param_count = ReadCompressedUInt32 ();
+
+			method.MethodReturnType.ReturnType = ReadTypeSignature ();
+
+			if (param_count == 0)
+				return;
+
+			Collection<ParameterDefinition> parameters;
+
+			var method_ref = method as MethodReference;
+			if (method_ref != null)
+				parameters = method_ref.parameters = new ParameterDefinitionCollection (method, (int) param_count);
+			else
+				parameters = method.Parameters;
+
+			for (int i = 0; i < param_count; i++)
+				parameters.Add (new ParameterDefinition (ReadTypeSignature ()));
+		}
+
+		public object ReadConstantSignature (ElementType type)
+		{
+			return ReadPrimitiveValue (type);
+		}
+
+		public void ReadCustomAttributeConstructorArguments (CustomAttribute attribute, Collection<ParameterDefinition> parameters)
+		{
+			var count = parameters.Count;
+			if (count == 0)
+				return;
+
+			attribute.arguments = new Collection<CustomAttributeArgument> (count);
+
+			for (int i = 0; i < count; i++)
+				attribute.arguments.Add (
+					ReadCustomAttributeFixedArgument (parameters [i].ParameterType));
+		}
+
+		CustomAttributeArgument ReadCustomAttributeFixedArgument (TypeReference type)
+		{
+			if (type.IsArray)
+				return ReadCustomAttributeFixedArrayArgument ((ArrayType) type);
+
+			return ReadCustomAttributeElement (type);
+		}
+
+		public void ReadCustomAttributeNamedArguments (ushort count, ref Collection<CustomAttributeNamedArgument> fields, ref Collection<CustomAttributeNamedArgument> properties)
+		{
+			for (int i = 0; i < count; i++) {
+				if (!CanReadMore ())
+					return;
+				ReadCustomAttributeNamedArgument (ref fields, ref properties);
+			}
+		}
+
+		void ReadCustomAttributeNamedArgument (ref Collection<CustomAttributeNamedArgument> fields, ref Collection<CustomAttributeNamedArgument> properties)
+		{
+			var kind = ReadByte ();
+			var type = ReadCustomAttributeFieldOrPropType ();
+			var name = ReadUTF8String ();
+
+			Collection<CustomAttributeNamedArgument> container;
+			switch (kind) {
+			case 0x53:
+				container = GetCustomAttributeNamedArgumentCollection (ref fields);
+				break;
+			case 0x54:
+				container = GetCustomAttributeNamedArgumentCollection (ref properties);
+				break;
+			default:
+				throw new NotSupportedException ();
+			}
+
+			container.Add (new CustomAttributeNamedArgument (name, ReadCustomAttributeFixedArgument (type)));
+		}
+
+		static Collection<CustomAttributeNamedArgument> GetCustomAttributeNamedArgumentCollection (ref Collection<CustomAttributeNamedArgument> collection)
+		{
+			if (collection != null)
+				return collection;
+
+			return collection = new Collection<CustomAttributeNamedArgument> ();
+		}
+
+		CustomAttributeArgument ReadCustomAttributeFixedArrayArgument (ArrayType type)
+		{
+			var length = ReadUInt32 ();
+
+			if (length == 0xffffffff)
+				return new CustomAttributeArgument (type, null);
+
+			if (length == 0)
+				return new CustomAttributeArgument (type, Empty<CustomAttributeArgument>.Array);
+
+			var arguments = new CustomAttributeArgument [length];
+			var element_type = type.ElementType;
+
+			for (int i = 0; i < length; i++)
+				arguments [i] = ReadCustomAttributeElement (element_type);
+
+			return new CustomAttributeArgument (type, arguments);
+		}
+
+		CustomAttributeArgument ReadCustomAttributeElement (TypeReference type)
+		{
+			if (type.IsArray)
+				return ReadCustomAttributeFixedArrayArgument ((ArrayType) type);
+
+			return new CustomAttributeArgument (
+				type,
+				type.etype == ElementType.Object
+					? ReadCustomAttributeElement (ReadCustomAttributeFieldOrPropType ())
+					: ReadCustomAttributeElementValue (type));
+		}
+
+		object ReadCustomAttributeElementValue (TypeReference type)
+		{
+			var etype = type.etype;
+
+			switch (etype) {
+			case ElementType.String:
+				return ReadUTF8String ();
+			case ElementType.None:
+				if (type.IsTypeOf ("System", "Type"))
+					return ReadTypeReference ();
+
+				return ReadCustomAttributeEnum (type);
+			default:
+				return ReadPrimitiveValue (etype);
+			}
+		}
+
+		object ReadPrimitiveValue (ElementType type)
+		{
+			switch (type) {
+			case ElementType.Boolean:
+				return ReadByte () == 1;
+			case ElementType.I1:
+				return (sbyte) ReadByte ();
+			case ElementType.U1:
+				return ReadByte ();
+			case ElementType.Char:
+				return (char) ReadUInt16 ();
+			case ElementType.I2:
+				return ReadInt16 ();
+			case ElementType.U2:
+				return ReadUInt16 ();
+			case ElementType.I4:
+				return ReadInt32 ();
+			case ElementType.U4:
+				return ReadUInt32 ();
+			case ElementType.I8:
+				return ReadInt64 ();
+			case ElementType.U8:
+				return ReadUInt64 ();
+			case ElementType.R4:
+				return ReadSingle ();
+			case ElementType.R8:
+				return ReadDouble ();
+			default:
+				throw new NotImplementedException (type.ToString ());
+			}
+		}
+
+		TypeReference GetPrimitiveType (ElementType etype)
+		{
+			switch (etype) {
+			case ElementType.Boolean:
+				return TypeSystem.Boolean;
+			case ElementType.Char:
+				return TypeSystem.Char;
+			case ElementType.I1:
+				return TypeSystem.SByte;
+			case ElementType.U1:
+				return TypeSystem.Byte;
+			case ElementType.I2:
+				return TypeSystem.Int16;
+			case ElementType.U2:
+				return TypeSystem.UInt16;
+			case ElementType.I4:
+				return TypeSystem.Int32;
+			case ElementType.U4:
+				return TypeSystem.UInt32;
+			case ElementType.I8:
+				return TypeSystem.Int64;
+			case ElementType.U8:
+				return TypeSystem.UInt64;
+			case ElementType.R4:
+				return TypeSystem.Single;
+			case ElementType.R8:
+				return TypeSystem.Double;
+			case ElementType.String:
+				return TypeSystem.String;
+			default:
+				throw new NotImplementedException (etype.ToString ());
+			}
+		}
+
+		TypeReference ReadCustomAttributeFieldOrPropType ()
+		{
+			var etype = (ElementType) ReadByte ();
+
+			switch (etype) {
+			case ElementType.Boxed:
+				return TypeSystem.Object;
+			case ElementType.SzArray:
+				return new ArrayType (ReadCustomAttributeFieldOrPropType ());
+			case ElementType.Enum:
+				return ReadTypeReference ();
+			case ElementType.Type:
+				return TypeSystem.LookupType ("System", "Type");
+			default:
+				return GetPrimitiveType (etype);
+			}
+		}
+
+		public TypeReference ReadTypeReference ()
+		{
+			return TypeParser.ParseType (reader.module, ReadUTF8String ());
+		}
+
+		object ReadCustomAttributeEnum (TypeReference enum_type)
+		{
+			var type = enum_type.CheckedResolve ();
+			if (!type.IsEnum)
+				throw new ArgumentException ();
+
+			return ReadCustomAttributeElementValue (type.GetEnumUnderlyingType ());
+		}
+
+		public SecurityAttribute ReadSecurityAttribute ()
+		{
+			var attribute = new SecurityAttribute (ReadTypeReference ());
+
+			ReadCompressedUInt32 ();
+
+			ReadCustomAttributeNamedArguments (
+				(ushort) ReadCompressedUInt32 (),
+				ref attribute.fields,
+				ref attribute.properties);
+
+			return attribute;
+		}
+
+		public MarshalInfo ReadMarshalInfo ()
+		{
+			var native = ReadNativeType ();
+			switch (native) {
+			case NativeType.Array: {
+				var array = new ArrayMarshalInfo ();
+				if (CanReadMore ())
+					array.element_type = ReadNativeType ();
+				if (CanReadMore ())
+					array.size_parameter_index = (int) ReadCompressedUInt32 ();
+				if (CanReadMore ())
+					array.size = (int) ReadCompressedUInt32 ();
+				if (CanReadMore ())
+					array.size_parameter_multiplier = (int) ReadCompressedUInt32 ();
+				return array;
+			}
+			case NativeType.SafeArray: {
+				var array = new SafeArrayMarshalInfo ();
+				if (CanReadMore ())
+					array.element_type = ReadVariantType ();
+				return array;
+			}
+			case NativeType.FixedArray: {
+				var array = new FixedArrayMarshalInfo ();
+				if (CanReadMore ())
+					array.size = (int) ReadCompressedUInt32 ();
+				if (CanReadMore ())
+					array.element_type = ReadNativeType ();
+				return array;
+			}
+			case NativeType.FixedSysString: {
+				var sys_string = new FixedSysStringMarshalInfo ();
+				if (CanReadMore ())
+					sys_string.size = (int) ReadCompressedUInt32 ();
+				return sys_string;
+			}
+			case NativeType.CustomMarshaler: {
+				var marshaler = new CustomMarshalInfo ();
+				var guid_value = ReadUTF8String ();
+				marshaler.guid = !string.IsNullOrEmpty (guid_value) ? new Guid (guid_value) : Guid.Empty;
+				marshaler.unmanaged_type = ReadUTF8String ();
+				marshaler.managed_type = ReadTypeReference ();
+				marshaler.cookie = ReadUTF8String ();
+				return marshaler;
+			}
+			default:
+				return new MarshalInfo (native);
+			}
+		}
+
+		NativeType ReadNativeType ()
+		{
+			return (NativeType) ReadByte ();
+		}
+
+		VariantType ReadVariantType ()
+		{
+			return (VariantType) ReadByte ();
+		}
+
+		string ReadUTF8String ()
+		{
+			if (buffer [position] == 0xff) {
+				position++;
+				return null;
+			}
+
+			var length = (int) ReadCompressedUInt32 ();
+			if (length == 0)
+				return string.Empty;
+
+			if (position + length > buffer.Length)
+				return string.Empty;
+
+			var @string = Encoding.UTF8.GetString (buffer, position, length);
+
+			position += length;
+			return @string;
+		}
+
+		public string ReadDocumentName ()
+		{
+			var separator = (char) buffer [position];
+			position++;
+
+			var builder = new StringBuilder ();
+			for (int i = 0; CanReadMore (); i++) {
+				if (i > 0 && separator != 0)
+					builder.Append (separator);
+
+				uint part = ReadCompressedUInt32 ();
+				if (part != 0)
+					builder.Append (reader.ReadUTF8StringBlob (part));
+			}
+
+			return builder.ToString ();
+		}
+
+		public Collection<SequencePoint> ReadSequencePoints (Document document)
+		{
+			var sequence_points = new Collection<SequencePoint> ();
+
+			ReadCompressedUInt32 (); // local_sig_token
+
+			if (document == null)
+				document = reader.GetDocument (ReadCompressedUInt32 ());
+
+			var offset = 0;
+			var start_line = 0;
+			var start_column = 0;
+			var first_non_hidden = true;
+
+			for (var i = 0; CanReadMore (); i++) {
+				var delta_il = (int) ReadCompressedUInt32 ();
+				if (i > 0 && delta_il == 0) {
+					document = reader.GetDocument (ReadCompressedUInt32 ());
+					continue;
+				}
+
+				offset += delta_il;
+
+				var delta_lines = (int) ReadCompressedUInt32 ();
+				var delta_columns = delta_lines == 0
+					? (int) ReadCompressedUInt32 ()
+					: ReadCompressedInt32 ();
+
+				if (delta_lines == 0 && delta_columns == 0) {
+					sequence_points.Add (new SequencePoint (offset, document) {
+						StartLine = 0xfeefee,
+						EndLine = 0xfeefee,
+						StartColumn = 0,
+						EndColumn = 0,
+					});
+					continue;
+				}
+
+				if (first_non_hidden) {
+					start_line = (int) ReadCompressedUInt32 ();
+					start_column = (int) ReadCompressedUInt32 ();
+				} else {
+					start_line += ReadCompressedInt32 ();
+					start_column += ReadCompressedInt32 ();
+				}
+
+				sequence_points.Add (new SequencePoint (offset, document) {
+					StartLine = start_line,
+					StartColumn = start_column,
+					EndLine = start_line + delta_lines,
+					EndColumn = start_column + delta_columns,
+				});
+				first_non_hidden = false;
+			}
+
+			return sequence_points;
+		}
+
+		public bool CanReadMore ()
+		{
+			return position - start < sig_length;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/AssemblyWriter.cs b/src/Mono/Cecil/AssemblyWriter.cs
new file mode 100644
index 00000000..13137ae4
--- /dev/null
+++ b/src/Mono/Cecil/AssemblyWriter.cs
@@ -0,0 +1,3310 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Text;
+
+using Mono;
+using Mono.Collections.Generic;
+using Mono.Cecil.Cil;
+using Mono.Cecil.Metadata;
+using Mono.Cecil.PE;
+
+using RVA = System.UInt32;
+using RID = System.UInt32;
+using CodedRID = System.UInt32;
+using StringIndex = System.UInt32;
+using BlobIndex = System.UInt32;
+using GuidIndex = System.UInt32;
+
+namespace Mono.Cecil {
+
+#if !READ_ONLY
+
+	using ModuleRow      = Row<StringIndex, GuidIndex>;
+	using TypeRefRow     = Row<CodedRID, StringIndex, StringIndex>;
+	using TypeDefRow     = Row<TypeAttributes, StringIndex, StringIndex, CodedRID, RID, RID>;
+	using FieldRow       = Row<FieldAttributes, StringIndex, BlobIndex>;
+	using MethodRow      = Row<RVA, MethodImplAttributes, MethodAttributes, StringIndex, BlobIndex, RID>;
+	using ParamRow       = Row<ParameterAttributes, ushort, StringIndex>;
+	using InterfaceImplRow = Row<uint, CodedRID>;
+	using MemberRefRow   = Row<CodedRID, StringIndex, BlobIndex>;
+	using ConstantRow    = Row<ElementType, CodedRID, BlobIndex>;
+	using CustomAttributeRow = Row<CodedRID, CodedRID, BlobIndex>;
+	using FieldMarshalRow = Row<CodedRID, BlobIndex>;
+	using DeclSecurityRow = Row<SecurityAction, CodedRID, BlobIndex>;
+	using ClassLayoutRow = Row<ushort, uint, RID>;
+	using FieldLayoutRow = Row<uint, RID>;
+	using EventMapRow    = Row<RID, RID>;
+	using EventRow       = Row<EventAttributes, StringIndex, CodedRID>;
+	using PropertyMapRow = Row<RID, RID>;
+	using PropertyRow    = Row<PropertyAttributes, StringIndex, BlobIndex>;
+	using MethodSemanticsRow = Row<MethodSemanticsAttributes, RID, CodedRID>;
+	using MethodImplRow  = Row<RID, CodedRID, CodedRID>;
+	using ImplMapRow     = Row<PInvokeAttributes, CodedRID, StringIndex, RID>;
+	using FieldRVARow    = Row<RVA, RID>;
+	using AssemblyRow    = Row<AssemblyHashAlgorithm, ushort, ushort, ushort, ushort, AssemblyAttributes, uint, uint, uint>;
+	using AssemblyRefRow = Row<ushort, ushort, ushort, ushort, AssemblyAttributes, uint, uint, uint, uint>;
+	using FileRow        = Row<FileAttributes, StringIndex, BlobIndex>;
+	using ExportedTypeRow = Row<TypeAttributes, uint, StringIndex, StringIndex, CodedRID>;
+	using ManifestResourceRow = Row<uint, ManifestResourceAttributes, StringIndex, CodedRID>;
+	using NestedClassRow = Row<RID, RID>;
+	using GenericParamRow = Row<ushort, GenericParameterAttributes, CodedRID, StringIndex>;
+	using MethodSpecRow = Row<CodedRID, BlobIndex>;
+	using GenericParamConstraintRow = Row<RID, CodedRID>;
+	using DocumentRow = Row<BlobIndex, GuidIndex, BlobIndex, GuidIndex>;
+	using MethodDebugInformationRow = Row<RID, BlobIndex>;
+	using LocalScopeRow = Row<RID, RID, RID, RID, uint, uint>;
+	using LocalVariableRow = Row<VariableAttributes, ushort, StringIndex>;
+	using LocalConstantRow = Row<StringIndex, BlobIndex>;
+	using ImportScopeRow = Row<RID, BlobIndex>;
+	using StateMachineMethodRow = Row<RID, RID>;
+	using CustomDebugInformationRow = Row<CodedRID, GuidIndex, BlobIndex>;
+
+	static class ModuleWriter {
+
+		public static void WriteModule (ModuleDefinition module, Disposable<Stream> stream, WriterParameters parameters)
+		{
+			using (stream)
+				Write (module, stream, parameters);
+		}
+
+		static void Write (ModuleDefinition module, Disposable<Stream> stream, WriterParameters parameters)
+		{
+			if ((module.Attributes & ModuleAttributes.ILOnly) == 0)
+				throw new NotSupportedException ("Writing mixed-mode assemblies is not supported");
+
+			if (module.HasImage && module.ReadingMode == ReadingMode.Deferred) {
+				var immediate_reader = new ImmediateModuleReader (module.Image);
+				immediate_reader.ReadModule (module, resolve_attributes: false);
+				immediate_reader.ReadSymbols (module);
+			}
+
+			module.MetadataSystem.Clear ();
+
+			if (module.symbol_reader != null)
+				module.symbol_reader.Dispose ();
+
+			var name = module.assembly != null ? module.assembly.Name : null;
+			var fq_name = stream.value.GetFileName ();
+			var timestamp = parameters.Timestamp ?? module.timestamp;
+			var symbol_writer_provider = parameters.SymbolWriterProvider;
+
+			if (symbol_writer_provider == null && parameters.WriteSymbols)
+				symbol_writer_provider = new DefaultSymbolWriterProvider ();
+
+#if !NET_CORE
+			if (parameters.StrongNameKeyPair != null && name != null) {
+				name.PublicKey = parameters.StrongNameKeyPair.PublicKey;
+				module.Attributes |= ModuleAttributes.StrongNameSigned;
+			}
+#endif
+
+			var metadata = new MetadataBuilder (module, fq_name, timestamp, symbol_writer_provider);
+			try {
+				module.metadata_builder = metadata;
+
+				using (var symbol_writer = GetSymbolWriter (module, fq_name, symbol_writer_provider, parameters)) {
+					metadata.SetSymbolWriter (symbol_writer);
+					BuildMetadata (module, metadata);
+
+					var writer = ImageWriter.CreateWriter (module, metadata, stream);
+					stream.value.SetLength (0);
+					writer.WriteImage ();
+
+#if !NET_CORE
+					if (parameters.StrongNameKeyPair != null)
+						CryptoService.StrongName (stream.value, writer, parameters.StrongNameKeyPair);
+#endif
+				}
+			} finally {
+				module.metadata_builder = null;
+			}
+		}
+
+		static void BuildMetadata (ModuleDefinition module, MetadataBuilder metadata)
+		{
+			if (!module.HasImage) {
+				metadata.BuildMetadata ();
+				return;
+			}
+
+			module.Read (metadata, (builder, _) => {
+				builder.BuildMetadata ();
+				return builder;
+			});
+		}
+
+		static ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fq_name, ISymbolWriterProvider symbol_writer_provider, WriterParameters parameters)
+		{
+			if (symbol_writer_provider == null)
+				return null;
+
+			if (parameters.SymbolStream != null)
+				return symbol_writer_provider.GetSymbolWriter (module, parameters.SymbolStream);
+
+			return symbol_writer_provider.GetSymbolWriter (module, fq_name);
+		}
+	}
+
+	abstract class MetadataTable {
+
+		public abstract int Length { get; }
+
+		public bool IsLarge {
+			get { return Length > ushort.MaxValue; }
+		}
+
+		public abstract void Write (TableHeapBuffer buffer);
+		public abstract void Sort ();
+	}
+
+	abstract class OneRowTable<TRow> : MetadataTable where TRow : struct {
+
+		internal TRow row;
+
+		public sealed override int Length {
+			get { return 1; }
+		}
+
+		public sealed override void Sort ()
+		{
+		}
+	}
+
+	abstract class MetadataTable<TRow> : MetadataTable where TRow : struct {
+
+		internal TRow [] rows = new TRow [2];
+		internal int length;
+
+		public sealed override int Length {
+			get { return length; }
+		}
+
+		public int AddRow (TRow row)
+		{
+			if (rows.Length == length)
+				Grow ();
+
+			rows [length++] = row;
+			return length;
+		}
+
+		void Grow ()
+		{
+			var rows = new TRow [this.rows.Length * 2];
+			Array.Copy (this.rows, rows, this.rows.Length);
+			this.rows = rows;
+		}
+
+		public override void Sort ()
+		{
+		}
+	}
+
+	abstract class SortedTable<TRow> : MetadataTable<TRow>, IComparer<TRow> where TRow : struct {
+
+		public sealed override void Sort ()
+		{
+			MergeSort<TRow>.Sort (rows, 0, this.length, this);
+		}
+
+		protected static int Compare (uint x, uint y)
+		{
+			return x == y ? 0 : x > y ? 1 : -1;
+		}
+
+		public abstract int Compare (TRow x, TRow y);
+	}
+
+	sealed class ModuleTable : OneRowTable<ModuleRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			buffer.WriteUInt16 (0);		// Generation
+			buffer.WriteString (row.Col1);	// Name
+			buffer.WriteGuid (row.Col2);		// Mvid
+			buffer.WriteUInt16 (0);		// EncId
+			buffer.WriteUInt16 (0);		// EncBaseId
+		}
+	}
+
+	sealed class TypeRefTable : MetadataTable<TypeRefRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteCodedRID (
+					rows [i].Col1, CodedIndex.ResolutionScope);	// Scope
+				buffer.WriteString (rows [i].Col2);			// Name
+				buffer.WriteString (rows [i].Col3);			// Namespace
+			}
+		}
+	}
+
+	sealed class TypeDefTable : MetadataTable<TypeDefRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt32 ((uint) rows [i].Col1);	// Attributes
+				buffer.WriteString (rows [i].Col2);			// Name
+				buffer.WriteString (rows [i].Col3);			// Namespace
+				buffer.WriteCodedRID (
+					rows [i].Col4, CodedIndex.TypeDefOrRef);	// Extends
+				buffer.WriteRID (rows [i].Col5, Table.Field);	// FieldList
+				buffer.WriteRID (rows [i].Col6, Table.Method);	// MethodList
+			}
+		}
+	}
+
+	sealed class FieldTable : MetadataTable<FieldRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);	// Attributes
+				buffer.WriteString (rows [i].Col2);			// Name
+				buffer.WriteBlob (rows [i].Col3);			// Signature
+			}
+		}
+	}
+
+	sealed class MethodTable : MetadataTable<MethodRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt32 (rows [i].Col1);		// RVA
+				buffer.WriteUInt16 ((ushort) rows [i].Col2);	// ImplFlags
+				buffer.WriteUInt16 ((ushort) rows [i].Col3);	// Flags
+				buffer.WriteString (rows [i].Col4);		// Name
+				buffer.WriteBlob (rows [i].Col5);		// Signature
+				buffer.WriteRID (rows [i].Col6, Table.Param);	// ParamList
+			}
+		}
+	}
+
+	sealed class ParamTable : MetadataTable<ParamRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);	// Attributes
+				buffer.WriteUInt16 (rows [i].Col2);		// Sequence
+				buffer.WriteString (rows [i].Col3);		// Name
+			}
+		}
+	}
+
+	sealed class InterfaceImplTable : MetadataTable<InterfaceImplRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.TypeDef);		// Class
+				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.TypeDefOrRef);	// Interface
+			}
+		}
+
+		/*public override int Compare (InterfaceImplRow x, InterfaceImplRow y)
+		{
+			return (int) (x.Col1 == y.Col1 ? y.Col2 - x.Col2 : x.Col1 - y.Col1);
+		}*/
+	}
+
+	sealed class MemberRefTable : MetadataTable<MemberRefRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.MemberRefParent);
+				buffer.WriteString (rows [i].Col2);
+				buffer.WriteBlob (rows [i].Col3);
+			}
+		}
+	}
+
+	sealed class ConstantTable : SortedTable<ConstantRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);
+				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.HasConstant);
+				buffer.WriteBlob (rows [i].Col3);
+			}
+		}
+
+		public override int Compare (ConstantRow x, ConstantRow y)
+		{
+			return Compare (x.Col2, y.Col2);
+		}
+	}
+
+	sealed class CustomAttributeTable : SortedTable<CustomAttributeRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasCustomAttribute);	// Parent
+				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.CustomAttributeType);	// Type
+				buffer.WriteBlob (rows [i].Col3);
+			}
+		}
+
+		public override int Compare (CustomAttributeRow x, CustomAttributeRow y)
+		{
+			return Compare (x.Col1, y.Col1);
+		}
+	}
+
+	sealed class FieldMarshalTable : SortedTable<FieldMarshalRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasFieldMarshal);
+				buffer.WriteBlob (rows [i].Col2);
+			}
+		}
+
+		public override int Compare (FieldMarshalRow x, FieldMarshalRow y)
+		{
+			return Compare (x.Col1, y.Col1);
+		}
+	}
+
+	sealed class DeclSecurityTable : SortedTable<DeclSecurityRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);
+				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.HasDeclSecurity);
+				buffer.WriteBlob (rows [i].Col3);
+			}
+		}
+
+		public override int Compare (DeclSecurityRow x, DeclSecurityRow y)
+		{
+			return Compare (x.Col2, y.Col2);
+		}
+	}
+
+	sealed class ClassLayoutTable : SortedTable<ClassLayoutRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 (rows [i].Col1);		// PackingSize
+				buffer.WriteUInt32 (rows [i].Col2);		// ClassSize
+				buffer.WriteRID (rows [i].Col3, Table.TypeDef);	// Parent
+			}
+		}
+
+		public override int Compare (ClassLayoutRow x, ClassLayoutRow y)
+		{
+			return Compare (x.Col3, y.Col3);
+		}
+	}
+
+	sealed class FieldLayoutTable : SortedTable<FieldLayoutRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt32 (rows [i].Col1);		// Offset
+				buffer.WriteRID (rows [i].Col2, Table.Field);	// Parent
+			}
+		}
+
+		public override int Compare (FieldLayoutRow x, FieldLayoutRow y)
+		{
+			return Compare (x.Col2, y.Col2);
+		}
+	}
+
+	sealed class StandAloneSigTable : MetadataTable<uint> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++)
+				buffer.WriteBlob (rows [i]);
+		}
+	}
+
+	sealed class EventMapTable : MetadataTable<EventMapRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.TypeDef);		// Parent
+				buffer.WriteRID (rows [i].Col2, Table.Event);		// EventList
+			}
+		}
+	}
+
+	sealed class EventTable : MetadataTable<EventRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);	// Flags
+				buffer.WriteString (rows [i].Col2);		// Name
+				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.TypeDefOrRef);	// EventType
+			}
+		}
+	}
+
+	sealed class PropertyMapTable : MetadataTable<PropertyMapRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.TypeDef);		// Parent
+				buffer.WriteRID (rows [i].Col2, Table.Property);	// PropertyList
+			}
+		}
+	}
+
+	sealed class PropertyTable : MetadataTable<PropertyRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);	// Flags
+				buffer.WriteString (rows [i].Col2);		// Name
+				buffer.WriteBlob (rows [i].Col3);		// Type
+			}
+		}
+	}
+
+	sealed class MethodSemanticsTable : SortedTable<MethodSemanticsRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);	// Flags
+				buffer.WriteRID (rows [i].Col2, Table.Method);	// Method
+				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.HasSemantics);	// Association
+			}
+		}
+
+		public override int Compare (MethodSemanticsRow x, MethodSemanticsRow y)
+		{
+			return Compare (x.Col3, y.Col3);
+		}
+	}
+
+	sealed class MethodImplTable : MetadataTable<MethodImplRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.TypeDef);	// Class
+				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.MethodDefOrRef);	// MethodBody
+				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.MethodDefOrRef);	// MethodDeclaration
+			}
+		}
+	}
+
+	sealed class ModuleRefTable : MetadataTable<uint> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++)
+				buffer.WriteString (rows [i]);	// Name
+		}
+	}
+
+	sealed class TypeSpecTable : MetadataTable<uint> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++)
+				buffer.WriteBlob (rows [i]);	// Signature
+		}
+	}
+
+	sealed class ImplMapTable : SortedTable<ImplMapRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);	// Flags
+				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.MemberForwarded);	// MemberForwarded
+				buffer.WriteString (rows [i].Col3);		// ImportName
+				buffer.WriteRID (rows [i].Col4, Table.ModuleRef);	// ImportScope
+			}
+		}
+
+		public override int Compare (ImplMapRow x, ImplMapRow y)
+		{
+			return Compare (x.Col2, y.Col2);
+		}
+	}
+
+	sealed class FieldRVATable : SortedTable<FieldRVARow> {
+
+		internal int position;
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			position = buffer.position;
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt32 (rows [i].Col1);		// RVA
+				buffer.WriteRID (rows [i].Col2, Table.Field);	// Field
+			}
+		}
+
+		public override int Compare (FieldRVARow x, FieldRVARow y)
+		{
+			return Compare (x.Col2, y.Col2);
+		}
+	}
+
+	sealed class AssemblyTable : OneRowTable<AssemblyRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			buffer.WriteUInt32 ((uint) row.Col1);	// AssemblyHashAlgorithm
+			buffer.WriteUInt16 (row.Col2);			// MajorVersion
+			buffer.WriteUInt16 (row.Col3);			// MinorVersion
+			buffer.WriteUInt16 (row.Col4);			// Build
+			buffer.WriteUInt16 (row.Col5);			// Revision
+			buffer.WriteUInt32 ((uint) row.Col6);	// Flags
+			buffer.WriteBlob (row.Col7);			// PublicKey
+			buffer.WriteString (row.Col8);			// Name
+			buffer.WriteString (row.Col9);			// Culture
+		}
+	}
+
+	sealed class AssemblyRefTable : MetadataTable<AssemblyRefRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 (rows [i].Col1);		// MajorVersion
+				buffer.WriteUInt16 (rows [i].Col2);		// MinorVersion
+				buffer.WriteUInt16 (rows [i].Col3);		// Build
+				buffer.WriteUInt16 (rows [i].Col4);		// Revision
+				buffer.WriteUInt32 ((uint) rows [i].Col5);	// Flags
+				buffer.WriteBlob (rows [i].Col6);		// PublicKeyOrToken
+				buffer.WriteString (rows [i].Col7);		// Name
+				buffer.WriteString (rows [i].Col8);		// Culture
+				buffer.WriteBlob (rows [i].Col9);		// Hash
+			}
+		}
+	}
+
+	sealed class FileTable : MetadataTable<FileRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt32 ((uint) rows [i].Col1);
+				buffer.WriteString (rows [i].Col2);
+				buffer.WriteBlob (rows [i].Col3);
+			}
+		}
+	}
+
+	sealed class ExportedTypeTable : MetadataTable<ExportedTypeRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt32 ((uint) rows [i].Col1);
+				buffer.WriteUInt32 (rows [i].Col2);
+				buffer.WriteString (rows [i].Col3);
+				buffer.WriteString (rows [i].Col4);
+				buffer.WriteCodedRID (rows [i].Col5, CodedIndex.Implementation);
+			}
+		}
+	}
+
+	sealed class ManifestResourceTable : MetadataTable<ManifestResourceRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt32 (rows [i].Col1);
+				buffer.WriteUInt32 ((uint) rows [i].Col2);
+				buffer.WriteString (rows [i].Col3);
+				buffer.WriteCodedRID (rows [i].Col4, CodedIndex.Implementation);
+			}
+		}
+	}
+
+	sealed class NestedClassTable : SortedTable<NestedClassRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.TypeDef);		// NestedClass
+				buffer.WriteRID (rows [i].Col2, Table.TypeDef);		// EnclosingClass
+			}
+		}
+
+		public override int Compare (NestedClassRow x, NestedClassRow y)
+		{
+			return Compare (x.Col1, y.Col1);
+		}
+	}
+
+	sealed class GenericParamTable : MetadataTable<GenericParamRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 (rows [i].Col1);		// Number
+				buffer.WriteUInt16 ((ushort) rows [i].Col2);	// Flags
+				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.TypeOrMethodDef);	// Owner
+				buffer.WriteString (rows [i].Col4);		// Name
+			}
+		}
+	}
+
+	sealed class MethodSpecTable : MetadataTable<MethodSpecRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.MethodDefOrRef);	// Method
+				buffer.WriteBlob (rows [i].Col2);	// Instantiation
+			}
+		}
+	}
+
+	sealed class GenericParamConstraintTable : MetadataTable<GenericParamConstraintRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.GenericParam);	// Owner
+				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.TypeDefOrRef);	// Constraint
+			}
+		}
+	}
+
+	sealed class DocumentTable : MetadataTable<DocumentRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteBlob (rows [i].Col1);	// Name
+				buffer.WriteGuid (rows [i].Col2);	// HashAlgorithm
+				buffer.WriteBlob (rows [i].Col3);	// Hash
+				buffer.WriteGuid (rows [i].Col4);	// Language
+			}
+		}
+	}
+
+	sealed class MethodDebugInformationTable : MetadataTable<MethodDebugInformationRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.Document);	// Document
+				buffer.WriteBlob (rows [i].Col2);	// SequencePoints
+			}
+		}
+	}
+
+	sealed class LocalScopeTable : MetadataTable<LocalScopeRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.Method);	// Method
+				buffer.WriteRID (rows [i].Col2, Table.ImportScope);	// ImportScope
+				buffer.WriteRID (rows [i].Col3, Table.LocalVariable); // VariableList
+				buffer.WriteRID (rows [i].Col4, Table.LocalConstant); // ConstantList
+				buffer.WriteUInt32 (rows [i].Col5); // StartOffset
+				buffer.WriteUInt32 (rows [i].Col6); // Length
+			}
+		}
+	}
+
+	sealed class LocalVariableTable : MetadataTable<LocalVariableRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteUInt16 ((ushort) rows [i].Col1);	// Attributes
+				buffer.WriteUInt16 (rows [i].Col2);	// Index
+				buffer.WriteString (rows [i].Col3); // Name
+			}
+		}
+	}
+
+	sealed class LocalConstantTable : MetadataTable<LocalConstantRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteString (rows [i].Col1);	// Name
+				buffer.WriteBlob (rows [i].Col2);	// Signature
+			}
+		}
+	}
+
+	sealed class ImportScopeTable : MetadataTable<ImportScopeRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.ImportScope);	// Parent
+				buffer.WriteBlob (rows [i].Col2);	// Imports
+			}
+		}
+	}
+
+	sealed class StateMachineMethodTable : MetadataTable<StateMachineMethodRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteRID (rows [i].Col1, Table.Method);	// MoveNextMethod
+				buffer.WriteRID (rows [i].Col2, Table.Method);	// KickoffMethod
+			}
+		}
+	}
+
+	sealed class CustomDebugInformationTable : SortedTable<CustomDebugInformationRow> {
+
+		public override void Write (TableHeapBuffer buffer)
+		{
+			for (int i = 0; i < length; i++) {
+				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasCustomDebugInformation);	// Parent
+				buffer.WriteGuid (rows [i].Col2);	// Kind
+				buffer.WriteBlob (rows [i].Col3);	// Value
+			}
+		}
+
+		public override int Compare (CustomDebugInformationRow x, CustomDebugInformationRow y)
+		{
+			return Compare(x.Col1, y.Col1);
+		}
+	}
+
+	sealed class MetadataBuilder {
+
+		readonly internal ModuleDefinition module;
+		readonly internal ISymbolWriterProvider symbol_writer_provider;
+		internal ISymbolWriter symbol_writer;
+		readonly internal TextMap text_map;
+		readonly internal string fq_name;
+		readonly internal uint timestamp;
+
+		readonly Dictionary<TypeRefRow, MetadataToken> type_ref_map;
+		readonly Dictionary<uint, MetadataToken> type_spec_map;
+		readonly Dictionary<MemberRefRow, MetadataToken> member_ref_map;
+		readonly Dictionary<MethodSpecRow, MetadataToken> method_spec_map;
+		readonly Collection<GenericParameter> generic_parameters;
+
+		readonly internal CodeWriter code;
+		readonly internal DataBuffer data;
+		readonly internal ResourceBuffer resources;
+		readonly internal StringHeapBuffer string_heap;
+		readonly internal GuidHeapBuffer guid_heap;
+		readonly internal UserStringHeapBuffer user_string_heap;
+		readonly internal BlobHeapBuffer blob_heap;
+		readonly internal TableHeapBuffer table_heap;
+		readonly internal PdbHeapBuffer pdb_heap;
+
+		internal MetadataToken entry_point;
+
+		internal RID type_rid = 1;
+		internal RID field_rid = 1;
+		internal RID method_rid = 1;
+		internal RID param_rid = 1;
+		internal RID property_rid = 1;
+		internal RID event_rid = 1;
+		internal RID local_variable_rid = 1;
+		internal RID local_constant_rid = 1;
+
+		readonly TypeRefTable type_ref_table;
+		readonly TypeDefTable type_def_table;
+		readonly FieldTable field_table;
+		readonly MethodTable method_table;
+		readonly ParamTable param_table;
+		readonly InterfaceImplTable iface_impl_table;
+		readonly MemberRefTable member_ref_table;
+		readonly ConstantTable constant_table;
+		readonly CustomAttributeTable custom_attribute_table;
+		readonly DeclSecurityTable declsec_table;
+		readonly StandAloneSigTable standalone_sig_table;
+		readonly EventMapTable event_map_table;
+		readonly EventTable event_table;
+		readonly PropertyMapTable property_map_table;
+		readonly PropertyTable property_table;
+		readonly TypeSpecTable typespec_table;
+		readonly MethodSpecTable method_spec_table;
+
+		internal MetadataBuilder metadata_builder;
+
+		readonly DocumentTable document_table;
+		readonly MethodDebugInformationTable method_debug_information_table;
+		readonly LocalScopeTable local_scope_table;
+		readonly LocalVariableTable local_variable_table;
+		readonly LocalConstantTable local_constant_table;
+		readonly ImportScopeTable import_scope_table;
+		readonly StateMachineMethodTable state_machine_method_table;
+		readonly CustomDebugInformationTable custom_debug_information_table;
+
+		readonly Dictionary<ImportScopeRow, MetadataToken> import_scope_map;
+		readonly Dictionary<string, MetadataToken> document_map;
+
+		public MetadataBuilder (ModuleDefinition module, string fq_name, uint timestamp, ISymbolWriterProvider symbol_writer_provider)
+		{
+			this.module = module;
+			this.text_map = CreateTextMap ();
+			this.fq_name = fq_name;
+			this.timestamp = timestamp;
+			this.symbol_writer_provider = symbol_writer_provider;
+
+			this.code = new CodeWriter (this);
+			this.data = new DataBuffer ();
+			this.resources = new ResourceBuffer ();
+			this.string_heap = new StringHeapBuffer ();
+			this.guid_heap = new GuidHeapBuffer ();
+			this.user_string_heap = new UserStringHeapBuffer ();
+			this.blob_heap = new BlobHeapBuffer ();
+			this.table_heap = new TableHeapBuffer (module, this);
+
+			this.type_ref_table = GetTable<TypeRefTable> (Table.TypeRef);
+			this.type_def_table = GetTable<TypeDefTable> (Table.TypeDef);
+			this.field_table = GetTable<FieldTable> (Table.Field);
+			this.method_table = GetTable<MethodTable> (Table.Method);
+			this.param_table = GetTable<ParamTable> (Table.Param);
+			this.iface_impl_table = GetTable<InterfaceImplTable> (Table.InterfaceImpl);
+			this.member_ref_table = GetTable<MemberRefTable> (Table.MemberRef);
+			this.constant_table = GetTable<ConstantTable> (Table.Constant);
+			this.custom_attribute_table = GetTable<CustomAttributeTable> (Table.CustomAttribute);
+			this.declsec_table = GetTable<DeclSecurityTable> (Table.DeclSecurity);
+			this.standalone_sig_table = GetTable<StandAloneSigTable> (Table.StandAloneSig);
+			this.event_map_table = GetTable<EventMapTable> (Table.EventMap);
+			this.event_table = GetTable<EventTable> (Table.Event);
+			this.property_map_table = GetTable<PropertyMapTable> (Table.PropertyMap);
+			this.property_table = GetTable<PropertyTable> (Table.Property);
+			this.typespec_table = GetTable<TypeSpecTable> (Table.TypeSpec);
+			this.method_spec_table = GetTable<MethodSpecTable> (Table.MethodSpec);
+
+			var row_equality_comparer = new RowEqualityComparer ();
+			type_ref_map = new Dictionary<TypeRefRow, MetadataToken> (row_equality_comparer);
+			type_spec_map = new Dictionary<uint, MetadataToken> ();
+			member_ref_map = new Dictionary<MemberRefRow, MetadataToken> (row_equality_comparer);
+			method_spec_map = new Dictionary<MethodSpecRow, MetadataToken> (row_equality_comparer);
+			generic_parameters = new Collection<GenericParameter> ();
+
+			this.document_table = GetTable<DocumentTable> (Table.Document);
+			this.method_debug_information_table = GetTable<MethodDebugInformationTable> (Table.MethodDebugInformation);
+			this.local_scope_table = GetTable<LocalScopeTable> (Table.LocalScope);
+			this.local_variable_table = GetTable<LocalVariableTable> (Table.LocalVariable);
+			this.local_constant_table = GetTable<LocalConstantTable> (Table.LocalConstant);
+			this.import_scope_table = GetTable<ImportScopeTable> (Table.ImportScope);
+			this.state_machine_method_table = GetTable<StateMachineMethodTable> (Table.StateMachineMethod);
+			this.custom_debug_information_table = GetTable<CustomDebugInformationTable> (Table.CustomDebugInformation);
+
+			this.document_map = new Dictionary<string, MetadataToken> (StringComparer.Ordinal);
+			this.import_scope_map = new Dictionary<ImportScopeRow, MetadataToken> (row_equality_comparer);
+		}
+
+		public MetadataBuilder (ModuleDefinition module, PortablePdbWriterProvider writer_provider)
+		{
+			this.module = module;
+			this.text_map = new TextMap ();
+			this.symbol_writer_provider = writer_provider;
+
+			this.string_heap = new StringHeapBuffer ();
+			this.guid_heap = new GuidHeapBuffer ();
+			this.user_string_heap = new UserStringHeapBuffer ();
+			this.blob_heap = new BlobHeapBuffer ();
+			this.table_heap = new TableHeapBuffer (module, this);
+			this.pdb_heap = new PdbHeapBuffer();
+
+			this.document_table = GetTable<DocumentTable> (Table.Document);
+			this.method_debug_information_table = GetTable<MethodDebugInformationTable> (Table.MethodDebugInformation);
+			this.local_scope_table = GetTable<LocalScopeTable> (Table.LocalScope);
+			this.local_variable_table = GetTable<LocalVariableTable> (Table.LocalVariable);
+			this.local_constant_table = GetTable<LocalConstantTable> (Table.LocalConstant);
+			this.import_scope_table = GetTable<ImportScopeTable> (Table.ImportScope);
+			this.state_machine_method_table = GetTable<StateMachineMethodTable> (Table.StateMachineMethod);
+			this.custom_debug_information_table = GetTable<CustomDebugInformationTable> (Table.CustomDebugInformation);
+
+			var row_equality_comparer = new RowEqualityComparer ();
+
+			this.document_map = new Dictionary<string, MetadataToken> ();
+			this.import_scope_map = new Dictionary<ImportScopeRow, MetadataToken> (row_equality_comparer);
+		}
+
+		public void SetSymbolWriter (ISymbolWriter writer)
+		{
+			symbol_writer = writer;
+
+			if (symbol_writer == null && module.HasImage && module.Image.HasDebugTables ())
+				symbol_writer = new PortablePdbWriter (this, module);
+		}
+
+		TextMap CreateTextMap ()
+		{
+			var map = new TextMap ();
+			map.AddMap (TextSegment.ImportAddressTable, module.Architecture == TargetArchitecture.I386 ? 8 : 0);
+			map.AddMap (TextSegment.CLIHeader, 0x48, 8);
+			return map;
+		}
+
+		TTable GetTable<TTable> (Table table) where TTable : MetadataTable, new ()
+		{
+			return table_heap.GetTable<TTable> (table);
+		}
+
+		uint GetStringIndex (string @string)
+		{
+			if (string.IsNullOrEmpty (@string))
+				return 0;
+
+			return string_heap.GetStringIndex (@string);
+		}
+
+		uint GetGuidIndex (Guid guid)
+		{
+			return guid_heap.GetGuidIndex (guid);
+		}
+
+		uint GetBlobIndex (ByteBuffer blob)
+		{
+			if (blob.length == 0)
+				return 0;
+
+			return blob_heap.GetBlobIndex (blob);
+		}
+
+		uint GetBlobIndex (byte [] blob)
+		{
+			if (blob.IsNullOrEmpty ())
+				return 0;
+
+			return GetBlobIndex (new ByteBuffer (blob));
+		}
+
+		public void BuildMetadata ()
+		{
+			BuildModule ();
+
+			table_heap.string_offsets = string_heap.WriteStrings ();
+			table_heap.ComputeTableInformations ();
+			table_heap.WriteTableHeap ();
+		}
+
+		void BuildModule ()
+		{
+			var table = GetTable<ModuleTable> (Table.Module);
+			table.row.Col1 = GetStringIndex (module.Name);
+			table.row.Col2 = GetGuidIndex (module.Mvid);
+
+			var assembly = module.Assembly;
+
+			if (assembly != null)
+				BuildAssembly ();
+
+			if (module.HasAssemblyReferences)
+				AddAssemblyReferences ();
+
+			if (module.HasModuleReferences)
+				AddModuleReferences ();
+
+			if (module.HasResources)
+				AddResources ();
+
+			if (module.HasExportedTypes)
+				AddExportedTypes ();
+
+			BuildTypes ();
+
+			if (assembly != null) {
+				if (assembly.HasCustomAttributes)
+					AddCustomAttributes (assembly);
+
+				if (assembly.HasSecurityDeclarations)
+					AddSecurityDeclarations (assembly);
+			}
+
+			if (module.HasCustomAttributes)
+				AddCustomAttributes (module);
+
+			if (module.EntryPoint != null)
+				entry_point = LookupToken (module.EntryPoint);
+		}
+
+		void BuildAssembly ()
+		{
+			var assembly = module.Assembly;
+			var name = assembly.Name;
+
+			var table = GetTable<AssemblyTable> (Table.Assembly);
+
+			table.row = new AssemblyRow (
+				name.HashAlgorithm,
+				(ushort) name.Version.Major,
+				(ushort) name.Version.Minor,
+				(ushort) name.Version.Build,
+				(ushort) name.Version.Revision,
+				name.Attributes,
+				GetBlobIndex (name.PublicKey),
+				GetStringIndex (name.Name),
+				GetStringIndex (name.Culture));
+
+			if (assembly.Modules.Count > 1)
+				BuildModules ();
+		}
+
+		void BuildModules ()
+		{
+			var modules = this.module.Assembly.Modules;
+			var table = GetTable<FileTable> (Table.File);
+
+			for (int i = 0; i < modules.Count; i++) {
+				var module = modules [i];
+				if (module.IsMain)
+					continue;
+
+#if NET_CORE
+				throw new NotSupportedException ();
+#else
+				var parameters = new WriterParameters {
+					SymbolWriterProvider = symbol_writer_provider,
+				};
+
+				var file_name = GetModuleFileName (module.Name);
+				module.Write (file_name, parameters);
+
+				var hash = CryptoService.ComputeHash (file_name);
+
+				table.AddRow (new FileRow (
+					FileAttributes.ContainsMetaData,
+					GetStringIndex (module.Name),
+					GetBlobIndex (hash)));
+#endif
+			}
+		}
+
+#if !NET_CORE
+		string GetModuleFileName (string name)
+		{
+			if (string.IsNullOrEmpty (name))
+				throw new NotSupportedException ();
+
+			var path = Path.GetDirectoryName (fq_name);
+			return Path.Combine (path, name);
+		}
+#endif
+
+		void AddAssemblyReferences ()
+		{
+			var references = module.AssemblyReferences;
+			var table = GetTable<AssemblyRefTable> (Table.AssemblyRef);
+
+			if (module.IsWindowsMetadata ())
+				module.Projections.RemoveVirtualReferences (references);
+
+			for (int i = 0; i < references.Count; i++) {
+				var reference = references [i];
+
+				var key_or_token = reference.PublicKey.IsNullOrEmpty ()
+					? reference.PublicKeyToken
+					: reference.PublicKey;
+
+				var version = reference.Version;
+
+				var rid = table.AddRow (new AssemblyRefRow (
+					(ushort) version.Major,
+					(ushort) version.Minor,
+					(ushort) version.Build,
+					(ushort) version.Revision,
+					reference.Attributes,
+					GetBlobIndex (key_or_token),
+					GetStringIndex (reference.Name),
+					GetStringIndex (reference.Culture),
+					GetBlobIndex (reference.Hash)));
+
+				reference.token = new MetadataToken (TokenType.AssemblyRef, rid);
+			}
+
+			if (module.IsWindowsMetadata ())
+				module.Projections.AddVirtualReferences (references);
+		}
+
+		void AddModuleReferences ()
+		{
+			var references = module.ModuleReferences;
+			var table = GetTable<ModuleRefTable> (Table.ModuleRef);
+
+			for (int i = 0; i < references.Count; i++) {
+				var reference = references [i];
+
+				reference.token = new MetadataToken (
+					TokenType.ModuleRef,
+					table.AddRow (GetStringIndex (reference.Name)));
+			}
+		}
+
+		void AddResources ()
+		{
+			var resources = module.Resources;
+			var table = GetTable<ManifestResourceTable> (Table.ManifestResource);
+
+			for (int i = 0; i < resources.Count; i++) {
+				var resource = resources [i];
+
+				var row = new ManifestResourceRow (
+					0,
+					resource.Attributes,
+					GetStringIndex (resource.Name),
+					0);
+
+				switch (resource.ResourceType) {
+				case ResourceType.Embedded:
+					row.Col1 = AddEmbeddedResource ((EmbeddedResource) resource);
+					break;
+				case ResourceType.Linked:
+					row.Col4 = CodedIndex.Implementation.CompressMetadataToken (
+						new MetadataToken (
+							TokenType.File,
+							AddLinkedResource ((LinkedResource) resource)));
+					break;
+				case ResourceType.AssemblyLinked:
+					row.Col4 = CodedIndex.Implementation.CompressMetadataToken (
+						((AssemblyLinkedResource) resource).Assembly.MetadataToken);
+					break;
+				default:
+					throw new NotSupportedException ();
+				}
+
+				table.AddRow (row);
+			}
+		}
+
+		uint AddLinkedResource (LinkedResource resource)
+		{
+			var table = GetTable<FileTable> (Table.File);
+			var hash = resource.Hash;
+
+#if !NET_CORE
+			if (hash.IsNullOrEmpty ())
+				hash = CryptoService.ComputeHash (resource.File);
+#endif
+
+			return (uint) table.AddRow (new FileRow (
+				FileAttributes.ContainsNoMetaData,
+				GetStringIndex (resource.File),
+				GetBlobIndex (hash)));
+		}
+
+		uint AddEmbeddedResource (EmbeddedResource resource)
+		{
+			return resources.AddResource (resource.GetResourceData ());
+		}
+
+		void AddExportedTypes ()
+		{
+			var exported_types = module.ExportedTypes;
+			var table = GetTable<ExportedTypeTable> (Table.ExportedType);
+
+			for (int i = 0; i < exported_types.Count; i++) {
+				var exported_type = exported_types [i];
+
+				var rid = table.AddRow (new ExportedTypeRow (
+					exported_type.Attributes,
+					(uint) exported_type.Identifier,
+					GetStringIndex (exported_type.Name),
+					GetStringIndex (exported_type.Namespace),
+					MakeCodedRID (GetExportedTypeScope (exported_type), CodedIndex.Implementation)));
+
+				exported_type.token = new MetadataToken (TokenType.ExportedType, rid);
+			}
+		}
+
+		MetadataToken GetExportedTypeScope (ExportedType exported_type)
+		{
+			if (exported_type.DeclaringType != null)
+				return exported_type.DeclaringType.MetadataToken;
+
+			var scope = exported_type.Scope;
+			switch (scope.MetadataToken.TokenType) {
+			case TokenType.AssemblyRef:
+				return scope.MetadataToken;
+			case TokenType.ModuleRef:
+				var file_table = GetTable<FileTable> (Table.File);
+				for (int i = 0; i < file_table.length; i++)
+					if (file_table.rows [i].Col2 == GetStringIndex (scope.Name))
+						return new MetadataToken (TokenType.File, i + 1);
+
+				break;
+			}
+
+			throw new NotSupportedException ();
+		}
+
+		void BuildTypes ()
+		{
+			if (!module.HasTypes)
+				return;
+
+			AttachTokens ();
+			AddTypes ();
+			AddGenericParameters ();
+		}
+
+		void AttachTokens ()
+		{
+			var types = module.Types;
+
+			for (int i = 0; i < types.Count; i++)
+				AttachTypeToken (types [i]);
+		}
+
+		void AttachTypeToken (TypeDefinition type)
+		{
+			type.token = new MetadataToken (TokenType.TypeDef, type_rid++);
+			type.fields_range.Start = field_rid;
+			type.methods_range.Start = method_rid;
+
+			if (type.HasFields)
+				AttachFieldsToken (type);
+
+			if (type.HasMethods)
+				AttachMethodsToken (type);
+
+			if (type.HasNestedTypes)
+				AttachNestedTypesToken (type);
+		}
+
+		void AttachNestedTypesToken (TypeDefinition type)
+		{
+			var nested_types = type.NestedTypes;
+			for (int i = 0; i < nested_types.Count; i++)
+				AttachTypeToken (nested_types [i]);
+		}
+
+		void AttachFieldsToken (TypeDefinition type)
+		{
+			var fields = type.Fields;
+			type.fields_range.Length = (uint) fields.Count;
+			for (int i = 0; i < fields.Count; i++)
+				fields [i].token = new MetadataToken (TokenType.Field, field_rid++);
+		}
+
+		void AttachMethodsToken (TypeDefinition type)
+		{
+			var methods = type.Methods;
+			type.methods_range.Length = (uint) methods.Count;
+			for (int i = 0; i < methods.Count; i++)
+				methods [i].token = new MetadataToken (TokenType.Method, method_rid++);
+		}
+
+		MetadataToken GetTypeToken (TypeReference type)
+		{
+			if (type == null)
+				return MetadataToken.Zero;
+
+			if (type.IsDefinition)
+				return type.token;
+
+			if (type.IsTypeSpecification ())
+				return GetTypeSpecToken (type);
+
+			return GetTypeRefToken (type);
+		}
+
+		MetadataToken GetTypeSpecToken (TypeReference type)
+		{
+			var row = GetBlobIndex (GetTypeSpecSignature (type));
+
+			MetadataToken token;
+			if (type_spec_map.TryGetValue (row, out token))
+				return token;
+
+			return AddTypeSpecification (type, row);
+		}
+
+		MetadataToken AddTypeSpecification (TypeReference type, uint row)
+		{
+			type.token = new MetadataToken (TokenType.TypeSpec, typespec_table.AddRow (row));
+
+			var token = type.token;
+			type_spec_map.Add (row, token);
+			return token;
+		}
+
+		MetadataToken GetTypeRefToken (TypeReference type)
+		{
+			var projection = WindowsRuntimeProjections.RemoveProjection (type);
+
+			var row = CreateTypeRefRow (type);
+
+			MetadataToken token;
+			if (!type_ref_map.TryGetValue (row, out token))
+				token = AddTypeReference (type, row);
+
+			WindowsRuntimeProjections.ApplyProjection (type, projection);
+
+			return token;
+		}
+
+		TypeRefRow CreateTypeRefRow (TypeReference type)
+		{
+			var scope_token = GetScopeToken (type);
+
+			return new TypeRefRow (
+				MakeCodedRID (scope_token, CodedIndex.ResolutionScope),
+				GetStringIndex (type.Name),
+				GetStringIndex (type.Namespace));
+		}
+
+		MetadataToken GetScopeToken (TypeReference type)
+		{
+			if (type.IsNested)
+				return GetTypeRefToken (type.DeclaringType);
+
+			var scope = type.Scope;
+
+			if (scope == null)
+				return MetadataToken.Zero;
+
+			return scope.MetadataToken;
+		}
+
+		static CodedRID MakeCodedRID (IMetadataTokenProvider provider, CodedIndex index)
+		{
+			return MakeCodedRID (provider.MetadataToken, index);
+		}
+
+		static CodedRID MakeCodedRID (MetadataToken token, CodedIndex index)
+		{
+			return index.CompressMetadataToken (token);
+		}
+
+		MetadataToken AddTypeReference (TypeReference type, TypeRefRow row)
+		{
+			type.token = new MetadataToken (TokenType.TypeRef, type_ref_table.AddRow (row));
+
+			var token = type.token;
+			type_ref_map.Add (row, token);
+			return token;
+		}
+
+		void AddTypes ()
+		{
+			var types = module.Types;
+
+			for (int i = 0; i < types.Count; i++)
+				AddType (types [i]);
+		}
+
+		void AddType (TypeDefinition type)
+		{
+			var treatment = WindowsRuntimeProjections.RemoveProjection (type);
+
+			type_def_table.AddRow (new TypeDefRow (
+				type.Attributes,
+				GetStringIndex (type.Name),
+				GetStringIndex (type.Namespace),
+				MakeCodedRID (GetTypeToken (type.BaseType), CodedIndex.TypeDefOrRef),
+				type.fields_range.Start,
+				type.methods_range.Start));
+
+			if (type.HasGenericParameters)
+				AddGenericParameters (type);
+
+			if (type.HasInterfaces)
+				AddInterfaces (type);
+
+			AddLayoutInfo (type);
+
+			if (type.HasFields)
+				AddFields (type);
+
+			if (type.HasMethods)
+				AddMethods (type);
+
+			if (type.HasProperties)
+				AddProperties (type);
+
+			if (type.HasEvents)
+				AddEvents (type);
+
+			if (type.HasCustomAttributes)
+				AddCustomAttributes (type);
+
+			if (type.HasSecurityDeclarations)
+				AddSecurityDeclarations (type);
+
+			if (type.HasNestedTypes)
+				AddNestedTypes (type);
+
+			WindowsRuntimeProjections.ApplyProjection (type, treatment);
+		}
+
+		void AddGenericParameters (IGenericParameterProvider owner)
+		{
+			var parameters = owner.GenericParameters;
+
+			for (int i = 0; i < parameters.Count; i++)
+				generic_parameters.Add (parameters [i]);
+		}
+
+		sealed class GenericParameterComparer : IComparer<GenericParameter> {
+
+			public int Compare (GenericParameter a, GenericParameter b)
+			{
+				var a_owner = MakeCodedRID (a.Owner, CodedIndex.TypeOrMethodDef);
+				var b_owner = MakeCodedRID (b.Owner, CodedIndex.TypeOrMethodDef);
+				if (a_owner == b_owner) {
+					var a_pos = a.Position;
+					var b_pos = b.Position;
+					return a_pos == b_pos ? 0 : a_pos > b_pos ? 1 : -1;
+				}
+
+				return a_owner > b_owner ? 1 : -1;
+			}
+		}
+
+		void AddGenericParameters ()
+		{
+			var items = this.generic_parameters.items;
+			var size = this.generic_parameters.size;
+			Array.Sort (items, 0, size, new GenericParameterComparer ());
+
+			var generic_param_table = GetTable<GenericParamTable> (Table.GenericParam);
+			var generic_param_constraint_table = GetTable<GenericParamConstraintTable> (Table.GenericParamConstraint);
+
+			for (int i = 0; i < size; i++) {
+				var generic_parameter = items [i];
+
+				var rid = generic_param_table.AddRow (new GenericParamRow (
+					(ushort) generic_parameter.Position,
+					generic_parameter.Attributes,
+					MakeCodedRID (generic_parameter.Owner, CodedIndex.TypeOrMethodDef),
+					GetStringIndex (generic_parameter.Name)));
+
+				generic_parameter.token = new MetadataToken (TokenType.GenericParam, rid);
+
+				if (generic_parameter.HasConstraints)
+					AddConstraints (generic_parameter, generic_param_constraint_table);
+
+				if (generic_parameter.HasCustomAttributes)
+					AddCustomAttributes (generic_parameter);
+			}
+		}
+
+		void AddConstraints (GenericParameter generic_parameter, GenericParamConstraintTable table)
+		{
+			var constraints = generic_parameter.Constraints;
+
+			var rid = generic_parameter.token.RID;
+
+			for (int i = 0; i < constraints.Count; i++)
+				table.AddRow (new GenericParamConstraintRow (
+					rid,
+					MakeCodedRID (GetTypeToken (constraints [i]), CodedIndex.TypeDefOrRef)));
+		}
+
+		void AddInterfaces (TypeDefinition type)
+		{
+			var interfaces = type.Interfaces;
+			var type_rid = type.token.RID;
+
+			for (int i = 0; i < interfaces.Count; i++) {
+				var iface_impl = interfaces [i];
+
+				var rid = iface_impl_table.AddRow (new InterfaceImplRow (
+					type_rid,
+					MakeCodedRID (GetTypeToken (iface_impl.InterfaceType), CodedIndex.TypeDefOrRef)));
+
+				iface_impl.token = new MetadataToken (TokenType.InterfaceImpl, rid);
+
+				if (iface_impl.HasCustomAttributes)
+					AddCustomAttributes (iface_impl);
+			}
+		}
+
+		void AddLayoutInfo (TypeDefinition type)
+		{
+			if (type.HasLayoutInfo) {
+				var table = GetTable<ClassLayoutTable> (Table.ClassLayout);
+
+				table.AddRow (new ClassLayoutRow (
+					(ushort) type.PackingSize,
+					(uint) type.ClassSize,
+					type.token.RID));
+
+				return;
+			}
+
+			if (type.IsValueType && HasNoInstanceField (type)) {
+				var table = GetTable<ClassLayoutTable> (Table.ClassLayout);
+
+				table.AddRow (new ClassLayoutRow (0, 1, type.token.RID));
+			}
+		}
+
+		static bool HasNoInstanceField (TypeDefinition type)
+		{
+			if (!type.HasFields)
+				return true;
+
+			var fields = type.Fields;
+
+			for (int i = 0; i < fields.Count; i++)
+				if (!fields [i].IsStatic)
+					return false;
+
+			return true;
+		}
+
+		void AddNestedTypes (TypeDefinition type)
+		{
+			var nested_types = type.NestedTypes;
+			var nested_table = GetTable<NestedClassTable> (Table.NestedClass);
+
+			for (int i = 0; i < nested_types.Count; i++) {
+				var nested = nested_types [i];
+				AddType (nested);
+				nested_table.AddRow (new NestedClassRow (nested.token.RID, type.token.RID));
+			}
+		}
+
+		void AddFields (TypeDefinition type)
+		{
+			var fields = type.Fields;
+
+			for (int i = 0; i < fields.Count; i++)
+				AddField (fields [i]);
+		}
+
+		void AddField (FieldDefinition field)
+		{
+			var projection = WindowsRuntimeProjections.RemoveProjection (field);
+
+			field_table.AddRow (new FieldRow (
+				field.Attributes,
+				GetStringIndex (field.Name),
+				GetBlobIndex (GetFieldSignature (field))));
+
+			if (!field.InitialValue.IsNullOrEmpty ())
+				AddFieldRVA (field);
+
+			if (field.HasLayoutInfo)
+				AddFieldLayout (field);
+
+			if (field.HasCustomAttributes)
+				AddCustomAttributes (field);
+
+			if (field.HasConstant)
+				AddConstant (field, field.FieldType);
+
+			if (field.HasMarshalInfo)
+				AddMarshalInfo (field);
+
+			WindowsRuntimeProjections.ApplyProjection (field, projection);
+		}
+
+		void AddFieldRVA (FieldDefinition field)
+		{
+			var table = GetTable<FieldRVATable> (Table.FieldRVA);
+			table.AddRow (new FieldRVARow (
+				data.AddData (field.InitialValue),
+				field.token.RID));
+		}
+
+		void AddFieldLayout (FieldDefinition field)
+		{
+			var table = GetTable<FieldLayoutTable> (Table.FieldLayout);
+			table.AddRow (new FieldLayoutRow ((uint) field.Offset, field.token.RID));
+		}
+
+		void AddMethods (TypeDefinition type)
+		{
+			var methods = type.Methods;
+
+			for (int i = 0; i < methods.Count; i++)
+				AddMethod (methods [i]);
+		}
+
+		void AddMethod (MethodDefinition method)
+		{
+			var projection = WindowsRuntimeProjections.RemoveProjection (method);
+
+			method_table.AddRow (new MethodRow (
+				method.HasBody ? code.WriteMethodBody (method) : 0,
+				method.ImplAttributes,
+				method.Attributes,
+				GetStringIndex (method.Name),
+				GetBlobIndex (GetMethodSignature (method)),
+				param_rid));
+
+			AddParameters (method);
+
+			if (method.HasGenericParameters)
+				AddGenericParameters (method);
+
+			if (method.IsPInvokeImpl)
+				AddPInvokeInfo (method);
+
+			if (method.HasCustomAttributes)
+				AddCustomAttributes (method);
+
+			if (method.HasSecurityDeclarations)
+				AddSecurityDeclarations (method);
+
+			if (method.HasOverrides)
+				AddOverrides (method);
+
+			WindowsRuntimeProjections.ApplyProjection (method, projection);
+		}
+
+		void AddParameters (MethodDefinition method)
+		{
+			var return_parameter = method.MethodReturnType.parameter;
+
+			if (return_parameter != null && RequiresParameterRow (return_parameter))
+				AddParameter (0, return_parameter, param_table);
+
+			if (!method.HasParameters)
+				return;
+
+			var parameters = method.Parameters;
+
+			for (int i = 0; i < parameters.Count; i++) {
+				var parameter = parameters [i];
+				if (!RequiresParameterRow (parameter))
+					continue;
+
+				AddParameter ((ushort) (i + 1), parameter, param_table);
+			}
+		}
+
+		void AddPInvokeInfo (MethodDefinition method)
+		{
+			var pinvoke = method.PInvokeInfo;
+			if (pinvoke == null)
+				return;
+
+			var table = GetTable<ImplMapTable> (Table.ImplMap);
+			table.AddRow (new ImplMapRow (
+				pinvoke.Attributes,
+				MakeCodedRID (method, CodedIndex.MemberForwarded),
+				GetStringIndex (pinvoke.EntryPoint),
+				pinvoke.Module.MetadataToken.RID));
+		}
+
+		void AddOverrides (MethodDefinition method)
+		{
+			var overrides = method.Overrides;
+			var table = GetTable<MethodImplTable> (Table.MethodImpl);
+
+			for (int i = 0; i < overrides.Count; i++) {
+				table.AddRow (new MethodImplRow (
+					method.DeclaringType.token.RID,
+					MakeCodedRID (method, CodedIndex.MethodDefOrRef),
+					MakeCodedRID (LookupToken (overrides [i]), CodedIndex.MethodDefOrRef)));
+			}
+		}
+
+		static bool RequiresParameterRow (ParameterDefinition parameter)
+		{
+			return !string.IsNullOrEmpty (parameter.Name)
+				|| parameter.Attributes != ParameterAttributes.None
+				|| parameter.HasMarshalInfo
+				|| parameter.HasConstant
+				|| parameter.HasCustomAttributes;
+		}
+
+		void AddParameter (ushort sequence, ParameterDefinition parameter, ParamTable table)
+		{
+			table.AddRow (new ParamRow (
+				parameter.Attributes,
+				sequence,
+				GetStringIndex (parameter.Name)));
+
+			parameter.token = new MetadataToken (TokenType.Param, param_rid++);
+
+			if (parameter.HasCustomAttributes)
+				AddCustomAttributes (parameter);
+
+			if (parameter.HasConstant)
+				AddConstant (parameter, parameter.ParameterType);
+
+			if (parameter.HasMarshalInfo)
+				AddMarshalInfo (parameter);
+		}
+
+		void AddMarshalInfo (IMarshalInfoProvider owner)
+		{
+			var table = GetTable<FieldMarshalTable> (Table.FieldMarshal);
+
+			table.AddRow (new FieldMarshalRow (
+				MakeCodedRID (owner, CodedIndex.HasFieldMarshal),
+				GetBlobIndex (GetMarshalInfoSignature (owner))));
+		}
+
+		void AddProperties (TypeDefinition type)
+		{
+			var properties = type.Properties;
+
+			property_map_table.AddRow (new PropertyMapRow (type.token.RID, property_rid));
+
+			for (int i = 0; i < properties.Count; i++)
+				AddProperty (properties [i]);
+		}
+
+		void AddProperty (PropertyDefinition property)
+		{
+			property_table.AddRow (new PropertyRow (
+				property.Attributes,
+				GetStringIndex (property.Name),
+				GetBlobIndex (GetPropertySignature (property))));
+			property.token = new MetadataToken (TokenType.Property, property_rid++);
+
+			var method = property.GetMethod;
+			if (method != null)
+				AddSemantic (MethodSemanticsAttributes.Getter, property, method);
+
+			method = property.SetMethod;
+			if (method != null)
+				AddSemantic (MethodSemanticsAttributes.Setter, property, method);
+
+			if (property.HasOtherMethods)
+				AddOtherSemantic (property, property.OtherMethods);
+
+			if (property.HasCustomAttributes)
+				AddCustomAttributes (property);
+
+			if (property.HasConstant)
+				AddConstant (property, property.PropertyType);
+		}
+
+		void AddOtherSemantic (IMetadataTokenProvider owner, Collection<MethodDefinition> others)
+		{
+			for (int i = 0; i < others.Count; i++)
+				AddSemantic (MethodSemanticsAttributes.Other, owner, others [i]);
+		}
+
+		void AddEvents (TypeDefinition type)
+		{
+			var events = type.Events;
+
+			event_map_table.AddRow (new EventMapRow (type.token.RID, event_rid));
+
+			for (int i = 0; i < events.Count; i++)
+				AddEvent (events [i]);
+		}
+
+		void AddEvent (EventDefinition @event)
+		{
+			event_table.AddRow (new EventRow (
+				@event.Attributes,
+				GetStringIndex (@event.Name),
+				MakeCodedRID (GetTypeToken (@event.EventType), CodedIndex.TypeDefOrRef)));
+			@event.token = new MetadataToken (TokenType.Event, event_rid++);
+
+			var method = @event.AddMethod;
+			if (method != null)
+				AddSemantic (MethodSemanticsAttributes.AddOn, @event, method);
+
+			method = @event.InvokeMethod;
+			if (method != null)
+				AddSemantic (MethodSemanticsAttributes.Fire, @event, method);
+
+			method = @event.RemoveMethod;
+			if (method != null)
+				AddSemantic (MethodSemanticsAttributes.RemoveOn, @event, method);
+
+			if (@event.HasOtherMethods)
+				AddOtherSemantic (@event, @event.OtherMethods);
+
+			if (@event.HasCustomAttributes)
+				AddCustomAttributes (@event);
+		}
+
+		void AddSemantic (MethodSemanticsAttributes semantics, IMetadataTokenProvider provider, MethodDefinition method)
+		{
+			method.SemanticsAttributes = semantics;
+			var table = GetTable<MethodSemanticsTable> (Table.MethodSemantics);
+
+			table.AddRow (new MethodSemanticsRow (
+				semantics,
+				method.token.RID,
+				MakeCodedRID (provider, CodedIndex.HasSemantics)));
+		}
+
+		void AddConstant (IConstantProvider owner, TypeReference type)
+		{
+			var constant = owner.Constant;
+			var etype = GetConstantType (type, constant);
+
+			constant_table.AddRow (new ConstantRow (
+				etype,
+				MakeCodedRID (owner.MetadataToken, CodedIndex.HasConstant),
+				GetBlobIndex (GetConstantSignature (etype, constant))));
+		}
+
+		static ElementType GetConstantType (TypeReference constant_type, object constant)
+		{
+			if (constant == null)
+				return ElementType.Class;
+
+			var etype = constant_type.etype;
+			switch (etype) {
+			case ElementType.None:
+				var type = constant_type.CheckedResolve ();
+				if (type.IsEnum)
+					return GetConstantType (type.GetEnumUnderlyingType (), constant);
+
+				return ElementType.Class;
+			case ElementType.String:
+				return ElementType.String;
+			case ElementType.Object:
+				return GetConstantType (constant.GetType ());
+			case ElementType.Array:
+			case ElementType.SzArray:
+			case ElementType.MVar:
+			case ElementType.Var:
+				return ElementType.Class;
+			case ElementType.GenericInst:
+				var generic_instance = (GenericInstanceType) constant_type;
+				if (generic_instance.ElementType.IsTypeOf ("System", "Nullable`1"))
+					return GetConstantType (generic_instance.GenericArguments [0], constant);
+
+				return GetConstantType (((TypeSpecification) constant_type).ElementType, constant);
+			case ElementType.CModOpt:
+			case ElementType.CModReqD:
+			case ElementType.ByRef:
+			case ElementType.Sentinel:
+				return GetConstantType (((TypeSpecification) constant_type).ElementType, constant);
+			case ElementType.Boolean:
+			case ElementType.Char:
+			case ElementType.I:
+			case ElementType.I1:
+			case ElementType.I2:
+			case ElementType.I4:
+			case ElementType.I8:
+			case ElementType.U:
+			case ElementType.U1:
+			case ElementType.U2:
+			case ElementType.U4:
+			case ElementType.U8:
+			case ElementType.R4:
+			case ElementType.R8:
+				return GetConstantType (constant.GetType ());
+			default:
+				return etype;
+			}
+		}
+
+		static ElementType GetConstantType (Type type)
+		{
+			switch (type.GetTypeCode ()) {
+			case TypeCode.Boolean:
+				return ElementType.Boolean;
+			case TypeCode.Byte:
+				return ElementType.U1;
+			case TypeCode.SByte:
+				return ElementType.I1;
+			case TypeCode.Char:
+				return ElementType.Char;
+			case TypeCode.Int16:
+				return ElementType.I2;
+			case TypeCode.UInt16:
+				return ElementType.U2;
+			case TypeCode.Int32:
+				return ElementType.I4;
+			case TypeCode.UInt32:
+				return ElementType.U4;
+			case TypeCode.Int64:
+				return ElementType.I8;
+			case TypeCode.UInt64:
+				return ElementType.U8;
+			case TypeCode.Single:
+				return ElementType.R4;
+			case TypeCode.Double:
+				return ElementType.R8;
+			case TypeCode.String:
+				return ElementType.String;
+			default:
+				throw new NotSupportedException (type.FullName);
+			}
+		}
+
+		void AddCustomAttributes (ICustomAttributeProvider owner)
+		{
+			var custom_attributes = owner.CustomAttributes;
+
+			for (int i = 0; i < custom_attributes.Count; i++) {
+				var attribute = custom_attributes [i];
+
+				var projection = WindowsRuntimeProjections.RemoveProjection (attribute);
+
+				custom_attribute_table.AddRow (new CustomAttributeRow (
+					MakeCodedRID (owner, CodedIndex.HasCustomAttribute),
+					MakeCodedRID (LookupToken (attribute.Constructor), CodedIndex.CustomAttributeType),
+					GetBlobIndex (GetCustomAttributeSignature (attribute))));
+
+				WindowsRuntimeProjections.ApplyProjection (attribute, projection);
+			}
+		}
+
+		void AddSecurityDeclarations (ISecurityDeclarationProvider owner)
+		{
+			var declarations = owner.SecurityDeclarations;
+
+			for (int i = 0; i < declarations.Count; i++) {
+				var declaration = declarations [i];
+
+				declsec_table.AddRow (new DeclSecurityRow (
+					declaration.Action,
+					MakeCodedRID (owner, CodedIndex.HasDeclSecurity),
+					GetBlobIndex (GetSecurityDeclarationSignature (declaration))));
+			}
+		}
+
+		MetadataToken GetMemberRefToken (MemberReference member)
+		{
+			var projection = WindowsRuntimeProjections.RemoveProjection (member);
+
+			var row = CreateMemberRefRow (member);
+
+			MetadataToken token;
+			if (!member_ref_map.TryGetValue (row, out token))
+				token = AddMemberReference (member, row);
+
+			WindowsRuntimeProjections.ApplyProjection (member, projection);
+
+			return token;
+		}
+
+		MemberRefRow CreateMemberRefRow (MemberReference member)
+		{
+			return new MemberRefRow (
+				MakeCodedRID (GetTypeToken (member.DeclaringType), CodedIndex.MemberRefParent),
+				GetStringIndex (member.Name),
+				GetBlobIndex (GetMemberRefSignature (member)));
+		}
+
+		MetadataToken AddMemberReference (MemberReference member, MemberRefRow row)
+		{
+			member.token = new MetadataToken (TokenType.MemberRef, member_ref_table.AddRow (row));
+
+			var token = member.token;
+			member_ref_map.Add (row, token);
+			return token;
+		}
+
+		MetadataToken GetMethodSpecToken (MethodSpecification method_spec)
+		{
+			var row = CreateMethodSpecRow (method_spec);
+
+			MetadataToken token;
+			if (method_spec_map.TryGetValue (row, out token))
+				return token;
+
+			AddMethodSpecification (method_spec, row);
+
+			return method_spec.token;
+		}
+
+		void AddMethodSpecification (MethodSpecification method_spec, MethodSpecRow row)
+		{
+			method_spec.token = new MetadataToken (TokenType.MethodSpec, method_spec_table.AddRow (row));
+			method_spec_map.Add (row, method_spec.token);
+		}
+
+		MethodSpecRow CreateMethodSpecRow (MethodSpecification method_spec)
+		{
+			return new MethodSpecRow (
+				MakeCodedRID (LookupToken (method_spec.ElementMethod), CodedIndex.MethodDefOrRef),
+				GetBlobIndex (GetMethodSpecSignature (method_spec)));
+		}
+
+		SignatureWriter CreateSignatureWriter ()
+		{
+			return new SignatureWriter (this);
+		}
+
+		SignatureWriter GetMethodSpecSignature (MethodSpecification method_spec)
+		{
+			if (!method_spec.IsGenericInstance)
+				throw new NotSupportedException ();
+
+			var generic_instance = (GenericInstanceMethod) method_spec;
+
+			var signature = CreateSignatureWriter ();
+			signature.WriteByte (0x0a);
+
+			signature.WriteGenericInstanceSignature (generic_instance);
+
+			return signature;
+		}
+
+		public uint AddStandAloneSignature (uint signature)
+		{
+			return (uint) standalone_sig_table.AddRow (signature);
+		}
+
+		public uint GetLocalVariableBlobIndex (Collection<VariableDefinition> variables)
+		{
+			return GetBlobIndex (GetVariablesSignature (variables));
+		}
+
+		public uint GetCallSiteBlobIndex (CallSite call_site)
+		{
+			return GetBlobIndex (GetMethodSignature (call_site));
+		}
+
+		public uint GetConstantTypeBlobIndex (TypeReference constant_type)
+		{
+			return GetBlobIndex (GetConstantTypeSignature (constant_type));
+		}
+
+		SignatureWriter GetVariablesSignature (Collection<VariableDefinition> variables)
+		{
+			var signature = CreateSignatureWriter ();
+			signature.WriteByte (0x7);
+			signature.WriteCompressedUInt32 ((uint) variables.Count);
+			for (int i = 0; i < variables.Count; i++)
+				signature.WriteTypeSignature (variables [i].VariableType);
+			return signature;
+		}
+
+		SignatureWriter GetConstantTypeSignature (TypeReference constant_type)
+		{
+			var signature = CreateSignatureWriter ();
+			signature.WriteByte (0x6);
+			signature.WriteTypeSignature (constant_type);
+			return signature;
+		}
+
+		SignatureWriter GetFieldSignature (FieldReference field)
+		{
+			var signature = CreateSignatureWriter ();
+			signature.WriteByte (0x6);
+			signature.WriteTypeSignature (field.FieldType);
+			return signature;
+		}
+
+		SignatureWriter GetMethodSignature (IMethodSignature method)
+		{
+			var signature = CreateSignatureWriter ();
+			signature.WriteMethodSignature (method);
+			return signature;
+		}
+
+		SignatureWriter GetMemberRefSignature (MemberReference member)
+		{
+			var field = member as FieldReference;
+			if (field != null)
+				return GetFieldSignature (field);
+
+			var method = member as MethodReference;
+			if (method != null)
+				return GetMethodSignature (method);
+
+			throw new NotSupportedException ();
+		}
+
+		SignatureWriter GetPropertySignature (PropertyDefinition property)
+		{
+			var signature = CreateSignatureWriter ();
+			byte calling_convention = 0x8;
+			if (property.HasThis)
+				calling_convention |= 0x20;
+
+			uint param_count = 0;
+			Collection<ParameterDefinition> parameters = null;
+
+			if (property.HasParameters) {
+				parameters = property.Parameters;
+				param_count = (uint) parameters.Count;
+			}
+
+			signature.WriteByte (calling_convention);
+			signature.WriteCompressedUInt32 (param_count);
+			signature.WriteTypeSignature (property.PropertyType);
+
+			if (param_count == 0)
+				return signature;
+
+			for (int i = 0; i < param_count; i++)
+				signature.WriteTypeSignature (parameters [i].ParameterType);
+
+			return signature;
+		}
+
+		SignatureWriter GetTypeSpecSignature (TypeReference type)
+		{
+			var signature = CreateSignatureWriter ();
+			signature.WriteTypeSignature (type);
+			return signature;
+		}
+
+		SignatureWriter GetConstantSignature (ElementType type, object value)
+		{
+			var signature = CreateSignatureWriter ();
+
+			switch (type) {
+			case ElementType.Array:
+			case ElementType.SzArray:
+			case ElementType.Class:
+			case ElementType.Object:
+			case ElementType.None:
+			case ElementType.Var:
+			case ElementType.MVar:
+				signature.WriteInt32 (0);
+				break;
+			case ElementType.String:
+				signature.WriteConstantString ((string) value);
+				break;
+			default:
+				signature.WriteConstantPrimitive (value);
+				break;
+			}
+
+			return signature;
+		}
+
+		SignatureWriter GetCustomAttributeSignature (CustomAttribute attribute)
+		{
+			var signature = CreateSignatureWriter ();
+			if (!attribute.resolved) {
+				signature.WriteBytes (attribute.GetBlob ());
+				return signature;
+			}
+
+			signature.WriteUInt16 (0x0001);
+
+			signature.WriteCustomAttributeConstructorArguments (attribute);
+
+			signature.WriteCustomAttributeNamedArguments (attribute);
+
+			return signature;
+		}
+
+		SignatureWriter GetSecurityDeclarationSignature (SecurityDeclaration declaration)
+		{
+			var signature = CreateSignatureWriter ();
+
+			if (!declaration.resolved)
+				signature.WriteBytes (declaration.GetBlob ());
+			else if (module.Runtime < TargetRuntime.Net_2_0)
+				signature.WriteXmlSecurityDeclaration (declaration);
+			else
+				signature.WriteSecurityDeclaration (declaration);
+
+			return signature;
+		}
+
+		SignatureWriter GetMarshalInfoSignature (IMarshalInfoProvider owner)
+		{
+			var signature = CreateSignatureWriter ();
+
+			signature.WriteMarshalInfo (owner.MarshalInfo);
+
+			return signature;
+		}
+
+		static Exception CreateForeignMemberException (MemberReference member)
+		{
+			return new ArgumentException (string.Format ("Member '{0}' is declared in another module and needs to be imported", member));
+		}
+
+		public MetadataToken LookupToken (IMetadataTokenProvider provider)
+		{
+			if (provider == null)
+				throw new ArgumentNullException ();
+
+			if (metadata_builder != null)
+				return metadata_builder.LookupToken (provider);
+
+			var member = provider as MemberReference;
+			if (member == null || member.Module != module)
+				throw CreateForeignMemberException (member);
+
+			var token = provider.MetadataToken;
+
+			switch (token.TokenType) {
+			case TokenType.TypeDef:
+			case TokenType.Method:
+			case TokenType.Field:
+			case TokenType.Event:
+			case TokenType.Property:
+				return token;
+			case TokenType.TypeRef:
+			case TokenType.TypeSpec:
+			case TokenType.GenericParam:
+				return GetTypeToken ((TypeReference) provider);
+			case TokenType.MethodSpec:
+				return GetMethodSpecToken ((MethodSpecification) provider);
+			case TokenType.MemberRef:
+				return GetMemberRefToken (member);
+			default:
+				throw new NotSupportedException ();
+			}
+		}
+
+		public void AddMethodDebugInformation (MethodDebugInformation method_info)
+		{
+			if (method_info.HasSequencePoints)
+				AddSequencePoints (method_info);
+
+			if (method_info.Scope != null)
+				AddLocalScope (method_info, method_info.Scope);
+
+			if (method_info.StateMachineKickOffMethod != null)
+				AddStateMachineMethod (method_info);
+
+			AddCustomDebugInformations (method_info.Method);
+		}
+
+		void AddStateMachineMethod (MethodDebugInformation method_info)
+		{
+			state_machine_method_table.AddRow (new StateMachineMethodRow (method_info.Method.MetadataToken.RID, method_info.StateMachineKickOffMethod.MetadataToken.RID));
+		}
+
+		void AddLocalScope (MethodDebugInformation method_info, ScopeDebugInformation scope)
+		{
+			var rid = local_scope_table.AddRow (new LocalScopeRow (
+				method_info.Method.MetadataToken.RID,
+				scope.import != null ? AddImportScope (scope.import) : 0,
+				local_variable_rid,
+				local_constant_rid,
+				(uint) scope.Start.Offset,
+				(uint) ((scope.End.IsEndOfMethod ? method_info.code_size : scope.End.Offset) - scope.Start.Offset)));
+
+			scope.token = new MetadataToken (TokenType.LocalScope, rid);
+
+			AddCustomDebugInformations (scope);
+
+			if (scope.HasVariables)
+				AddLocalVariables (scope);
+
+			if (scope.HasConstants)
+				AddLocalConstants (scope);
+
+			for (int i = 0; i < scope.Scopes.Count; i++)
+				AddLocalScope (method_info, scope.Scopes [i]);
+		}
+
+		void AddLocalVariables (ScopeDebugInformation scope)
+		{
+			for (int i = 0; i < scope.Variables.Count; i++) {
+				var variable = scope.Variables [i];
+				local_variable_table.AddRow (new LocalVariableRow (variable.Attributes, (ushort) variable.Index, GetStringIndex (variable.Name)));
+				variable.token = new MetadataToken (TokenType.LocalVariable, local_variable_rid);
+				local_variable_rid++;
+
+				AddCustomDebugInformations (variable);
+			}
+		}
+
+		void AddLocalConstants (ScopeDebugInformation scope)
+		{
+			for (int i = 0; i < scope.Constants.Count; i++) {
+				var constant = scope.Constants [i];
+				local_constant_table.AddRow (new LocalConstantRow (GetStringIndex (constant.Name), GetBlobIndex (GetConstantSignature(constant))));
+				constant.token = new MetadataToken (TokenType.LocalConstant, local_constant_rid);
+				local_constant_rid++;
+			}
+		}
+
+		SignatureWriter GetConstantSignature (ConstantDebugInformation constant)
+		{
+			var type = constant.ConstantType;
+
+			var signature = CreateSignatureWriter ();
+			signature.WriteTypeSignature (type);
+
+			if (type.IsTypeOf ("System", "Decimal")) {
+				var bits = decimal.GetBits ((decimal) constant.Value);
+
+				var low = (uint) bits [0];
+				var mid = (uint) bits [1];
+				var high = (uint) bits [2];
+
+				var scale = (byte) (bits [3] >> 16);
+				var negative = (bits [3] & 0x80000000) != 0;
+
+				signature.WriteByte ((byte) (scale | (negative ? 0x80 : 0x00)));
+				signature.WriteUInt32 (low);
+				signature.WriteUInt32 (mid);
+				signature.WriteUInt32 (high);
+
+				return signature;
+			}
+
+			if (type.IsTypeOf ("System", "DateTime")) {
+				var date = (DateTime) constant.Value;
+				signature.WriteInt64 (date.Ticks);
+				return signature;
+			}
+
+			signature.WriteBytes (GetConstantSignature (type.etype, constant.Value));
+
+			return signature;
+		}
+
+		public void AddCustomDebugInformations (ICustomDebugInformationProvider provider)
+		{
+			if (!provider.HasCustomDebugInformations)
+				return;
+
+			var custom_infos = provider.CustomDebugInformations;
+
+			for (int i = 0; i < custom_infos.Count; i++) {
+				var custom_info = custom_infos [i];
+				switch (custom_info.Kind) {
+				case CustomDebugInformationKind.Binary:
+					var binary_info = (BinaryCustomDebugInformation) custom_info;
+					AddCustomDebugInformation (provider, binary_info, GetBlobIndex (binary_info.Data));
+					break;
+				case CustomDebugInformationKind.AsyncMethodBody:
+					AddAsyncMethodBodyDebugInformation (provider, (AsyncMethodBodyDebugInformation) custom_info);
+					break;
+				case CustomDebugInformationKind.StateMachineScope:
+					AddStateMachineScopeDebugInformation (provider, (StateMachineScopeDebugInformation) custom_info);
+					break;
+				case CustomDebugInformationKind.EmbeddedSource:
+					AddEmbeddedSourceDebugInformation (provider, (EmbeddedSourceDebugInformation) custom_info);
+					break;
+				case CustomDebugInformationKind.SourceLink:
+					AddSourceLinkDebugInformation (provider, (SourceLinkDebugInformation) custom_info);
+					break;
+				default:
+					throw new NotImplementedException ();
+				}
+			}
+		}
+
+		void AddStateMachineScopeDebugInformation (ICustomDebugInformationProvider provider, StateMachineScopeDebugInformation state_machine_scope)
+		{
+			var method_info = ((MethodDefinition) provider).DebugInformation;
+
+			var signature = CreateSignatureWriter ();
+
+			var scopes = state_machine_scope.Scopes;
+
+			for (int i = 0; i < scopes.Count; i++) {
+				var scope = scopes [i];
+				signature.WriteUInt32 ((uint) scope.Start.Offset);
+
+				var end_offset = scope.End.IsEndOfMethod
+					? method_info.code_size
+					: scope.End.Offset;
+
+				signature.WriteUInt32 ((uint) (end_offset - scope.Start.Offset));
+			}
+
+			AddCustomDebugInformation (provider, state_machine_scope, signature);
+		}
+
+		void AddAsyncMethodBodyDebugInformation (ICustomDebugInformationProvider provider, AsyncMethodBodyDebugInformation async_method)
+		{
+			var signature = CreateSignatureWriter ();
+			signature.WriteUInt32 ((uint) async_method.catch_handler.Offset + 1);
+
+			if (!async_method.yields.IsNullOrEmpty ()) {
+				for (int i = 0; i < async_method.yields.Count; i++) {
+					signature.WriteUInt32 ((uint) async_method.yields [i].Offset);
+					signature.WriteUInt32 ((uint) async_method.resumes [i].Offset);
+					signature.WriteCompressedUInt32 (async_method.resume_methods [i].MetadataToken.RID);
+				}
+			}
+
+			AddCustomDebugInformation (provider, async_method, signature);
+		}
+
+		void AddEmbeddedSourceDebugInformation (ICustomDebugInformationProvider provider, EmbeddedSourceDebugInformation embedded_source)
+		{
+			var signature = CreateSignatureWriter ();
+			var content = embedded_source.content ?? Empty<byte>.Array;
+			if (embedded_source.compress) {
+				signature.WriteInt32 (content.Length);
+
+				var decompressed_stream = new MemoryStream (content);
+				var content_stream = new MemoryStream ();
+
+				using (var compress_stream = new DeflateStream (content_stream, CompressionMode.Compress, leaveOpen: true))
+					decompressed_stream.CopyTo (compress_stream);
+
+				signature.WriteBytes (content_stream.ToArray ());
+			} else {
+				signature.WriteInt32 (0);
+				signature.WriteBytes (content);
+			}
+
+			AddCustomDebugInformation (provider, embedded_source, signature);
+		}
+
+		void AddSourceLinkDebugInformation (ICustomDebugInformationProvider provider, SourceLinkDebugInformation source_link)
+		{
+			var signature = CreateSignatureWriter ();
+			signature.WriteBytes (Encoding.UTF8.GetBytes (source_link.content));
+
+			AddCustomDebugInformation (provider, source_link, signature);
+		}
+
+		void AddCustomDebugInformation (ICustomDebugInformationProvider provider, CustomDebugInformation custom_info, SignatureWriter signature)
+		{
+			AddCustomDebugInformation (provider, custom_info, GetBlobIndex (signature));
+		}
+
+		void AddCustomDebugInformation (ICustomDebugInformationProvider provider, CustomDebugInformation custom_info, uint blob_index)
+		{
+			var rid = custom_debug_information_table.AddRow (new CustomDebugInformationRow (
+				MakeCodedRID (provider.MetadataToken, CodedIndex.HasCustomDebugInformation),
+				GetGuidIndex (custom_info.Identifier),
+				blob_index));
+
+			custom_info.token = new MetadataToken (TokenType.CustomDebugInformation, rid);
+		}
+
+		uint AddImportScope (ImportDebugInformation import)
+		{
+			uint parent = 0;
+			if (import.Parent != null)
+				parent = AddImportScope (import.Parent);
+
+			uint targets_index = 0;
+			if (import.HasTargets) {
+				var signature = CreateSignatureWriter ();
+
+				for (int i = 0; i < import.Targets.Count; i++)
+					AddImportTarget (import.Targets [i], signature);
+
+				targets_index = GetBlobIndex (signature);
+			}
+
+			var row = new ImportScopeRow (parent, targets_index);
+
+			MetadataToken import_token;
+			if (import_scope_map.TryGetValue (row, out import_token))
+				return import_token.RID;
+
+			import_token = new MetadataToken (TokenType.ImportScope, import_scope_table.AddRow (row));
+			import_scope_map.Add (row, import_token);
+
+			return import_token.RID;
+		}
+
+		void AddImportTarget (ImportTarget target, SignatureWriter signature)
+		{
+			signature.WriteCompressedUInt32 ((uint)target.kind);
+
+			switch (target.kind) {
+			case ImportTargetKind.ImportNamespace:
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
+				break;
+			case ImportTargetKind.ImportNamespaceInAssembly:
+				signature.WriteCompressedUInt32 (target.reference.MetadataToken.RID);
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
+				break;
+			case ImportTargetKind.ImportType:
+				signature.WriteTypeToken (target.type);
+				break;
+			case ImportTargetKind.ImportXmlNamespaceWithAlias:
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));	
+				break;
+			case ImportTargetKind.ImportAlias:
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
+				break;
+			case ImportTargetKind.DefineAssemblyAlias:
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
+				signature.WriteCompressedUInt32 (target.reference.MetadataToken.RID);
+				break;
+			case ImportTargetKind.DefineNamespaceAlias:
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
+				break;
+			case ImportTargetKind.DefineNamespaceInAssemblyAlias:
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
+				signature.WriteCompressedUInt32 (target.reference.MetadataToken.RID);
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
+				break;
+			case ImportTargetKind.DefineTypeAlias:
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
+				signature.WriteTypeToken (target.type);
+				break;
+			}
+		}
+
+		uint GetUTF8StringBlobIndex (string s)
+		{
+			return GetBlobIndex (Encoding.UTF8.GetBytes (s));
+		}
+
+		public MetadataToken GetDocumentToken (Document document)
+		{
+			MetadataToken token;
+			if (document_map.TryGetValue (document.Url, out token))
+				return token;
+
+			token = new MetadataToken (TokenType.Document, document_table.AddRow (
+				new DocumentRow (GetBlobIndex (GetDocumentNameSignature (document)),
+				GetGuidIndex (document.HashAlgorithm.ToGuid ()),
+				GetBlobIndex (document.Hash),
+				GetGuidIndex (document.Language.ToGuid ()))));
+
+			document.token = token;
+
+			AddCustomDebugInformations (document);
+
+			document_map.Add (document.Url, token);
+
+			return token;
+		}
+
+		SignatureWriter GetDocumentNameSignature (Document document)
+		{
+			var name = document.Url;
+			var signature = CreateSignatureWriter ();
+
+			char separator;
+			if (!TryGetDocumentNameSeparator (name, out separator)) {
+				signature.WriteByte (0);
+				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (name));
+				return signature;
+			}
+
+			signature.WriteByte ((byte) separator);
+			var parts = name.Split (new [] { separator });
+			for (int i = 0; i < parts.Length; i++) {
+				if (parts [i] == String.Empty)
+					signature.WriteCompressedUInt32 (0);
+				else
+					signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (parts [i]));
+			}
+
+			return signature;
+		}
+
+		static bool TryGetDocumentNameSeparator (string path, out char separator)
+		{
+			const char unix = '/';
+			const char win = '\\';
+			const char zero = (char) 0;
+
+			separator = zero;
+			if (string.IsNullOrEmpty (path))
+				return false;
+
+			int unix_count = 0;
+			int win_count = 0;
+
+			for (int i = 0; i < path.Length; i++) {
+				if (path [i] == unix)
+					unix_count++;
+				else if (path [i] == win)
+					win_count++;
+			}
+
+			if (unix_count == 0 && win_count == 0)
+				return false;
+
+			if (unix_count >= win_count) {
+				separator = unix;
+				return true;
+			}
+
+			separator = win;
+			return true;
+		}
+
+		void AddSequencePoints (MethodDebugInformation info)
+		{
+			var rid = info.Method.MetadataToken.RID;
+
+			Document document;
+			if (info.TryGetUniqueDocument (out document))
+				method_debug_information_table.rows [rid - 1].Col1 = GetDocumentToken (document).RID;
+
+			var signature = CreateSignatureWriter ();
+			signature.WriteSequencePoints (info);
+
+			method_debug_information_table.rows [rid - 1].Col2 = GetBlobIndex (signature);
+		}
+	}
+
+	sealed class SignatureWriter : ByteBuffer {
+
+		readonly MetadataBuilder metadata;
+
+		public SignatureWriter (MetadataBuilder metadata)
+			: base (6)
+		{
+			this.metadata = metadata;
+		}
+
+		public void WriteElementType (ElementType element_type)
+		{
+			WriteByte ((byte) element_type);
+		}
+
+		public void WriteUTF8String (string @string)
+		{
+			if (@string == null) {
+				WriteByte (0xff);
+				return;
+			}
+
+			var bytes = Encoding.UTF8.GetBytes (@string);
+			WriteCompressedUInt32 ((uint) bytes.Length);
+			WriteBytes (bytes);
+		}
+
+		public void WriteMethodSignature (IMethodSignature method)
+		{
+			byte calling_convention = (byte) method.CallingConvention;
+			if (method.HasThis)
+				calling_convention |= 0x20;
+			if (method.ExplicitThis)
+				calling_convention |= 0x40;
+
+			var generic_provider = method as IGenericParameterProvider;
+			var generic_arity = generic_provider != null && generic_provider.HasGenericParameters
+				? generic_provider.GenericParameters.Count
+				: 0;
+
+			if (generic_arity > 0)
+				calling_convention |= 0x10;
+
+			var param_count = method.HasParameters ? method.Parameters.Count : 0;
+
+			WriteByte (calling_convention);
+
+			if (generic_arity > 0)
+				WriteCompressedUInt32 ((uint) generic_arity);
+
+			WriteCompressedUInt32 ((uint) param_count);
+			WriteTypeSignature (method.ReturnType);
+
+			if (param_count == 0)
+				return;
+
+			var parameters = method.Parameters;
+
+			for (int i = 0; i < param_count; i++)
+				WriteTypeSignature (parameters [i].ParameterType);
+		}
+
+		uint MakeTypeDefOrRefCodedRID (TypeReference type)
+		{
+			return CodedIndex.TypeDefOrRef.CompressMetadataToken (metadata.LookupToken (type));
+		}
+
+		public void WriteTypeToken (TypeReference type)
+		{
+			WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (type));
+		}
+
+		public void WriteTypeSignature (TypeReference type)
+		{
+			if (type == null)
+				throw new ArgumentNullException ();
+
+			var etype = type.etype;
+
+			switch (etype) {
+			case ElementType.MVar:
+			case ElementType.Var: {
+				var generic_parameter = (GenericParameter) type;
+
+				WriteElementType (etype);
+				var position = generic_parameter.Position;
+				if (position == -1)
+					throw new NotSupportedException ();
+
+				WriteCompressedUInt32 ((uint) position);
+				break;
+			}
+
+			case ElementType.GenericInst: {
+				var generic_instance = (GenericInstanceType) type;
+				WriteElementType (ElementType.GenericInst);
+				WriteElementType (generic_instance.IsValueType ? ElementType.ValueType : ElementType.Class);
+				WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (generic_instance.ElementType));
+
+				WriteGenericInstanceSignature (generic_instance);
+				break;
+			}
+
+			case ElementType.Ptr:
+			case ElementType.ByRef:
+			case ElementType.Pinned:
+			case ElementType.Sentinel: {
+				var type_spec = (TypeSpecification) type;
+				WriteElementType (etype);
+				WriteTypeSignature (type_spec.ElementType);
+				break;
+			}
+
+			case ElementType.FnPtr: {
+				var fptr = (FunctionPointerType) type;
+				WriteElementType (ElementType.FnPtr);
+				WriteMethodSignature (fptr);
+				break;
+			}
+
+			case ElementType.CModOpt:
+			case ElementType.CModReqD: {
+				var modifier = (IModifierType) type;
+				WriteModifierSignature (etype, modifier);
+				break;
+			}
+
+			case ElementType.Array: {
+				var array = (ArrayType) type;
+				if (!array.IsVector) {
+					WriteArrayTypeSignature (array);
+					break;
+				}
+
+				WriteElementType (ElementType.SzArray);
+				WriteTypeSignature (array.ElementType);
+				break;
+			}
+
+			case ElementType.None: {
+				WriteElementType (type.IsValueType ? ElementType.ValueType : ElementType.Class);
+				WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (type));
+				break;
+			}
+
+			default:
+				if (!TryWriteElementType (type))
+					throw new NotSupportedException ();
+
+				break;
+
+			}
+		}
+
+		void WriteArrayTypeSignature (ArrayType array)
+		{
+			WriteElementType (ElementType.Array);
+			WriteTypeSignature (array.ElementType);
+
+			var dimensions = array.Dimensions;
+			var rank = dimensions.Count;
+
+			WriteCompressedUInt32 ((uint) rank);
+
+			var sized = 0;
+			var lbounds = 0;
+
+			for (int i = 0; i < rank; i++) {
+				var dimension = dimensions [i];
+
+				if (dimension.UpperBound.HasValue) {
+					sized++;
+					lbounds++;
+				} else if (dimension.LowerBound.HasValue)
+					lbounds++;
+			}
+
+			var sizes = new int [sized];
+			var low_bounds = new int [lbounds];
+
+			for (int i = 0; i < lbounds; i++) {
+				var dimension = dimensions [i];
+				low_bounds [i] = dimension.LowerBound.GetValueOrDefault ();
+				if (dimension.UpperBound.HasValue)
+					sizes [i] = dimension.UpperBound.Value - low_bounds [i] + 1;
+			}
+
+			WriteCompressedUInt32 ((uint) sized);
+			for (int i = 0; i < sized; i++)
+				WriteCompressedUInt32 ((uint) sizes [i]);
+
+			WriteCompressedUInt32 ((uint) lbounds);
+			for (int i = 0; i < lbounds; i++)
+				WriteCompressedInt32 (low_bounds [i]);
+		}
+
+		public void WriteGenericInstanceSignature (IGenericInstance instance)
+		{
+			var generic_arguments = instance.GenericArguments;
+			var arity = generic_arguments.Count;
+
+			WriteCompressedUInt32 ((uint) arity);
+			for (int i = 0; i < arity; i++)
+				WriteTypeSignature (generic_arguments [i]);
+		}
+
+		void WriteModifierSignature (ElementType element_type, IModifierType type)
+		{
+			WriteElementType (element_type);
+			WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (type.ModifierType));
+			WriteTypeSignature (type.ElementType);
+		}
+
+		bool TryWriteElementType (TypeReference type)
+		{
+			var element = type.etype;
+
+			if (element == ElementType.None)
+				return false;
+
+			WriteElementType (element);
+			return true;
+		}
+
+		public void WriteConstantString (string value)
+		{
+			if (value != null)
+				WriteBytes (Encoding.Unicode.GetBytes (value));
+			else
+				WriteByte (0xff);
+		}
+
+		public void WriteConstantPrimitive (object value)
+		{
+			WritePrimitiveValue (value);
+		}
+
+		public void WriteCustomAttributeConstructorArguments (CustomAttribute attribute)
+		{
+			if (!attribute.HasConstructorArguments)
+				return;
+
+			var arguments = attribute.ConstructorArguments;
+			var parameters = attribute.Constructor.Parameters;
+
+			if (parameters.Count != arguments.Count)
+				throw new InvalidOperationException ();
+
+			for (int i = 0; i < arguments.Count; i++)
+				WriteCustomAttributeFixedArgument (parameters [i].ParameterType, arguments [i]);
+		}
+
+		void WriteCustomAttributeFixedArgument (TypeReference type, CustomAttributeArgument argument)
+		{
+			if (type.IsArray) {
+				WriteCustomAttributeFixedArrayArgument ((ArrayType) type, argument);
+				return;
+			}
+
+			WriteCustomAttributeElement (type, argument);
+		}
+
+		void WriteCustomAttributeFixedArrayArgument (ArrayType type, CustomAttributeArgument argument)
+		{
+			var values = argument.Value as CustomAttributeArgument [];
+
+			if (values == null) {
+				WriteUInt32 (0xffffffff);
+				return;
+			}
+
+			WriteInt32 (values.Length);
+
+			if (values.Length == 0)
+				return;
+
+			var element_type = type.ElementType;
+
+			for (int i = 0; i < values.Length; i++)
+				WriteCustomAttributeElement (element_type, values [i]);
+		}
+
+		void WriteCustomAttributeElement (TypeReference type, CustomAttributeArgument argument)
+		{
+			if (type.IsArray) {
+				WriteCustomAttributeFixedArrayArgument ((ArrayType) type, argument);
+				return;
+			}
+
+			if (type.etype == ElementType.Object) {
+				argument = (CustomAttributeArgument) argument.Value;
+				type = argument.Type;
+
+				WriteCustomAttributeFieldOrPropType (type);
+				WriteCustomAttributeElement (type, argument);
+				return;
+			}
+
+			WriteCustomAttributeValue (type, argument.Value);
+		}
+
+		void WriteCustomAttributeValue (TypeReference type, object value)
+		{
+			var etype = type.etype;
+
+			switch (etype) {
+			case ElementType.String:
+				var @string = (string) value;
+				if (@string == null)
+					WriteByte (0xff);
+				else
+					WriteUTF8String (@string);
+				break;
+			case ElementType.None:
+				if (type.IsTypeOf ("System", "Type"))
+					WriteTypeReference ((TypeReference) value);
+				else
+					WriteCustomAttributeEnumValue (type, value);
+				break;
+			default:
+				WritePrimitiveValue (value);
+				break;
+			}
+		}
+
+		void WritePrimitiveValue (object value)
+		{
+			if (value == null)
+				throw new ArgumentNullException ();
+
+			switch (value.GetType ().GetTypeCode ()) {
+			case TypeCode.Boolean:
+				WriteByte ((byte) (((bool) value) ? 1 : 0));
+				break;
+			case TypeCode.Byte:
+				WriteByte ((byte) value);
+				break;
+			case TypeCode.SByte:
+				WriteSByte ((sbyte) value);
+				break;
+			case TypeCode.Int16:
+				WriteInt16 ((short) value);
+				break;
+			case TypeCode.UInt16:
+				WriteUInt16 ((ushort) value);
+				break;
+			case TypeCode.Char:
+				WriteInt16 ((short) (char) value);
+				break;
+			case TypeCode.Int32:
+				WriteInt32 ((int) value);
+				break;
+			case TypeCode.UInt32:
+				WriteUInt32 ((uint) value);
+				break;
+			case TypeCode.Single:
+				WriteSingle ((float) value);
+				break;
+			case TypeCode.Int64:
+				WriteInt64 ((long) value);
+				break;
+			case TypeCode.UInt64:
+				WriteUInt64 ((ulong) value);
+				break;
+			case TypeCode.Double:
+				WriteDouble ((double) value);
+				break;
+			default:
+				throw new NotSupportedException (value.GetType ().FullName);
+			}
+		}
+
+		void WriteCustomAttributeEnumValue (TypeReference enum_type, object value)
+		{
+			var type = enum_type.CheckedResolve ();
+			if (!type.IsEnum)
+				throw new ArgumentException ();
+
+			WriteCustomAttributeValue (type.GetEnumUnderlyingType (), value);
+		}
+
+		void WriteCustomAttributeFieldOrPropType (TypeReference type)
+		{
+			if (type.IsArray) {
+				var array = (ArrayType) type;
+				WriteElementType (ElementType.SzArray);
+				WriteCustomAttributeFieldOrPropType (array.ElementType);
+				return;
+			}
+
+			var etype = type.etype;
+
+			switch (etype) {
+			case ElementType.Object:
+				WriteElementType (ElementType.Boxed);
+				return;
+			case ElementType.None:
+				if (type.IsTypeOf ("System", "Type"))
+					WriteElementType (ElementType.Type);
+				else {
+					WriteElementType (ElementType.Enum);
+					WriteTypeReference (type);
+				}
+				return;
+			default:
+				WriteElementType (etype);
+				return;
+			}
+		}
+
+		public void WriteCustomAttributeNamedArguments (CustomAttribute attribute)
+		{
+			var count = GetNamedArgumentCount (attribute);
+
+			WriteUInt16 ((ushort) count);
+
+			if (count == 0)
+				return;
+
+			WriteICustomAttributeNamedArguments (attribute);
+		}
+
+		static int GetNamedArgumentCount (ICustomAttribute attribute)
+		{
+			int count = 0;
+
+			if (attribute.HasFields)
+				count += attribute.Fields.Count;
+
+			if (attribute.HasProperties)
+				count += attribute.Properties.Count;
+
+			return count;
+		}
+
+		void WriteICustomAttributeNamedArguments (ICustomAttribute attribute)
+		{
+			if (attribute.HasFields)
+				WriteCustomAttributeNamedArguments (0x53, attribute.Fields);
+
+			if (attribute.HasProperties)
+				WriteCustomAttributeNamedArguments (0x54, attribute.Properties);
+		}
+
+		void WriteCustomAttributeNamedArguments (byte kind, Collection<CustomAttributeNamedArgument> named_arguments)
+		{
+			for (int i = 0; i < named_arguments.Count; i++)
+				WriteCustomAttributeNamedArgument (kind, named_arguments [i]);
+		}
+
+		void WriteCustomAttributeNamedArgument (byte kind, CustomAttributeNamedArgument named_argument)
+		{
+			var argument = named_argument.Argument;
+
+			WriteByte (kind);
+			WriteCustomAttributeFieldOrPropType (argument.Type);
+			WriteUTF8String (named_argument.Name);
+			WriteCustomAttributeFixedArgument (argument.Type, argument);
+		}
+
+		void WriteSecurityAttribute (SecurityAttribute attribute)
+		{
+			WriteTypeReference (attribute.AttributeType);
+
+			var count = GetNamedArgumentCount (attribute);
+
+			if (count == 0) {
+				WriteCompressedUInt32 (1); // length
+				WriteCompressedUInt32 (0); // count
+				return;
+			}
+
+			var buffer = new SignatureWriter (metadata);
+			buffer.WriteCompressedUInt32 ((uint) count);
+			buffer.WriteICustomAttributeNamedArguments (attribute);
+
+			WriteCompressedUInt32 ((uint) buffer.length);
+			WriteBytes (buffer);
+		}
+
+		public void WriteSecurityDeclaration (SecurityDeclaration declaration)
+		{
+			WriteByte ((byte) '.');
+
+			var attributes = declaration.security_attributes;
+			if (attributes == null)
+				throw new NotSupportedException ();
+
+			WriteCompressedUInt32 ((uint) attributes.Count);
+
+			for (int i = 0; i < attributes.Count; i++)
+				WriteSecurityAttribute (attributes [i]);
+		}
+
+		public void WriteXmlSecurityDeclaration (SecurityDeclaration declaration)
+		{
+			var xml = GetXmlSecurityDeclaration (declaration);
+			if (xml == null)
+				throw new NotSupportedException ();
+
+			WriteBytes (Encoding.Unicode.GetBytes (xml));
+		}
+
+		static string GetXmlSecurityDeclaration (SecurityDeclaration declaration)
+		{
+			if (declaration.security_attributes == null || declaration.security_attributes.Count != 1)
+				return null;
+
+			var attribute = declaration.security_attributes [0];
+
+			if (!attribute.AttributeType.IsTypeOf ("System.Security.Permissions", "PermissionSetAttribute"))
+				return null;
+
+			if (attribute.properties == null || attribute.properties.Count != 1)
+				return null;
+
+			var property = attribute.properties [0];
+			if (property.Name != "XML")
+				return null;
+
+			return (string) property.Argument.Value;
+		}
+
+		void WriteTypeReference (TypeReference type)
+		{
+			WriteUTF8String (TypeParser.ToParseable (type, top_level: false));
+		}
+
+		public void WriteMarshalInfo (MarshalInfo marshal_info)
+		{
+			WriteNativeType (marshal_info.native);
+
+			switch (marshal_info.native) {
+			case NativeType.Array: {
+				var array = (ArrayMarshalInfo) marshal_info;
+				if (array.element_type != NativeType.None)
+					WriteNativeType (array.element_type);
+				if (array.size_parameter_index > -1)
+					WriteCompressedUInt32 ((uint) array.size_parameter_index);
+				if (array.size > -1)
+					WriteCompressedUInt32 ((uint) array.size);
+				if (array.size_parameter_multiplier > -1)
+					WriteCompressedUInt32 ((uint) array.size_parameter_multiplier);
+				return;
+			}
+			case NativeType.SafeArray: {
+				var array = (SafeArrayMarshalInfo) marshal_info;
+				if (array.element_type != VariantType.None)
+					WriteVariantType (array.element_type);
+				return;
+			}
+			case NativeType.FixedArray: {
+				var array = (FixedArrayMarshalInfo) marshal_info;
+				if (array.size > -1)
+					WriteCompressedUInt32 ((uint) array.size);
+				if (array.element_type != NativeType.None)
+					WriteNativeType (array.element_type);
+				return;
+			}
+			case NativeType.FixedSysString:
+				var sys_string = (FixedSysStringMarshalInfo) marshal_info;
+				if (sys_string.size > -1)
+					WriteCompressedUInt32 ((uint) sys_string.size);
+				return;
+			case NativeType.CustomMarshaler:
+				var marshaler = (CustomMarshalInfo) marshal_info;
+				WriteUTF8String (marshaler.guid != Guid.Empty ? marshaler.guid.ToString () : string.Empty);
+				WriteUTF8String (marshaler.unmanaged_type);
+				WriteTypeReference (marshaler.managed_type);
+				WriteUTF8String (marshaler.cookie);
+				return;
+			}
+		}
+
+		void WriteNativeType (NativeType native)
+		{
+			WriteByte ((byte) native);
+		}
+
+		void WriteVariantType (VariantType variant)
+		{
+			WriteByte ((byte) variant);
+		}
+
+		public void WriteSequencePoints (MethodDebugInformation info)
+		{
+			var start_line = -1;
+			var start_column = -1;
+
+			WriteCompressedUInt32 (info.local_var_token.RID);
+
+			Document previous_document;
+			if (!info.TryGetUniqueDocument (out previous_document))
+				previous_document = null;
+
+			for (int i = 0; i < info.SequencePoints.Count; i++) {
+				var sequence_point = info.SequencePoints [i];
+
+				var document = sequence_point.Document;
+				if (previous_document != document) {
+					var document_token = metadata.GetDocumentToken (document);
+
+					if (previous_document != null)
+						WriteCompressedUInt32 (0);
+
+					WriteCompressedUInt32 (document_token.RID);
+					previous_document = document;
+				}
+
+				if (i > 0)
+					WriteCompressedUInt32 ((uint) (sequence_point.Offset - info.SequencePoints [i - 1].Offset));
+				else
+					WriteCompressedUInt32 ((uint) sequence_point.Offset);
+
+				if (sequence_point.IsHidden) {
+					WriteInt16 (0);
+					continue;
+				}
+
+				var delta_lines = sequence_point.EndLine - sequence_point.StartLine;
+				var delta_columns = sequence_point.EndColumn - sequence_point.StartColumn;
+
+				WriteCompressedUInt32 ((uint) delta_lines);
+
+				if (delta_lines == 0)
+					WriteCompressedUInt32((uint) delta_columns);
+				else
+					WriteCompressedInt32 (delta_columns);
+
+				if (start_line < 0) {
+					WriteCompressedUInt32 ((uint) sequence_point.StartLine);
+					WriteCompressedUInt32 ((uint) sequence_point.StartColumn);
+				} else {
+					WriteCompressedInt32 (sequence_point.StartLine - start_line);
+					WriteCompressedInt32 (sequence_point.StartColumn - start_column);
+				}
+
+				start_line = sequence_point.StartLine;
+				start_column = sequence_point.StartColumn;
+			}
+		}
+	}
+
+#endif
+
+	static partial class Mixin {
+
+		public static bool TryGetUniqueDocument (this MethodDebugInformation info, out Document document)
+		{
+			document = info.SequencePoints [0].Document;
+
+			for (int i = 1; i < info.SequencePoints.Count; i++) {
+				var sequence_point = info.SequencePoints [i];
+				if (sequence_point.Document != document)
+					return false;
+			}
+
+			return true;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/BaseAssemblyResolver.cs b/src/Mono/Cecil/BaseAssemblyResolver.cs
new file mode 100644
index 00000000..c10a826d
--- /dev/null
+++ b/src/Mono/Cecil/BaseAssemblyResolver.cs
@@ -0,0 +1,410 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Text;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public delegate AssemblyDefinition AssemblyResolveEventHandler (object sender, AssemblyNameReference reference);
+
+	public sealed class AssemblyResolveEventArgs : EventArgs {
+
+		readonly AssemblyNameReference reference;
+
+		public AssemblyNameReference AssemblyReference {
+			get { return reference; }
+		}
+
+		public AssemblyResolveEventArgs (AssemblyNameReference reference)
+		{
+			this.reference = reference;
+		}
+	}
+
+#if !NET_CORE
+	[Serializable]
+#endif
+	public sealed class AssemblyResolutionException : FileNotFoundException {
+
+		readonly AssemblyNameReference reference;
+
+		public AssemblyNameReference AssemblyReference {
+			get { return reference; }
+		}
+
+		public AssemblyResolutionException (AssemblyNameReference reference)
+			: this (reference, null)
+		{
+		}
+
+		public AssemblyResolutionException (AssemblyNameReference reference, Exception innerException)
+			: base (string.Format ("Failed to resolve assembly: '{0}'", reference), innerException)
+		{
+			this.reference = reference;
+		}
+
+#if !NET_CORE
+		AssemblyResolutionException (
+			System.Runtime.Serialization.SerializationInfo info,
+			System.Runtime.Serialization.StreamingContext context)
+			: base (info, context)
+		{
+		}
+#endif
+	}
+
+	public abstract class BaseAssemblyResolver : IAssemblyResolver {
+
+		static readonly bool on_mono = Type.GetType ("Mono.Runtime") != null;
+
+		readonly Collection<string> directories;
+
+#if NET_CORE
+		// Maps file names of available trusted platform assemblies to their full paths.
+		// Internal for testing.
+		internal static readonly Lazy<Dictionary<string, string>> TrustedPlatformAssemblies = new Lazy<Dictionary<string, string>> (CreateTrustedPlatformAssemblyMap);
+#else
+		Collection<string> gac_paths;
+#endif
+
+		public void AddSearchDirectory (string directory)
+		{
+			directories.Add (directory);
+		}
+
+		public void RemoveSearchDirectory (string directory)
+		{
+			directories.Remove (directory);
+		}
+
+		public string [] GetSearchDirectories ()
+		{
+			var directories = new string [this.directories.size];
+			Array.Copy (this.directories.items, directories, directories.Length);
+			return directories;
+		}
+
+		public event AssemblyResolveEventHandler ResolveFailure;
+
+		protected BaseAssemblyResolver ()
+		{
+			directories = new Collection<string> (2) { ".", "bin" };
+		}
+
+		AssemblyDefinition GetAssembly (string file, ReaderParameters parameters)
+		{
+			if (parameters.AssemblyResolver == null)
+				parameters.AssemblyResolver = this;
+
+			return ModuleDefinition.ReadModule (file, parameters).Assembly;
+		}
+
+		public virtual AssemblyDefinition Resolve (AssemblyNameReference name)
+		{
+			return Resolve (name, new ReaderParameters ());
+		}
+
+		public virtual AssemblyDefinition Resolve (AssemblyNameReference name, ReaderParameters parameters)
+		{
+			Mixin.CheckName (name);
+			Mixin.CheckParameters (parameters);
+
+			var assembly = SearchDirectory (name, directories, parameters);
+			if (assembly != null)
+				return assembly;
+
+			if (name.IsRetargetable) {
+				// if the reference is retargetable, zero it
+				name = new AssemblyNameReference (name.Name, Mixin.ZeroVersion) {
+					PublicKeyToken = Empty<byte>.Array,
+				};
+			}
+
+#if NET_CORE
+			assembly = SearchTrustedPlatformAssemblies (name, parameters);
+			if (assembly != null)
+				return assembly;
+#else
+			var framework_dir = Path.GetDirectoryName (typeof (object).Module.FullyQualifiedName);
+			var framework_dirs = on_mono
+				? new [] { framework_dir, Path.Combine (framework_dir, "Facades") }
+				: new [] { framework_dir };
+
+			if (IsZero (name.Version)) {
+				assembly = SearchDirectory (name, framework_dirs, parameters);
+				if (assembly != null)
+					return assembly;
+			}
+
+			if (name.Name == "mscorlib") {
+				assembly = GetCorlib (name, parameters);
+				if (assembly != null)
+					return assembly;
+			}
+
+			assembly = GetAssemblyInGac (name, parameters);
+			if (assembly != null)
+				return assembly;
+
+			assembly = SearchDirectory (name, framework_dirs, parameters);
+			if (assembly != null)
+				return assembly;
+#endif
+			if (ResolveFailure != null) {
+				assembly = ResolveFailure (this, name);
+				if (assembly != null)
+					return assembly;
+			}
+
+			throw new AssemblyResolutionException (name);
+		}
+
+#if NET_CORE
+		AssemblyDefinition SearchTrustedPlatformAssemblies (AssemblyNameReference name, ReaderParameters parameters)
+		{
+			if (name.IsWindowsRuntime)
+				return null;
+
+			if (TrustedPlatformAssemblies.Value.TryGetValue (name.Name, out string path))
+				return GetAssembly (path, parameters);
+
+			return null;
+		}
+
+		static Dictionary<string, string> CreateTrustedPlatformAssemblyMap ()
+		{
+			var result = new Dictionary<string, string> (StringComparer.OrdinalIgnoreCase);
+
+			string paths;
+
+			try {
+				// AppContext is only available on platforms that implement .NET Standard 1.6
+				var appContextType = Type.GetType ("System.AppContext, System.AppContext, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", throwOnError: false);
+				var getData = appContextType?.GetTypeInfo ().GetDeclaredMethod ("GetData");
+				paths = (string) getData?.Invoke (null, new [] { "TRUSTED_PLATFORM_ASSEMBLIES" });
+			} catch {
+				paths = null;
+			}
+
+			if (paths == null)
+				return result;
+
+			foreach (var path in paths.Split (Path.PathSeparator))
+				if (string.Equals (Path.GetExtension (path), ".dll", StringComparison.OrdinalIgnoreCase))
+					result [Path.GetFileNameWithoutExtension (path)] = path;
+
+			return result;
+		}
+#endif
+
+		protected virtual AssemblyDefinition SearchDirectory (AssemblyNameReference name, IEnumerable<string> directories, ReaderParameters parameters)
+		{
+			var extensions = name.IsWindowsRuntime ? new [] { ".winmd", ".dll" } : new [] { ".exe", ".dll" };
+			foreach (var directory in directories) {
+				foreach (var extension in extensions) {
+					string file = Path.Combine (directory, name.Name + extension);
+					if (!File.Exists (file))
+						continue;
+					try {
+						return GetAssembly (file, parameters);
+					} catch (System.BadImageFormatException) {
+						continue;
+					}
+				}
+			}
+
+			return null;
+		}
+
+		static bool IsZero (Version version)
+		{
+			return version.Major == 0 && version.Minor == 0 && version.Build == 0 && version.Revision == 0;
+		}
+
+#if !NET_CORE
+		AssemblyDefinition GetCorlib (AssemblyNameReference reference, ReaderParameters parameters)
+		{
+			var version = reference.Version;
+			var corlib = typeof (object).Assembly.GetName ();
+			if (corlib.Version == version || IsZero (version))
+				return GetAssembly (typeof (object).Module.FullyQualifiedName, parameters);
+
+			var path = Directory.GetParent (
+				Directory.GetParent (
+					typeof (object).Module.FullyQualifiedName).FullName
+				).FullName;
+
+			if (on_mono) {
+				if (version.Major == 1)
+					path = Path.Combine (path, "1.0");
+				else if (version.Major == 2) {
+					if (version.MajorRevision == 5)
+						path = Path.Combine (path, "2.1");
+					else
+						path = Path.Combine (path, "2.0");
+				} else if (version.Major == 4)
+					path = Path.Combine (path, "4.0");
+				else
+					throw new NotSupportedException ("Version not supported: " + version);
+			} else {
+				switch (version.Major) {
+				case 1:
+					if (version.MajorRevision == 3300)
+						path = Path.Combine (path, "v1.0.3705");
+					else
+						path = Path.Combine (path, "v1.1.4322");
+					break;
+				case 2:
+					path = Path.Combine (path, "v2.0.50727");
+					break;
+				case 4:
+					path = Path.Combine (path, "v4.0.30319");
+					break;
+				default:
+					throw new NotSupportedException ("Version not supported: " + version);
+				}
+			}
+
+			var file = Path.Combine (path, "mscorlib.dll");
+			if (File.Exists (file))
+				return GetAssembly (file, parameters);
+
+			if (on_mono && Directory.Exists (path + "-api")) {
+				file = Path.Combine (path + "-api", "mscorlib.dll");
+				if (File.Exists (file))
+					return GetAssembly (file, parameters);
+			}
+
+			return null;
+		}
+
+		static Collection<string> GetGacPaths ()
+		{
+			if (on_mono)
+				return GetDefaultMonoGacPaths ();
+
+			var paths = new Collection<string> (2);
+			var windir = Environment.GetEnvironmentVariable ("WINDIR");
+			if (windir == null)
+				return paths;
+
+			paths.Add (Path.Combine (windir, "assembly"));
+			paths.Add (Path.Combine (windir, Path.Combine ("Microsoft.NET", "assembly")));
+			return paths;
+		}
+
+		static Collection<string> GetDefaultMonoGacPaths ()
+		{
+			var paths = new Collection<string> (1);
+			var gac = GetCurrentMonoGac ();
+			if (gac != null)
+				paths.Add (gac);
+
+			var gac_paths_env = Environment.GetEnvironmentVariable ("MONO_GAC_PREFIX");
+			if (string.IsNullOrEmpty (gac_paths_env))
+				return paths;
+
+			var prefixes = gac_paths_env.Split (Path.PathSeparator);
+			foreach (var prefix in prefixes) {
+				if (string.IsNullOrEmpty (prefix))
+					continue;
+
+				var gac_path = Path.Combine (Path.Combine (Path.Combine (prefix, "lib"), "mono"), "gac");
+				if (Directory.Exists (gac_path) && !paths.Contains (gac))
+					paths.Add (gac_path);
+			}
+
+			return paths;
+		}
+
+		static string GetCurrentMonoGac ()
+		{
+			return Path.Combine (
+				Directory.GetParent (
+					Path.GetDirectoryName (typeof (object).Module.FullyQualifiedName)).FullName,
+				"gac");
+		}
+
+		AssemblyDefinition GetAssemblyInGac (AssemblyNameReference reference, ReaderParameters parameters)
+		{
+			if (reference.PublicKeyToken == null || reference.PublicKeyToken.Length == 0)
+				return null;
+
+			if (gac_paths == null)
+				gac_paths = GetGacPaths ();
+
+			if (on_mono)
+				return GetAssemblyInMonoGac (reference, parameters);
+
+			return GetAssemblyInNetGac (reference, parameters);
+		}
+
+		AssemblyDefinition GetAssemblyInMonoGac (AssemblyNameReference reference, ReaderParameters parameters)
+		{
+			for (int i = 0; i < gac_paths.Count; i++) {
+				var gac_path = gac_paths [i];
+				var file = GetAssemblyFile (reference, string.Empty, gac_path);
+				if (File.Exists (file))
+					return GetAssembly (file, parameters);
+			}
+
+			return null;
+		}
+
+		AssemblyDefinition GetAssemblyInNetGac (AssemblyNameReference reference, ReaderParameters parameters)
+		{
+			var gacs = new [] { "GAC_MSIL", "GAC_32", "GAC_64", "GAC" };
+			var prefixes = new [] { string.Empty, "v4.0_" };
+
+			for (int i = 0; i < 2; i++) {
+				for (int j = 0; j < gacs.Length; j++) {
+					var gac = Path.Combine (gac_paths [i], gacs [j]);
+					var file = GetAssemblyFile (reference, prefixes [i], gac);
+					if (Directory.Exists (gac) && File.Exists (file))
+						return GetAssembly (file, parameters);
+				}
+			}
+
+			return null;
+		}
+#endif
+		static string GetAssemblyFile (AssemblyNameReference reference, string prefix, string gac)
+		{
+			var gac_folder = new StringBuilder ()
+				.Append (prefix)
+				.Append (reference.Version)
+				.Append ("__");
+
+			for (int i = 0; i < reference.PublicKeyToken.Length; i++)
+				gac_folder.Append (reference.PublicKeyToken [i].ToString ("x2"));
+
+			return Path.Combine (
+				Path.Combine (
+					Path.Combine (gac, reference.Name), gac_folder.ToString ()),
+				reference.Name + ".dll");
+		}
+
+		public void Dispose ()
+		{
+			Dispose (true);
+			GC.SuppressFinalize (this);
+		}
+
+		protected virtual void Dispose (bool disposing)
+		{
+		}
+	}
+}
diff --git a/src/Mono/Cecil/CallSite.cs b/src/Mono/Cecil/CallSite.cs
new file mode 100644
index 00000000..ebb108f2
--- /dev/null
+++ b/src/Mono/Cecil/CallSite.cs
@@ -0,0 +1,106 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class CallSite : IMethodSignature {
+
+		readonly MethodReference signature;
+
+		public bool HasThis {
+			get { return signature.HasThis; }
+			set { signature.HasThis = value; }
+		}
+
+		public bool ExplicitThis {
+			get { return signature.ExplicitThis; }
+			set { signature.ExplicitThis = value; }
+		}
+
+		public MethodCallingConvention CallingConvention {
+			get { return signature.CallingConvention; }
+			set { signature.CallingConvention = value; }
+		}
+
+		public bool HasParameters {
+			get { return signature.HasParameters; }
+		}
+
+		public Collection<ParameterDefinition> Parameters {
+			get { return signature.Parameters; }
+		}
+
+		public TypeReference ReturnType {
+			get { return signature.MethodReturnType.ReturnType; }
+			set { signature.MethodReturnType.ReturnType = value; }
+		}
+
+		public MethodReturnType MethodReturnType {
+			get { return signature.MethodReturnType; }
+		}
+
+		public string Name {
+			get { return string.Empty; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public string Namespace {
+			get { return string.Empty; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public ModuleDefinition Module {
+			get { return ReturnType.Module; }
+		}
+
+		public IMetadataScope Scope {
+			get { return signature.ReturnType.Scope; }
+		}
+
+		public MetadataToken MetadataToken {
+			get { return signature.token; }
+			set { signature.token = value; }
+		}
+
+		public string FullName {
+			get {
+				var signature = new StringBuilder ();
+				signature.Append (ReturnType.FullName);
+				this.MethodSignatureFullName (signature);
+				return signature.ToString ();
+			}
+		}
+
+		internal CallSite ()
+		{
+			this.signature = new MethodReference ();
+			this.signature.token = new MetadataToken (TokenType.Signature, 0);
+		}
+
+		public CallSite (TypeReference returnType)
+			: this ()
+		{
+			if (returnType == null)
+				throw new ArgumentNullException ("returnType");
+
+			this.signature.ReturnType = returnType;
+		}
+
+		public override string ToString ()
+		{
+			return FullName;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/Code.cs b/src/Mono/Cecil/Cil/Code.cs
new file mode 100644
index 00000000..cd929fcc
--- /dev/null
+++ b/src/Mono/Cecil/Cil/Code.cs
@@ -0,0 +1,234 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Cil {
+
+	public enum Code {
+		Nop,
+		Break,
+		Ldarg_0,
+		Ldarg_1,
+		Ldarg_2,
+		Ldarg_3,
+		Ldloc_0,
+		Ldloc_1,
+		Ldloc_2,
+		Ldloc_3,
+		Stloc_0,
+		Stloc_1,
+		Stloc_2,
+		Stloc_3,
+		Ldarg_S,
+		Ldarga_S,
+		Starg_S,
+		Ldloc_S,
+		Ldloca_S,
+		Stloc_S,
+		Ldnull,
+		Ldc_I4_M1,
+		Ldc_I4_0,
+		Ldc_I4_1,
+		Ldc_I4_2,
+		Ldc_I4_3,
+		Ldc_I4_4,
+		Ldc_I4_5,
+		Ldc_I4_6,
+		Ldc_I4_7,
+		Ldc_I4_8,
+		Ldc_I4_S,
+		Ldc_I4,
+		Ldc_I8,
+		Ldc_R4,
+		Ldc_R8,
+		Dup,
+		Pop,
+		Jmp,
+		Call,
+		Calli,
+		Ret,
+		Br_S,
+		Brfalse_S,
+		Brtrue_S,
+		Beq_S,
+		Bge_S,
+		Bgt_S,
+		Ble_S,
+		Blt_S,
+		Bne_Un_S,
+		Bge_Un_S,
+		Bgt_Un_S,
+		Ble_Un_S,
+		Blt_Un_S,
+		Br,
+		Brfalse,
+		Brtrue,
+		Beq,
+		Bge,
+		Bgt,
+		Ble,
+		Blt,
+		Bne_Un,
+		Bge_Un,
+		Bgt_Un,
+		Ble_Un,
+		Blt_Un,
+		Switch,
+		Ldind_I1,
+		Ldind_U1,
+		Ldind_I2,
+		Ldind_U2,
+		Ldind_I4,
+		Ldind_U4,
+		Ldind_I8,
+		Ldind_I,
+		Ldind_R4,
+		Ldind_R8,
+		Ldind_Ref,
+		Stind_Ref,
+		Stind_I1,
+		Stind_I2,
+		Stind_I4,
+		Stind_I8,
+		Stind_R4,
+		Stind_R8,
+		Add,
+		Sub,
+		Mul,
+		Div,
+		Div_Un,
+		Rem,
+		Rem_Un,
+		And,
+		Or,
+		Xor,
+		Shl,
+		Shr,
+		Shr_Un,
+		Neg,
+		Not,
+		Conv_I1,
+		Conv_I2,
+		Conv_I4,
+		Conv_I8,
+		Conv_R4,
+		Conv_R8,
+		Conv_U4,
+		Conv_U8,
+		Callvirt,
+		Cpobj,
+		Ldobj,
+		Ldstr,
+		Newobj,
+		Castclass,
+		Isinst,
+		Conv_R_Un,
+		Unbox,
+		Throw,
+		Ldfld,
+		Ldflda,
+		Stfld,
+		Ldsfld,
+		Ldsflda,
+		Stsfld,
+		Stobj,
+		Conv_Ovf_I1_Un,
+		Conv_Ovf_I2_Un,
+		Conv_Ovf_I4_Un,
+		Conv_Ovf_I8_Un,
+		Conv_Ovf_U1_Un,
+		Conv_Ovf_U2_Un,
+		Conv_Ovf_U4_Un,
+		Conv_Ovf_U8_Un,
+		Conv_Ovf_I_Un,
+		Conv_Ovf_U_Un,
+		Box,
+		Newarr,
+		Ldlen,
+		Ldelema,
+		Ldelem_I1,
+		Ldelem_U1,
+		Ldelem_I2,
+		Ldelem_U2,
+		Ldelem_I4,
+		Ldelem_U4,
+		Ldelem_I8,
+		Ldelem_I,
+		Ldelem_R4,
+		Ldelem_R8,
+		Ldelem_Ref,
+		Stelem_I,
+		Stelem_I1,
+		Stelem_I2,
+		Stelem_I4,
+		Stelem_I8,
+		Stelem_R4,
+		Stelem_R8,
+		Stelem_Ref,
+		Ldelem_Any,
+		Stelem_Any,
+		Unbox_Any,
+		Conv_Ovf_I1,
+		Conv_Ovf_U1,
+		Conv_Ovf_I2,
+		Conv_Ovf_U2,
+		Conv_Ovf_I4,
+		Conv_Ovf_U4,
+		Conv_Ovf_I8,
+		Conv_Ovf_U8,
+		Refanyval,
+		Ckfinite,
+		Mkrefany,
+		Ldtoken,
+		Conv_U2,
+		Conv_U1,
+		Conv_I,
+		Conv_Ovf_I,
+		Conv_Ovf_U,
+		Add_Ovf,
+		Add_Ovf_Un,
+		Mul_Ovf,
+		Mul_Ovf_Un,
+		Sub_Ovf,
+		Sub_Ovf_Un,
+		Endfinally,
+		Leave,
+		Leave_S,
+		Stind_I,
+		Conv_U,
+		Arglist,
+		Ceq,
+		Cgt,
+		Cgt_Un,
+		Clt,
+		Clt_Un,
+		Ldftn,
+		Ldvirtftn,
+		Ldarg,
+		Ldarga,
+		Starg,
+		Ldloc,
+		Ldloca,
+		Stloc,
+		Localloc,
+		Endfilter,
+		Unaligned,
+		Volatile,
+		Tail,
+		Initobj,
+		Constrained,
+		Cpblk,
+		Initblk,
+		No,
+		Rethrow,
+		Sizeof,
+		Refanytype,
+		Readonly,
+	}
+}
diff --git a/src/Mono/Cecil/Cil/CodeReader.cs b/src/Mono/Cecil/Cil/CodeReader.cs
new file mode 100644
index 00000000..f7f11d5d
--- /dev/null
+++ b/src/Mono/Cecil/Cil/CodeReader.cs
@@ -0,0 +1,671 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Cecil.PE;
+using Mono.Collections.Generic;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil.Cil {
+
+	sealed class CodeReader : BinaryStreamReader {
+
+		readonly internal MetadataReader reader;
+
+		int start;
+
+		MethodDefinition method;
+		MethodBody body;
+
+		int Offset {
+			get { return Position - start; }
+		}
+
+		public CodeReader (MetadataReader reader)
+			: base (reader.image.Stream.value)
+		{
+			this.reader = reader;
+		}
+
+		public int MoveTo (MethodDefinition method)
+		{
+			this.method = method;
+			this.reader.context = method;
+			var position = this.Position;
+			this.Position = (int) reader.image.ResolveVirtualAddress ((uint) method.RVA);
+			return position;
+		}
+
+		public void MoveBackTo (int position)
+		{
+			this.reader.context = null;
+			this.Position = position;
+		}
+
+		public MethodBody ReadMethodBody (MethodDefinition method)
+		{
+			var position = MoveTo (method);
+			this.body = new MethodBody (method);
+
+			ReadMethodBody ();
+
+			MoveBackTo (position);
+			return this.body;
+		}
+
+		public int ReadCodeSize (MethodDefinition method)
+		{
+			var position = MoveTo (method);
+
+			var code_size = ReadCodeSize ();
+
+			MoveBackTo (position);
+			return code_size;
+		}
+
+		int ReadCodeSize ()
+		{
+			var flags = ReadByte ();
+			switch (flags & 0x3) {
+			case 0x2: // tiny
+				return flags >> 2;
+			case 0x3: // fat
+				Advance (-1 + 2 + 2); // go back, 2 bytes flags, 2 bytes stack size
+				return (int) ReadUInt32 ();
+			default:
+				throw new InvalidOperationException ();
+			}
+		}
+
+		void ReadMethodBody ()
+		{
+			var flags = ReadByte ();
+			switch (flags & 0x3) {
+			case 0x2: // tiny
+				body.code_size = flags >> 2;
+				body.MaxStackSize = 8;
+				ReadCode ();
+				break;
+			case 0x3: // fat
+				Advance (-1);
+				ReadFatMethod ();
+				break;
+			default:
+				throw new InvalidOperationException ();
+			}
+
+			var symbol_reader = reader.module.symbol_reader;
+
+			if (symbol_reader != null && method.debug_info == null)
+				method.debug_info = symbol_reader.Read (method);
+
+			if (method.debug_info != null)
+				ReadDebugInfo ();
+		}
+
+		void ReadFatMethod ()
+		{
+			var flags = ReadUInt16 ();
+			body.max_stack_size = ReadUInt16 ();
+			body.code_size = (int) ReadUInt32 ();
+			body.local_var_token = new MetadataToken (ReadUInt32 ());
+			body.init_locals = (flags & 0x10) != 0;
+
+			if (body.local_var_token.RID != 0)
+				body.variables = ReadVariables (body.local_var_token);
+
+			ReadCode ();
+
+			if ((flags & 0x8) != 0)
+				ReadSection ();
+		}
+
+		public VariableDefinitionCollection ReadVariables (MetadataToken local_var_token)
+		{
+			var position = reader.position;
+			var variables = reader.ReadVariables (local_var_token);
+			reader.position = position;
+
+			return variables;
+		}
+
+		void ReadCode ()
+		{
+			start = Position;
+			var code_size = body.code_size;
+
+			if (code_size < 0 || Length <= (uint) (code_size + Position))
+				code_size = 0;
+
+			var end = start + code_size;
+			var instructions = body.instructions = new InstructionCollection (method, (code_size + 1) / 2);
+
+			while (Position < end) {
+				var offset = Position - start;
+				var opcode = ReadOpCode ();
+				var current = new Instruction (offset, opcode);
+
+				if (opcode.OperandType != OperandType.InlineNone)
+					current.operand = ReadOperand (current);
+
+				instructions.Add (current);
+			}
+
+			ResolveBranches (instructions);
+		}
+
+		OpCode ReadOpCode ()
+		{
+			var il_opcode = ReadByte ();
+			return il_opcode != 0xfe
+				? OpCodes.OneByteOpCode [il_opcode]
+				: OpCodes.TwoBytesOpCode [ReadByte ()];
+		}
+
+		object ReadOperand (Instruction instruction)
+		{
+			switch (instruction.opcode.OperandType) {
+			case OperandType.InlineSwitch:
+				var length = ReadInt32 ();
+				var base_offset = Offset + (4 * length);
+				var branches = new int [length];
+				for (int i = 0; i < length; i++)
+					branches [i] = base_offset + ReadInt32 ();
+				return branches;
+			case OperandType.ShortInlineBrTarget:
+				return ReadSByte () + Offset;
+			case OperandType.InlineBrTarget:
+				return ReadInt32 () + Offset;
+			case OperandType.ShortInlineI:
+				if (instruction.opcode == OpCodes.Ldc_I4_S)
+					return ReadSByte ();
+
+				return ReadByte ();
+			case OperandType.InlineI:
+				return ReadInt32 ();
+			case OperandType.ShortInlineR:
+				return ReadSingle ();
+			case OperandType.InlineR:
+				return ReadDouble ();
+			case OperandType.InlineI8:
+				return ReadInt64 ();
+			case OperandType.ShortInlineVar:
+				return GetVariable (ReadByte ());
+			case OperandType.InlineVar:
+				return GetVariable (ReadUInt16 ());
+			case OperandType.ShortInlineArg:
+				return GetParameter (ReadByte ());
+			case OperandType.InlineArg:
+				return GetParameter (ReadUInt16 ());
+			case OperandType.InlineSig:
+				return GetCallSite (ReadToken ());
+			case OperandType.InlineString:
+				return GetString (ReadToken ());
+			case OperandType.InlineTok:
+			case OperandType.InlineType:
+			case OperandType.InlineMethod:
+			case OperandType.InlineField:
+				return reader.LookupToken (ReadToken ());
+			default:
+				throw new NotSupportedException ();
+			}
+		}
+
+		public string GetString (MetadataToken token)
+		{
+			return reader.image.UserStringHeap.Read (token.RID);
+		}
+
+		public ParameterDefinition GetParameter (int index)
+		{
+			return body.GetParameter (index);
+		}
+
+		public VariableDefinition GetVariable (int index)
+		{
+			return body.GetVariable (index);
+		}
+
+		public CallSite GetCallSite (MetadataToken token)
+		{
+			return reader.ReadCallSite (token);
+		}
+
+		void ResolveBranches (Collection<Instruction> instructions)
+		{
+			var items = instructions.items;
+			var size = instructions.size;
+
+			for (int i = 0; i < size; i++) {
+				var instruction = items [i];
+				switch (instruction.opcode.OperandType) {
+				case OperandType.ShortInlineBrTarget:
+				case OperandType.InlineBrTarget:
+					instruction.operand = GetInstruction ((int) instruction.operand);
+					break;
+				case OperandType.InlineSwitch:
+					var offsets = (int []) instruction.operand;
+					var branches = new Instruction [offsets.Length];
+					for (int j = 0; j < offsets.Length; j++)
+						branches [j] = GetInstruction (offsets [j]);
+
+					instruction.operand = branches;
+					break;
+				}
+			}
+		}
+
+		Instruction GetInstruction (int offset)
+		{
+			return GetInstruction (body.Instructions, offset);
+		}
+
+		static Instruction GetInstruction (Collection<Instruction> instructions, int offset)
+		{
+			var size = instructions.size;
+			var items = instructions.items;
+			if (offset < 0 || offset > items [size - 1].offset)
+				return null;
+
+			int min = 0;
+			int max = size - 1;
+			while (min <= max) {
+				int mid = min + ((max - min) / 2);
+				var instruction = items [mid];
+				var instruction_offset = instruction.offset;
+
+				if (offset == instruction_offset)
+					return instruction;
+
+				if (offset < instruction_offset)
+					max = mid - 1;
+				else
+					min = mid + 1;
+			}
+
+			return null;
+		}
+
+		void ReadSection ()
+		{
+			Align (4);
+
+			const byte fat_format = 0x40;
+			const byte more_sects = 0x80;
+
+			var flags = ReadByte ();
+			if ((flags & fat_format) == 0)
+				ReadSmallSection ();
+			else
+				ReadFatSection ();
+
+			if ((flags & more_sects) != 0)
+				ReadSection ();
+		}
+
+		void ReadSmallSection ()
+		{
+			var count = ReadByte () / 12;
+			Advance (2);
+
+			ReadExceptionHandlers (
+				count,
+				() => (int) ReadUInt16 (),
+				() => (int) ReadByte ());
+		}
+
+		void ReadFatSection ()
+		{
+			Advance (-1);
+			var count = (ReadInt32 () >> 8) / 24;
+
+			ReadExceptionHandlers (
+				count,
+				ReadInt32,
+				ReadInt32);
+		}
+
+		// inline ?
+		void ReadExceptionHandlers (int count, Func<int> read_entry, Func<int> read_length)
+		{
+			for (int i = 0; i < count; i++) {
+				var handler = new ExceptionHandler (
+					(ExceptionHandlerType) (read_entry () & 0x7));
+
+				handler.TryStart = GetInstruction (read_entry ());
+				handler.TryEnd = GetInstruction (handler.TryStart.Offset + read_length ());
+
+				handler.HandlerStart = GetInstruction (read_entry ());
+				handler.HandlerEnd = GetInstruction (handler.HandlerStart.Offset + read_length ());
+
+				ReadExceptionHandlerSpecific (handler);
+
+				this.body.ExceptionHandlers.Add (handler);
+			}
+		}
+
+		void ReadExceptionHandlerSpecific (ExceptionHandler handler)
+		{
+			switch (handler.HandlerType) {
+			case ExceptionHandlerType.Catch:
+				handler.CatchType = (TypeReference) reader.LookupToken (ReadToken ());
+				break;
+			case ExceptionHandlerType.Filter:
+				handler.FilterStart = GetInstruction (ReadInt32 ());
+				break;
+			default:
+				Advance (4);
+				break;
+			}
+		}
+
+		public MetadataToken ReadToken ()
+		{
+			return new MetadataToken (ReadUInt32 ());
+		}
+
+		void ReadDebugInfo ()
+		{
+			if (method.debug_info.sequence_points != null)
+				ReadSequencePoints ();
+
+			if (method.debug_info.scope != null)
+				ReadScope (method.debug_info.scope);
+
+			if (method.custom_infos != null)
+				ReadCustomDebugInformations (method);
+		}
+
+		void ReadCustomDebugInformations (MethodDefinition method)
+		{
+			var custom_infos = method.custom_infos;
+
+			for (int i = 0; i < custom_infos.Count; i++) {
+				var state_machine_scope = custom_infos [i] as StateMachineScopeDebugInformation;
+				if (state_machine_scope != null)
+					ReadStateMachineScope (state_machine_scope);
+
+				var async_method = custom_infos [i] as AsyncMethodBodyDebugInformation;
+				if (async_method != null)
+					ReadAsyncMethodBody (async_method);
+			}
+		}
+
+		void ReadAsyncMethodBody (AsyncMethodBodyDebugInformation async_method)
+		{
+			if (async_method.catch_handler.Offset > -1)
+				async_method.catch_handler = new InstructionOffset (GetInstruction (async_method.catch_handler.Offset));
+
+			if (!async_method.yields.IsNullOrEmpty ())
+				for (int i = 0; i < async_method.yields.Count; i++)
+					async_method.yields [i] = new InstructionOffset (GetInstruction (async_method.yields [i].Offset));
+
+			if (!async_method.resumes.IsNullOrEmpty ())
+				for (int i = 0; i < async_method.resumes.Count; i++)
+					async_method.resumes [i] = new InstructionOffset (GetInstruction (async_method.resumes [i].Offset));
+		}
+
+		void ReadStateMachineScope (StateMachineScopeDebugInformation state_machine_scope)
+		{
+			if (state_machine_scope.scopes.IsNullOrEmpty ())
+				return;
+
+			foreach (var scope in state_machine_scope.scopes) {
+				scope.start = new InstructionOffset (GetInstruction (scope.start.Offset));
+
+				var end_instruction = GetInstruction (scope.end.Offset);
+				scope.end = end_instruction == null
+					? new InstructionOffset ()
+					: new InstructionOffset (end_instruction);
+			}
+		}
+
+		void ReadSequencePoints ()
+		{
+			var symbol = method.debug_info;
+
+			for (int i = 0; i < symbol.sequence_points.Count; i++) {
+				var sequence_point = symbol.sequence_points [i];
+				var instruction = GetInstruction (sequence_point.Offset);
+				if (instruction != null)
+					sequence_point.offset = new InstructionOffset (instruction);
+			}
+		}
+
+		void ReadScopes (Collection<ScopeDebugInformation> scopes)
+		{
+			for (int i = 0; i < scopes.Count; i++)
+				ReadScope (scopes [i]);
+		}
+
+		void ReadScope (ScopeDebugInformation scope)
+		{
+			var start_instruction = GetInstruction (scope.Start.Offset);
+			if (start_instruction != null)
+				scope.Start = new InstructionOffset (start_instruction);
+
+			var end_instruction = GetInstruction (scope.End.Offset);
+			scope.End = end_instruction != null
+				? new InstructionOffset (end_instruction)
+				: new InstructionOffset ();
+
+			if (!scope.variables.IsNullOrEmpty ()) {
+				for (int i = 0; i < scope.variables.Count; i++) {
+					var variable_info = scope.variables [i];
+					var variable = GetVariable (variable_info.Index);
+					if (variable != null)
+						variable_info.index = new VariableIndex (variable);
+				}
+			}
+
+			if (!scope.scopes.IsNullOrEmpty ())
+				ReadScopes (scope.scopes);
+		}
+
+#if !READ_ONLY
+
+		public ByteBuffer PatchRawMethodBody (MethodDefinition method, CodeWriter writer, out int code_size, out MetadataToken local_var_token)
+		{
+			var position = MoveTo (method);
+
+			var buffer = new ByteBuffer ();
+
+			var flags = ReadByte ();
+
+			switch (flags & 0x3) {
+			case 0x2: // tiny
+				buffer.WriteByte (flags);
+				local_var_token = MetadataToken.Zero;
+				code_size = flags >> 2;
+				PatchRawCode (buffer, code_size, writer);
+				break;
+			case 0x3: // fat
+				Advance (-1);
+				PatchRawFatMethod (buffer, writer, out code_size, out local_var_token);
+				break;
+			default:
+				throw new NotSupportedException ();
+			}
+
+			MoveBackTo (position);
+
+			return buffer;
+		}
+
+		void PatchRawFatMethod (ByteBuffer buffer, CodeWriter writer, out int code_size, out MetadataToken local_var_token)
+		{
+			var flags = ReadUInt16 ();
+			buffer.WriteUInt16 (flags);
+			buffer.WriteUInt16 (ReadUInt16 ());
+			code_size = ReadInt32 ();
+			buffer.WriteInt32 (code_size);
+			local_var_token = ReadToken ();
+
+			if (local_var_token.RID > 0) {
+				var variables = ReadVariables (local_var_token);
+				buffer.WriteUInt32 (variables != null
+					? writer.GetStandAloneSignature (variables).ToUInt32 ()
+					: 0);
+			} else
+				buffer.WriteUInt32 (0);
+
+			PatchRawCode (buffer, code_size, writer);
+
+			if ((flags & 0x8) != 0)
+				PatchRawSection (buffer, writer.metadata);
+		}
+
+		void PatchRawCode (ByteBuffer buffer, int code_size, CodeWriter writer)
+		{
+			var metadata = writer.metadata;
+			buffer.WriteBytes (ReadBytes (code_size));
+			var end = buffer.position;
+			buffer.position -= code_size;
+
+			while (buffer.position < end) {
+				OpCode opcode;
+				var il_opcode = buffer.ReadByte ();
+				if (il_opcode != 0xfe) {
+					opcode = OpCodes.OneByteOpCode [il_opcode];
+				} else {
+					var il_opcode2 = buffer.ReadByte ();
+					opcode = OpCodes.TwoBytesOpCode [il_opcode2];
+				}
+
+				switch (opcode.OperandType) {
+				case OperandType.ShortInlineI:
+				case OperandType.ShortInlineBrTarget:
+				case OperandType.ShortInlineVar:
+				case OperandType.ShortInlineArg:
+					buffer.position += 1;
+					break;
+				case OperandType.InlineVar:
+				case OperandType.InlineArg:
+					buffer.position += 2;
+					break;
+				case OperandType.InlineBrTarget:
+				case OperandType.ShortInlineR:
+				case OperandType.InlineI:
+					buffer.position += 4;
+					break;
+				case OperandType.InlineI8:
+				case OperandType.InlineR:
+					buffer.position += 8;
+					break;
+				case OperandType.InlineSwitch:
+					var length = buffer.ReadInt32 ();
+					buffer.position += length * 4;
+					break;
+				case OperandType.InlineString:
+					var @string = GetString (new MetadataToken (buffer.ReadUInt32 ()));
+					buffer.position -= 4;
+					buffer.WriteUInt32 (
+						new MetadataToken (
+							TokenType.String,
+							metadata.user_string_heap.GetStringIndex (@string)).ToUInt32 ());
+					break;
+				case OperandType.InlineSig:
+					var call_site = GetCallSite (new MetadataToken (buffer.ReadUInt32 ()));
+					buffer.position -= 4;
+					buffer.WriteUInt32 (writer.GetStandAloneSignature (call_site).ToUInt32 ());
+					break;
+				case OperandType.InlineTok:
+				case OperandType.InlineType:
+				case OperandType.InlineMethod:
+				case OperandType.InlineField:
+					var provider = reader.LookupToken (new MetadataToken (buffer.ReadUInt32 ()));
+					buffer.position -= 4;
+					buffer.WriteUInt32 (metadata.LookupToken (provider).ToUInt32 ());
+					break;
+				}
+			}
+		}
+
+		void PatchRawSection (ByteBuffer buffer, MetadataBuilder metadata)
+		{
+			var position = Position;
+			Align (4);
+			buffer.WriteBytes (Position - position);
+
+			const byte fat_format = 0x40;
+			const byte more_sects = 0x80;
+
+			var flags = ReadByte ();
+			if ((flags & fat_format) == 0) {
+				buffer.WriteByte (flags);
+				PatchRawSmallSection (buffer, metadata);
+			} else
+				PatchRawFatSection (buffer, metadata);
+
+			if ((flags & more_sects) != 0)
+				PatchRawSection (buffer, metadata);
+		}
+
+		void PatchRawSmallSection (ByteBuffer buffer, MetadataBuilder metadata)
+		{
+			var length = ReadByte ();
+			buffer.WriteByte (length);
+			Advance (2);
+
+			buffer.WriteUInt16 (0);
+
+			var count = length / 12;
+
+			PatchRawExceptionHandlers (buffer, metadata, count, false);
+		}
+
+		void PatchRawFatSection (ByteBuffer buffer, MetadataBuilder metadata)
+		{
+			Advance (-1);
+			var length = ReadInt32 ();
+			buffer.WriteInt32 (length);
+
+			var count = (length >> 8) / 24;
+
+			PatchRawExceptionHandlers (buffer, metadata, count, true);
+		}
+
+		void PatchRawExceptionHandlers (ByteBuffer buffer, MetadataBuilder metadata, int count, bool fat_entry)
+		{
+			const int fat_entry_size = 16;
+			const int small_entry_size = 6;
+
+			for (int i = 0; i < count; i++) {
+				ExceptionHandlerType handler_type;
+				if (fat_entry) {
+					var type = ReadUInt32 ();
+					handler_type = (ExceptionHandlerType) (type & 0x7);
+					buffer.WriteUInt32 (type);
+				} else {
+					var type = ReadUInt16 ();
+					handler_type = (ExceptionHandlerType) (type & 0x7);
+					buffer.WriteUInt16 (type);
+				}
+
+				buffer.WriteBytes (ReadBytes (fat_entry ? fat_entry_size : small_entry_size));
+
+				switch (handler_type) {
+				case ExceptionHandlerType.Catch:
+					var exception = reader.LookupToken (ReadToken ());
+					buffer.WriteUInt32 (metadata.LookupToken (exception).ToUInt32 ());
+					break;
+				default:
+					buffer.WriteUInt32 (ReadUInt32 ());
+					break;
+				}
+			}
+		}
+
+#endif
+
+	}
+}
diff --git a/src/Mono/Cecil/Cil/CodeWriter.cs b/src/Mono/Cecil/Cil/CodeWriter.cs
new file mode 100644
index 00000000..2003f104
--- /dev/null
+++ b/src/Mono/Cecil/Cil/CodeWriter.cs
@@ -0,0 +1,659 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+
+using Mono.Collections.Generic;
+
+using Mono.Cecil.Metadata;
+using Mono.Cecil.PE;
+
+using RVA = System.UInt32;
+
+#if !READ_ONLY
+
+namespace Mono.Cecil.Cil {
+
+	sealed class CodeWriter : ByteBuffer {
+
+		readonly RVA code_base;
+		internal readonly MetadataBuilder metadata;
+		readonly Dictionary<uint, MetadataToken> standalone_signatures;
+		readonly Dictionary<ByteBuffer, RVA> tiny_method_bodies;
+
+		MethodBody body;
+
+		public CodeWriter (MetadataBuilder metadata)
+			: base (0)
+		{
+			this.code_base = metadata.text_map.GetNextRVA (TextSegment.CLIHeader);
+			this.metadata = metadata;
+			this.standalone_signatures = new Dictionary<uint, MetadataToken> ();
+			this.tiny_method_bodies = new Dictionary<ByteBuffer, RVA> (new ByteBufferEqualityComparer ());
+		}
+
+		public RVA WriteMethodBody (MethodDefinition method)
+		{
+			RVA rva;
+
+			if (IsUnresolved (method)) {
+				if (method.rva == 0)
+					return 0;
+
+				rva = WriteUnresolvedMethodBody (method);
+			} else {
+				if (IsEmptyMethodBody (method.Body))
+					return 0;
+
+				rva = WriteResolvedMethodBody (method);
+			}
+
+			return rva;
+		}
+
+		static bool IsEmptyMethodBody (MethodBody body)
+		{
+			return body.instructions.IsNullOrEmpty ()
+				&& body.variables.IsNullOrEmpty ();
+		}
+
+		static bool IsUnresolved (MethodDefinition method)
+		{
+			return method.HasBody && method.HasImage && method.body == null;
+		}
+
+		RVA WriteUnresolvedMethodBody (MethodDefinition method)
+		{
+			var code_reader = metadata.module.reader.code;
+
+			int code_size;
+			MetadataToken local_var_token;
+			var raw_body = code_reader.PatchRawMethodBody (method, this, out code_size, out local_var_token);
+			var fat_header = (raw_body.buffer [0] & 0x3) == 0x3;
+			if (fat_header)
+				Align (4);
+
+			var rva = BeginMethod ();
+
+			if (fat_header || !GetOrMapTinyMethodBody (raw_body, ref rva))  {
+				WriteBytes (raw_body);
+			}
+
+			if (method.debug_info == null)
+				return rva;
+
+			var symbol_writer = metadata.symbol_writer;
+			if (symbol_writer != null) {
+				method.debug_info.code_size = code_size;
+				method.debug_info.local_var_token = local_var_token;
+				symbol_writer.Write (method.debug_info);
+			}
+
+			return rva;
+		}
+
+		RVA WriteResolvedMethodBody(MethodDefinition method)
+		{
+			RVA rva;
+
+			body = method.Body;
+			ComputeHeader ();
+			if (RequiresFatHeader ()) {
+				Align (4);
+				rva = BeginMethod ();
+				WriteFatHeader ();
+				WriteInstructions ();
+
+				if (body.HasExceptionHandlers)
+					WriteExceptionHandlers ();
+			} else {
+				rva = BeginMethod ();
+				WriteByte ((byte) (0x2 | (body.CodeSize << 2))); // tiny
+				WriteInstructions ();
+
+				var start_position = (int) (rva - code_base);
+				var body_size = position - start_position;
+				var body_bytes = new byte [body_size];
+
+				Array.Copy (buffer, start_position, body_bytes, 0, body_size);
+
+				if (GetOrMapTinyMethodBody (new ByteBuffer (body_bytes), ref rva))
+					position = start_position;
+			}
+
+			var symbol_writer = metadata.symbol_writer;
+			if (symbol_writer != null && method.debug_info != null) {
+				method.debug_info.code_size = body.CodeSize;
+				method.debug_info.local_var_token = body.local_var_token;
+				symbol_writer.Write (method.debug_info);
+			}
+
+			return rva;
+		}
+
+		bool GetOrMapTinyMethodBody (ByteBuffer body, ref RVA rva)
+		{
+			RVA existing_rva;
+			if (tiny_method_bodies.TryGetValue (body, out existing_rva)) {
+				rva = existing_rva;
+				return true;
+			}
+
+			tiny_method_bodies.Add (body, rva);
+			return false;
+		}
+
+		void WriteFatHeader ()
+		{
+			var body = this.body;
+			byte flags = 0x3;	// fat
+			if (body.InitLocals)
+				flags |= 0x10;	// init locals
+			if (body.HasExceptionHandlers)
+				flags |= 0x8;	// more sections
+
+			WriteByte (flags);
+			WriteByte (0x30);
+			WriteInt16 ((short) body.max_stack_size);
+			WriteInt32 (body.code_size);
+			body.local_var_token = body.HasVariables
+				? GetStandAloneSignature (body.Variables)
+				: MetadataToken.Zero;
+			WriteMetadataToken (body.local_var_token);
+		}
+
+		void WriteInstructions ()
+		{
+			var instructions = body.Instructions;
+			var items = instructions.items;
+			var size = instructions.size;
+
+			for (int i = 0; i < size; i++) {
+				var instruction = items [i];
+				WriteOpCode (instruction.opcode);
+				WriteOperand (instruction);
+			}
+		}
+
+		void WriteOpCode (OpCode opcode)
+		{
+			if (opcode.Size == 1) {
+				WriteByte (opcode.Op2);
+			} else {
+				WriteByte (opcode.Op1);
+				WriteByte (opcode.Op2);
+			}
+		}
+
+		void WriteOperand (Instruction instruction)
+		{
+			var opcode = instruction.opcode;
+			var operand_type = opcode.OperandType;
+			if (operand_type == OperandType.InlineNone)
+				return;
+
+			var operand = instruction.operand;
+			if (operand == null && !(operand_type == OperandType.InlineBrTarget || operand_type == OperandType.ShortInlineBrTarget)) {
+				throw new ArgumentException ();
+			}
+
+			switch (operand_type) {
+			case OperandType.InlineSwitch: {
+				var targets = (Instruction []) operand;
+				WriteInt32 (targets.Length);
+				var diff = instruction.Offset + opcode.Size + (4 * (targets.Length + 1));
+				for (int i = 0; i < targets.Length; i++)
+					WriteInt32 (GetTargetOffset (targets [i]) - diff);
+				break;
+			}
+			case OperandType.ShortInlineBrTarget: {
+				var target = (Instruction) operand;
+				var offset = target != null ? GetTargetOffset (target) : body.code_size;
+				WriteSByte ((sbyte) (offset - (instruction.Offset + opcode.Size + 1)));
+				break;
+			}
+			case OperandType.InlineBrTarget: {
+				var target = (Instruction) operand;
+				var offset = target != null ? GetTargetOffset (target) : body.code_size;
+				WriteInt32 (offset - (instruction.Offset + opcode.Size + 4));
+				break;
+			}
+			case OperandType.ShortInlineVar:
+				WriteByte ((byte) GetVariableIndex ((VariableDefinition) operand));
+				break;
+			case OperandType.ShortInlineArg:
+				WriteByte ((byte) GetParameterIndex ((ParameterDefinition) operand));
+				break;
+			case OperandType.InlineVar:
+				WriteInt16 ((short) GetVariableIndex ((VariableDefinition) operand));
+				break;
+			case OperandType.InlineArg:
+				WriteInt16 ((short) GetParameterIndex ((ParameterDefinition) operand));
+				break;
+			case OperandType.InlineSig:
+				WriteMetadataToken (GetStandAloneSignature ((CallSite) operand));
+				break;
+			case OperandType.ShortInlineI:
+				if (opcode == OpCodes.Ldc_I4_S)
+					WriteSByte ((sbyte) operand);
+				else
+					WriteByte ((byte) operand);
+				break;
+			case OperandType.InlineI:
+				WriteInt32 ((int) operand);
+				break;
+			case OperandType.InlineI8:
+				WriteInt64 ((long) operand);
+				break;
+			case OperandType.ShortInlineR:
+				WriteSingle ((float) operand);
+				break;
+			case OperandType.InlineR:
+				WriteDouble ((double) operand);
+				break;
+			case OperandType.InlineString:
+				WriteMetadataToken (
+					new MetadataToken (
+						TokenType.String,
+						GetUserStringIndex ((string) operand)));
+				break;
+			case OperandType.InlineType:
+			case OperandType.InlineField:
+			case OperandType.InlineMethod:
+			case OperandType.InlineTok:
+				WriteMetadataToken (metadata.LookupToken ((IMetadataTokenProvider) operand));
+				break;
+			default:
+				throw new ArgumentException ();
+			}
+		}
+
+		int GetTargetOffset (Instruction instruction)
+		{
+			if (instruction == null) {
+				var last = body.instructions [body.instructions.size - 1];
+				return last.offset + last.GetSize ();
+			}
+
+			return instruction.offset;
+		}
+
+		uint GetUserStringIndex (string @string)
+		{
+			if (@string == null)
+				return 0;
+
+			return metadata.user_string_heap.GetStringIndex (@string);
+		}
+
+		static int GetVariableIndex (VariableDefinition variable)
+		{
+			return variable.Index;
+		}
+
+		int GetParameterIndex (ParameterDefinition parameter)
+		{
+			if (body.method.HasThis) {
+				if (parameter == body.this_parameter)
+					return 0;
+
+				return parameter.Index + 1;
+			}
+
+			return parameter.Index;
+		}
+
+		bool RequiresFatHeader ()
+		{
+			var body = this.body;
+			return body.CodeSize >= 64
+				|| body.InitLocals
+				|| body.HasVariables
+				|| body.HasExceptionHandlers
+				|| body.MaxStackSize > 8;
+		}
+
+		void ComputeHeader ()
+		{
+			int offset = 0;
+			var instructions = body.instructions;
+			var items = instructions.items;
+			var count = instructions.size;
+			var stack_size = 0;
+			var max_stack = 0;
+			Dictionary<Instruction, int> stack_sizes = null;
+
+			if (body.HasExceptionHandlers)
+				ComputeExceptionHandlerStackSize (ref stack_sizes);
+
+			for (int i = 0; i < count; i++) {
+				var instruction = items [i];
+				instruction.offset = offset;
+				offset += instruction.GetSize ();
+
+				ComputeStackSize (instruction, ref stack_sizes, ref stack_size, ref max_stack);
+			}
+
+			body.code_size = offset;
+			body.max_stack_size = max_stack;
+		}
+
+		void ComputeExceptionHandlerStackSize (ref Dictionary<Instruction, int> stack_sizes)
+		{
+			var exception_handlers = body.ExceptionHandlers;
+
+			for (int i = 0; i < exception_handlers.Count; i++) {
+				var exception_handler = exception_handlers [i];
+
+				switch (exception_handler.HandlerType) {
+				case ExceptionHandlerType.Catch:
+					AddExceptionStackSize (exception_handler.HandlerStart, ref stack_sizes);
+					break;
+				case ExceptionHandlerType.Filter:
+					AddExceptionStackSize (exception_handler.FilterStart, ref stack_sizes);
+					AddExceptionStackSize (exception_handler.HandlerStart, ref stack_sizes);
+					break;
+				}
+			}
+		}
+
+		static void AddExceptionStackSize (Instruction handler_start, ref Dictionary<Instruction, int> stack_sizes)
+		{
+			if (handler_start == null)
+				return;
+
+			if (stack_sizes == null)
+				stack_sizes = new Dictionary<Instruction, int> ();
+
+			stack_sizes [handler_start] = 1;
+		}
+
+		static void ComputeStackSize (Instruction instruction, ref Dictionary<Instruction, int> stack_sizes, ref int stack_size, ref int max_stack)
+		{
+			int computed_size;
+			if (stack_sizes != null && stack_sizes.TryGetValue (instruction, out computed_size))
+				stack_size = computed_size;
+
+			max_stack = System.Math.Max (max_stack, stack_size);
+			ComputeStackDelta (instruction, ref stack_size);
+			max_stack = System.Math.Max (max_stack, stack_size);
+
+			CopyBranchStackSize (instruction, ref stack_sizes, stack_size);
+			ComputeStackSize (instruction, ref stack_size);
+		}
+
+		static void CopyBranchStackSize (Instruction instruction, ref Dictionary<Instruction, int> stack_sizes, int stack_size)
+		{
+			if (stack_size == 0)
+				return;
+
+			switch (instruction.opcode.OperandType) {
+			case OperandType.ShortInlineBrTarget:
+			case OperandType.InlineBrTarget:
+				CopyBranchStackSize (ref stack_sizes, (Instruction) instruction.operand, stack_size);
+				break;
+			case OperandType.InlineSwitch:
+				var targets = (Instruction []) instruction.operand;
+				for (int i = 0; i < targets.Length; i++)
+					CopyBranchStackSize (ref stack_sizes, targets [i], stack_size);
+				break;
+			}
+		}
+
+		static void CopyBranchStackSize (ref Dictionary<Instruction, int> stack_sizes, Instruction target, int stack_size)
+		{
+			if (stack_sizes == null)
+				stack_sizes = new Dictionary<Instruction, int> ();
+
+			int branch_stack_size = stack_size;
+
+			int computed_size;
+			if (stack_sizes.TryGetValue (target, out computed_size))
+				branch_stack_size = System.Math.Max (branch_stack_size, computed_size);
+
+			stack_sizes [target] = branch_stack_size;
+		}
+
+		static void ComputeStackSize (Instruction instruction, ref int stack_size)
+		{
+			switch (instruction.opcode.FlowControl) {
+			case FlowControl.Branch:
+			case FlowControl.Break:
+			case FlowControl.Throw:
+			case FlowControl.Return:
+				stack_size = 0;
+				break;
+			}
+		}
+
+		static void ComputeStackDelta (Instruction instruction, ref int stack_size)
+		{
+			switch (instruction.opcode.FlowControl) {
+			case FlowControl.Call: {
+				var method = (IMethodSignature) instruction.operand;
+				// pop 'this' argument
+				if (method.HasImplicitThis() && instruction.opcode.Code != Code.Newobj)
+					stack_size--;
+				// pop normal arguments
+				if (method.HasParameters)
+					stack_size -= method.Parameters.Count;
+				// pop function pointer
+				if (instruction.opcode.Code == Code.Calli)
+					stack_size--;
+				// push return value
+				if (method.ReturnType.etype != ElementType.Void || instruction.opcode.Code == Code.Newobj)
+					stack_size++;
+				break;
+			}
+			default:
+				ComputePopDelta (instruction.opcode.StackBehaviourPop, ref stack_size);
+				ComputePushDelta (instruction.opcode.StackBehaviourPush, ref stack_size);
+				break;
+			}
+		}
+
+		static void ComputePopDelta (StackBehaviour pop_behavior, ref int stack_size)
+		{
+			switch (pop_behavior) {
+			case StackBehaviour.Popi:
+			case StackBehaviour.Popref:
+			case StackBehaviour.Pop1:
+				stack_size--;
+				break;
+			case StackBehaviour.Pop1_pop1:
+			case StackBehaviour.Popi_pop1:
+			case StackBehaviour.Popi_popi:
+			case StackBehaviour.Popi_popi8:
+			case StackBehaviour.Popi_popr4:
+			case StackBehaviour.Popi_popr8:
+			case StackBehaviour.Popref_pop1:
+			case StackBehaviour.Popref_popi:
+				stack_size -= 2;
+				break;
+			case StackBehaviour.Popi_popi_popi:
+			case StackBehaviour.Popref_popi_popi:
+			case StackBehaviour.Popref_popi_popi8:
+			case StackBehaviour.Popref_popi_popr4:
+			case StackBehaviour.Popref_popi_popr8:
+			case StackBehaviour.Popref_popi_popref:
+				stack_size -= 3;
+				break;
+			case StackBehaviour.PopAll:
+				stack_size = 0;
+				break;
+			}
+		}
+
+		static void ComputePushDelta (StackBehaviour push_behaviour, ref int stack_size)
+		{
+			switch (push_behaviour) {
+			case StackBehaviour.Push1:
+			case StackBehaviour.Pushi:
+			case StackBehaviour.Pushi8:
+			case StackBehaviour.Pushr4:
+			case StackBehaviour.Pushr8:
+			case StackBehaviour.Pushref:
+				stack_size++;
+				break;
+			case StackBehaviour.Push1_push1:
+				stack_size += 2;
+				break;
+			}
+		}
+
+		void WriteExceptionHandlers ()
+		{
+			Align (4);
+
+			var handlers = body.ExceptionHandlers;
+
+			if (handlers.Count < 0x15 && !RequiresFatSection (handlers))
+				WriteSmallSection (handlers);
+			else
+				WriteFatSection (handlers);
+		}
+
+		static bool RequiresFatSection (Collection<ExceptionHandler> handlers)
+		{
+			for (int i = 0; i < handlers.Count; i++) {
+				var handler = handlers [i];
+
+				if (IsFatRange (handler.TryStart, handler.TryEnd))
+					return true;
+
+				if (IsFatRange (handler.HandlerStart, handler.HandlerEnd))
+					return true;
+
+				if (handler.HandlerType == ExceptionHandlerType.Filter
+					&& IsFatRange (handler.FilterStart, handler.HandlerStart))
+					return true;
+			}
+
+			return false;
+		}
+
+		static bool IsFatRange (Instruction start, Instruction end)
+		{
+			if (start == null)
+				throw new ArgumentException ();
+
+			if (end == null)
+				return true;
+
+			return end.Offset - start.Offset > 255 || start.Offset > 65535;
+		}
+
+		void WriteSmallSection (Collection<ExceptionHandler> handlers)
+		{
+			const byte eh_table = 0x1;
+
+			WriteByte (eh_table);
+			WriteByte ((byte) (handlers.Count * 12 + 4));
+			WriteBytes (2);
+
+			WriteExceptionHandlers (
+				handlers,
+				i => WriteUInt16 ((ushort) i),
+				i => WriteByte ((byte) i));
+		}
+
+		void WriteFatSection (Collection<ExceptionHandler> handlers)
+		{
+			const byte eh_table = 0x1;
+			const byte fat_format = 0x40;
+
+			WriteByte (eh_table | fat_format);
+
+			int size = handlers.Count * 24 + 4;
+			WriteByte ((byte) (size & 0xff));
+			WriteByte ((byte) ((size >> 8) & 0xff));
+			WriteByte ((byte) ((size >> 16) & 0xff));
+
+			WriteExceptionHandlers (handlers, WriteInt32, WriteInt32);
+		}
+
+		void WriteExceptionHandlers (Collection<ExceptionHandler> handlers, Action<int> write_entry, Action<int> write_length)
+		{
+			for (int i = 0; i < handlers.Count; i++) {
+				var handler = handlers [i];
+
+				write_entry ((int) handler.HandlerType);
+
+				write_entry (handler.TryStart.Offset);
+				write_length (GetTargetOffset (handler.TryEnd) - handler.TryStart.Offset);
+
+				write_entry (handler.HandlerStart.Offset);
+				write_length (GetTargetOffset (handler.HandlerEnd) - handler.HandlerStart.Offset);
+
+				WriteExceptionHandlerSpecific (handler);
+			}
+		}
+
+		void WriteExceptionHandlerSpecific (ExceptionHandler handler)
+		{
+			switch (handler.HandlerType) {
+			case ExceptionHandlerType.Catch:
+				WriteMetadataToken (metadata.LookupToken (handler.CatchType));
+				break;
+			case ExceptionHandlerType.Filter:
+				WriteInt32 (handler.FilterStart.Offset);
+				break;
+			default:
+				WriteInt32 (0);
+				break;
+			}
+		}
+
+		public MetadataToken GetStandAloneSignature (Collection<VariableDefinition> variables)
+		{
+			var signature = metadata.GetLocalVariableBlobIndex (variables);
+
+			return GetStandAloneSignatureToken (signature);
+		}
+
+		public MetadataToken GetStandAloneSignature (CallSite call_site)
+		{
+			var signature = metadata.GetCallSiteBlobIndex (call_site);
+			var token = GetStandAloneSignatureToken (signature);
+			call_site.MetadataToken = token;
+			return token;
+		}
+
+		MetadataToken GetStandAloneSignatureToken (uint signature)
+		{
+			MetadataToken token;
+			if (standalone_signatures.TryGetValue (signature, out token))
+				return token;
+
+			token = new MetadataToken (TokenType.Signature, metadata.AddStandAloneSignature (signature));
+			standalone_signatures.Add (signature, token);
+			return token;
+		}
+
+		RVA BeginMethod ()
+		{
+			return (RVA)(code_base + position);
+		}
+
+		void WriteMetadataToken (MetadataToken token)
+		{
+			WriteUInt32 (token.ToUInt32 ());
+		}
+
+		void Align (int align)
+		{
+			align--;
+			WriteBytes (((position + align) & ~align) - position);
+		}
+	}
+}
+
+#endif
diff --git a/src/Mono/Cecil/Cil/Document.cs b/src/Mono/Cecil/Cil/Document.cs
new file mode 100644
index 00000000..03d3ec30
--- /dev/null
+++ b/src/Mono/Cecil/Cil/Document.cs
@@ -0,0 +1,123 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil.Cil {
+
+	public enum DocumentType {
+		Other,
+		Text,
+	}
+
+	public enum DocumentHashAlgorithm {
+		None,
+		MD5,
+		SHA1,
+		SHA256,
+	}
+
+	public enum DocumentLanguage {
+		Other,
+		C,
+		Cpp,
+		CSharp,
+		Basic,
+		Java,
+		Cobol,
+		Pascal,
+		Cil,
+		JScript,
+		Smc,
+		MCpp,
+		FSharp,
+	}
+
+	public enum DocumentLanguageVendor {
+		Other,
+		Microsoft,
+	}
+
+	public sealed class Document : DebugInformation {
+
+		string url;
+
+		Guid type;
+		Guid hash_algorithm;
+		Guid language;
+		Guid language_vendor;
+
+		byte [] hash;
+		byte [] embedded_source;
+
+		public string Url {
+			get { return url; }
+			set { url = value; }
+		}
+
+		public DocumentType Type {
+			get { return type.ToType (); }
+			set { type = value.ToGuid (); }
+		}
+
+		public Guid TypeGuid {
+			get { return type; }
+			set { type = value; }
+		}
+
+		public DocumentHashAlgorithm HashAlgorithm {
+			get { return hash_algorithm.ToHashAlgorithm (); }
+			set { hash_algorithm = value.ToGuid (); }
+		}
+
+		public Guid HashAlgorithmGuid {
+			get { return hash_algorithm; }
+			set { hash_algorithm = value; }
+		}
+
+		public DocumentLanguage Language {
+			get { return language.ToLanguage (); }
+			set { language = value.ToGuid (); }
+		}
+
+		public Guid LanguageGuid {
+			get { return language; }
+			set { language = value; }
+		}
+
+		public DocumentLanguageVendor LanguageVendor {
+			get { return language_vendor.ToVendor (); }
+			set { language_vendor = value.ToGuid (); }
+		}
+
+		public Guid LanguageVendorGuid {
+			get { return language_vendor; }
+			set { language_vendor = value; }
+		}
+
+		public byte [] Hash {
+			get { return hash; }
+			set { hash = value; }
+		}
+
+		public byte[] EmbeddedSource {
+			get { return embedded_source; }
+			set { embedded_source = value; }
+		}
+
+		public Document (string url)
+		{
+			this.url = url;
+			this.hash = Empty<byte>.Array;
+			this.embedded_source = Empty<byte>.Array;
+			this.token = new MetadataToken (TokenType.Document);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/ExceptionHandler.cs b/src/Mono/Cecil/Cil/ExceptionHandler.cs
new file mode 100644
index 00000000..6bdb1aa3
--- /dev/null
+++ b/src/Mono/Cecil/Cil/ExceptionHandler.cs
@@ -0,0 +1,71 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Cil {
+
+	public enum ExceptionHandlerType {
+		Catch = 0,
+		Filter = 1,
+		Finally = 2,
+		Fault = 4,
+	}
+
+	public sealed class ExceptionHandler {
+
+		Instruction try_start;
+		Instruction try_end;
+		Instruction filter_start;
+		Instruction handler_start;
+		Instruction handler_end;
+
+		TypeReference catch_type;
+		ExceptionHandlerType handler_type;
+
+		public Instruction TryStart {
+			get { return try_start; }
+			set { try_start = value; }
+		}
+
+		public Instruction TryEnd {
+			get { return try_end; }
+			set { try_end = value; }
+		}
+
+		public Instruction FilterStart {
+			get { return filter_start; }
+			set { filter_start = value; }
+		}
+
+		public Instruction HandlerStart {
+			get { return handler_start; }
+			set { handler_start = value; }
+		}
+
+		public Instruction HandlerEnd {
+			get { return handler_end; }
+			set { handler_end = value; }
+		}
+
+		public TypeReference CatchType {
+			get { return catch_type; }
+			set { catch_type = value; }
+		}
+
+		public ExceptionHandlerType HandlerType {
+			get { return handler_type; }
+			set { handler_type = value; }
+		}
+
+		public ExceptionHandler (ExceptionHandlerType handlerType)
+		{
+			this.handler_type = handlerType;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/ILProcessor.cs b/src/Mono/Cecil/Cil/ILProcessor.cs
new file mode 100644
index 00000000..039d2fc3
--- /dev/null
+++ b/src/Mono/Cecil/Cil/ILProcessor.cs
@@ -0,0 +1,260 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil.Cil {
+
+	public sealed class ILProcessor {
+
+		readonly MethodBody body;
+		readonly Collection<Instruction> instructions;
+
+		public MethodBody Body {
+			get { return body; }
+		}
+
+		internal ILProcessor (MethodBody body)
+		{
+			this.body = body;
+			this.instructions = body.Instructions;
+		}
+
+		public Instruction Create (OpCode opcode)
+		{
+			return Instruction.Create (opcode);
+		}
+
+		public Instruction Create (OpCode opcode, TypeReference type)
+		{
+			return Instruction.Create (opcode, type);
+		}
+
+		public Instruction Create (OpCode opcode, CallSite site)
+		{
+			return Instruction.Create (opcode, site);
+		}
+
+		public Instruction Create (OpCode opcode, MethodReference method)
+		{
+			return Instruction.Create (opcode, method);
+		}
+
+		public Instruction Create (OpCode opcode, FieldReference field)
+		{
+			return Instruction.Create (opcode, field);
+		}
+
+		public Instruction Create (OpCode opcode, string value)
+		{
+			return Instruction.Create (opcode, value);
+		}
+
+		public Instruction Create (OpCode opcode, sbyte value)
+		{
+			return Instruction.Create (opcode, value);
+		}
+
+		public Instruction Create (OpCode opcode, byte value)
+		{
+			if (opcode.OperandType == OperandType.ShortInlineVar)
+				return Instruction.Create (opcode, body.Variables [value]);
+
+			if (opcode.OperandType == OperandType.ShortInlineArg)
+				return Instruction.Create (opcode, body.GetParameter (value));
+
+			return Instruction.Create (opcode, value);
+		}
+
+		public Instruction Create (OpCode opcode, int value)
+		{
+			if (opcode.OperandType == OperandType.InlineVar)
+				return Instruction.Create (opcode, body.Variables [value]);
+
+			if (opcode.OperandType == OperandType.InlineArg)
+				return Instruction.Create (opcode, body.GetParameter (value));
+
+			return Instruction.Create (opcode, value);
+		}
+
+		public Instruction Create (OpCode opcode, long value)
+		{
+			return Instruction.Create (opcode, value);
+		}
+
+		public Instruction Create (OpCode opcode, float value)
+		{
+			return Instruction.Create (opcode, value);
+		}
+
+		public Instruction Create (OpCode opcode, double value)
+		{
+			return Instruction.Create (opcode, value);
+		}
+
+		public Instruction Create (OpCode opcode, Instruction target)
+		{
+			return Instruction.Create (opcode, target);
+		}
+
+		public Instruction Create (OpCode opcode, Instruction [] targets)
+		{
+			return Instruction.Create (opcode, targets);
+		}
+
+		public Instruction Create (OpCode opcode, VariableDefinition variable)
+		{
+			return Instruction.Create (opcode, variable);
+		}
+
+		public Instruction Create (OpCode opcode, ParameterDefinition parameter)
+		{
+			return Instruction.Create (opcode, parameter);
+		}
+
+		public void Emit (OpCode opcode)
+		{
+			Append (Create (opcode));
+		}
+
+		public void Emit (OpCode opcode, TypeReference type)
+		{
+			Append (Create (opcode, type));
+		}
+
+		public void Emit (OpCode opcode, MethodReference method)
+		{
+			Append (Create (opcode, method));
+		}
+
+		public void Emit (OpCode opcode, CallSite site)
+		{
+			Append (Create (opcode, site));
+		}
+
+		public void Emit (OpCode opcode, FieldReference field)
+		{
+			Append (Create (opcode, field));
+		}
+
+		public void Emit (OpCode opcode, string value)
+		{
+			Append (Create (opcode, value));
+		}
+
+		public void Emit (OpCode opcode, byte value)
+		{
+			Append (Create (opcode, value));
+		}
+
+		public void Emit (OpCode opcode, sbyte value)
+		{
+			Append (Create (opcode, value));
+		}
+
+		public void Emit (OpCode opcode, int value)
+		{
+			Append (Create (opcode, value));
+		}
+
+		public void Emit (OpCode opcode, long value)
+		{
+			Append (Create (opcode, value));
+		}
+
+		public void Emit (OpCode opcode, float value)
+		{
+			Append (Create (opcode, value));
+		}
+
+		public void Emit (OpCode opcode, double value)
+		{
+			Append (Create (opcode, value));
+		}
+
+		public void Emit (OpCode opcode, Instruction target)
+		{
+			Append (Create (opcode, target));
+		}
+
+		public void Emit (OpCode opcode, Instruction [] targets)
+		{
+			Append (Create (opcode, targets));
+		}
+
+		public void Emit (OpCode opcode, VariableDefinition variable)
+		{
+			Append (Create (opcode, variable));
+		}
+
+		public void Emit (OpCode opcode, ParameterDefinition parameter)
+		{
+			Append (Create (opcode, parameter));
+		}
+
+		public void InsertBefore (Instruction target, Instruction instruction)
+		{
+			if (target == null)
+				throw new ArgumentNullException ("target");
+			if (instruction == null)
+				throw new ArgumentNullException ("instruction");
+
+			var index = instructions.IndexOf (target);
+			if (index == -1)
+				throw new ArgumentOutOfRangeException ("target");
+
+			instructions.Insert (index, instruction);
+		}
+
+		public void InsertAfter (Instruction target, Instruction instruction)
+		{
+			if (target == null)
+				throw new ArgumentNullException ("target");
+			if (instruction == null)
+				throw new ArgumentNullException ("instruction");
+
+			var index = instructions.IndexOf (target);
+			if (index == -1)
+				throw new ArgumentOutOfRangeException ("target");
+
+			instructions.Insert (index + 1, instruction);
+		}
+
+		public void Append (Instruction instruction)
+		{
+			if (instruction == null)
+				throw new ArgumentNullException ("instruction");
+
+			instructions.Add (instruction);
+		}
+
+		public void Replace (Instruction target, Instruction instruction)
+		{
+			if (target == null)
+				throw new ArgumentNullException ("target");
+			if (instruction == null)
+				throw new ArgumentNullException ("instruction");
+
+			InsertAfter (target, instruction);
+			Remove (target);
+		}
+
+		public void Remove (Instruction instruction)
+		{
+			if (instruction == null)
+				throw new ArgumentNullException ("instruction");
+
+			if (!instructions.Remove (instruction))
+				throw new ArgumentOutOfRangeException ("instruction");
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/Instruction.cs b/src/Mono/Cecil/Cil/Instruction.cs
new file mode 100644
index 00000000..5fb36049
--- /dev/null
+++ b/src/Mono/Cecil/Cil/Instruction.cs
@@ -0,0 +1,296 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+
+namespace Mono.Cecil.Cil {
+
+	public sealed class Instruction {
+
+		internal int offset;
+		internal OpCode opcode;
+		internal object operand;
+
+		internal Instruction previous;
+		internal Instruction next;
+
+		public int Offset {
+			get { return offset; }
+			set { offset = value; }
+		}
+
+		public OpCode OpCode {
+			get { return opcode; }
+			set { opcode = value; }
+		}
+
+		public object Operand {
+			get { return operand; }
+			set { operand = value; }
+		}
+
+		public Instruction Previous {
+			get { return previous; }
+			set { previous = value; }
+		}
+
+		public Instruction Next {
+			get { return next; }
+			set { next = value; }
+		}
+
+		internal Instruction (int offset, OpCode opCode)
+		{
+			this.offset = offset;
+			this.opcode = opCode;
+		}
+
+		internal Instruction (OpCode opcode, object operand)
+		{
+			this.opcode = opcode;
+			this.operand = operand;
+		}
+
+		public int GetSize ()
+		{
+			int size = opcode.Size;
+
+			switch (opcode.OperandType) {
+			case OperandType.InlineSwitch:
+				return size + (1 + ((Instruction []) operand).Length) * 4;
+			case OperandType.InlineI8:
+			case OperandType.InlineR:
+				return size + 8;
+			case OperandType.InlineBrTarget:
+			case OperandType.InlineField:
+			case OperandType.InlineI:
+			case OperandType.InlineMethod:
+			case OperandType.InlineString:
+			case OperandType.InlineTok:
+			case OperandType.InlineType:
+			case OperandType.ShortInlineR:
+			case OperandType.InlineSig:
+				return size + 4;
+			case OperandType.InlineArg:
+			case OperandType.InlineVar:
+				return size + 2;
+			case OperandType.ShortInlineBrTarget:
+			case OperandType.ShortInlineI:
+			case OperandType.ShortInlineArg:
+			case OperandType.ShortInlineVar:
+				return size + 1;
+			default:
+				return size;
+			}
+		}
+
+		public override string ToString ()
+		{
+			var instruction = new StringBuilder ();
+
+			AppendLabel (instruction, this);
+			instruction.Append (':');
+			instruction.Append (' ');
+			instruction.Append (opcode.Name);
+
+			if (operand == null)
+				return instruction.ToString ();
+
+			instruction.Append (' ');
+
+			switch (opcode.OperandType) {
+			case OperandType.ShortInlineBrTarget:
+			case OperandType.InlineBrTarget:
+				AppendLabel (instruction, (Instruction) operand);
+				break;
+			case OperandType.InlineSwitch:
+				var labels = (Instruction []) operand;
+				for (int i = 0; i < labels.Length; i++) {
+					if (i > 0)
+						instruction.Append (',');
+
+					AppendLabel (instruction, labels [i]);
+				}
+				break;
+			case OperandType.InlineString:
+				instruction.Append ('\"');
+				instruction.Append (operand);
+				instruction.Append ('\"');
+				break;
+			default:
+				instruction.Append (operand);
+				break;
+			}
+
+			return instruction.ToString ();
+		}
+
+		static void AppendLabel (StringBuilder builder, Instruction instruction)
+		{
+			builder.Append ("IL_");
+			builder.Append (instruction.offset.ToString ("x4"));
+		}
+
+		public static Instruction Create (OpCode opcode)
+		{
+			if (opcode.OperandType != OperandType.InlineNone)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, null);
+		}
+
+		public static Instruction Create (OpCode opcode, TypeReference type)
+		{
+			if (type == null)
+				throw new ArgumentNullException ("type");
+			if (opcode.OperandType != OperandType.InlineType &&
+				opcode.OperandType != OperandType.InlineTok)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, type);
+		}
+
+		public static Instruction Create (OpCode opcode, CallSite site)
+		{
+			if (site == null)
+				throw new ArgumentNullException ("site");
+			if (opcode.Code != Code.Calli)
+				throw new ArgumentException ("code");
+
+			return new Instruction (opcode, site);
+		}
+
+		public static Instruction Create (OpCode opcode, MethodReference method)
+		{
+			if (method == null)
+				throw new ArgumentNullException ("method");
+			if (opcode.OperandType != OperandType.InlineMethod &&
+				opcode.OperandType != OperandType.InlineTok)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, method);
+		}
+
+		public static Instruction Create (OpCode opcode, FieldReference field)
+		{
+			if (field == null)
+				throw new ArgumentNullException ("field");
+			if (opcode.OperandType != OperandType.InlineField &&
+				opcode.OperandType != OperandType.InlineTok)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, field);
+		}
+
+		public static Instruction Create (OpCode opcode, string value)
+		{
+			if (value == null)
+				throw new ArgumentNullException ("value");
+			if (opcode.OperandType != OperandType.InlineString)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, sbyte value)
+		{
+			if (opcode.OperandType != OperandType.ShortInlineI &&
+				opcode != OpCodes.Ldc_I4_S)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, byte value)
+		{
+			if (opcode.OperandType != OperandType.ShortInlineI ||
+				opcode == OpCodes.Ldc_I4_S)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, int value)
+		{
+			if (opcode.OperandType != OperandType.InlineI)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, long value)
+		{
+			if (opcode.OperandType != OperandType.InlineI8)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, float value)
+		{
+			if (opcode.OperandType != OperandType.ShortInlineR)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, double value)
+		{
+			if (opcode.OperandType != OperandType.InlineR)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, Instruction target)
+		{
+			if (target == null)
+				throw new ArgumentNullException ("target");
+			if (opcode.OperandType != OperandType.InlineBrTarget &&
+				opcode.OperandType != OperandType.ShortInlineBrTarget)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, target);
+		}
+
+		public static Instruction Create (OpCode opcode, Instruction [] targets)
+		{
+			if (targets == null)
+				throw new ArgumentNullException ("targets");
+			if (opcode.OperandType != OperandType.InlineSwitch)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, targets);
+		}
+
+		public static Instruction Create (OpCode opcode, VariableDefinition variable)
+		{
+			if (variable == null)
+				throw new ArgumentNullException ("variable");
+			if (opcode.OperandType != OperandType.ShortInlineVar &&
+				opcode.OperandType != OperandType.InlineVar)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, variable);
+		}
+
+		public static Instruction Create (OpCode opcode, ParameterDefinition parameter)
+		{
+			if (parameter == null)
+				throw new ArgumentNullException ("parameter");
+			if (opcode.OperandType != OperandType.ShortInlineArg &&
+				opcode.OperandType != OperandType.InlineArg)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, parameter);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/MethodBody.cs b/src/Mono/Cecil/Cil/MethodBody.cs
new file mode 100644
index 00000000..eb8baf5b
--- /dev/null
+++ b/src/Mono/Cecil/Cil/MethodBody.cs
@@ -0,0 +1,248 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Threading;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil.Cil {
+
+	public sealed class MethodBody {
+
+		readonly internal MethodDefinition method;
+
+		internal ParameterDefinition this_parameter;
+		internal int max_stack_size;
+		internal int code_size;
+		internal bool init_locals;
+		internal MetadataToken local_var_token;
+
+		internal Collection<Instruction> instructions;
+		internal Collection<ExceptionHandler> exceptions;
+		internal Collection<VariableDefinition> variables;
+
+		public MethodDefinition Method {
+			get { return method; }
+		}
+
+		public int MaxStackSize {
+			get { return max_stack_size; }
+			set { max_stack_size = value; }
+		}
+
+		public int CodeSize {
+			get { return code_size; }
+		}
+
+		public bool InitLocals {
+			get { return init_locals; }
+			set { init_locals = value; }
+		}
+
+		public MetadataToken LocalVarToken {
+			get { return local_var_token; }
+			set { local_var_token = value; }
+		}
+
+		public Collection<Instruction> Instructions {
+			get { return instructions ?? (instructions = new InstructionCollection (method)); }
+		}
+
+		public bool HasExceptionHandlers {
+			get { return !exceptions.IsNullOrEmpty (); }
+		}
+
+		public Collection<ExceptionHandler> ExceptionHandlers {
+			get { return exceptions ?? (exceptions = new Collection<ExceptionHandler> ()); }
+		}
+
+		public bool HasVariables {
+			get { return !variables.IsNullOrEmpty (); }
+		}
+
+		public Collection<VariableDefinition> Variables {
+			get { return variables ?? (variables = new VariableDefinitionCollection ()); }
+		}
+
+		public ParameterDefinition ThisParameter {
+			get {
+				if (method == null || method.DeclaringType == null)
+					throw new NotSupportedException ();
+
+				if (!method.HasThis)
+					return null;
+
+				if (this_parameter == null)
+					Interlocked.CompareExchange (ref this_parameter, CreateThisParameter (method), null);
+
+				return this_parameter;
+			}
+		}
+
+		static ParameterDefinition CreateThisParameter (MethodDefinition method)
+		{
+			var parameter_type = method.DeclaringType as TypeReference;
+
+			if (parameter_type.HasGenericParameters) {
+				var instance = new GenericInstanceType (parameter_type);
+				for (int i = 0; i < parameter_type.GenericParameters.Count; i++)
+					instance.GenericArguments.Add (parameter_type.GenericParameters [i]);
+
+				parameter_type = instance;
+
+			}
+
+			if (parameter_type.IsValueType || parameter_type.IsPrimitive)
+				parameter_type = new ByReferenceType (parameter_type);
+
+			return new ParameterDefinition (parameter_type, method);
+		}
+
+		public MethodBody (MethodDefinition method)
+		{
+			this.method = method;
+		}
+
+		public ILProcessor GetILProcessor ()
+		{
+			return new ILProcessor (this);
+		}
+	}
+
+	sealed class VariableDefinitionCollection : Collection<VariableDefinition> {
+
+		internal VariableDefinitionCollection ()
+		{
+		}
+
+		internal VariableDefinitionCollection (int capacity)
+			: base (capacity)
+		{
+		}
+
+		protected override void OnAdd (VariableDefinition item, int index)
+		{
+			item.index = index;
+		}
+
+		protected override void OnInsert (VariableDefinition item, int index)
+		{
+			item.index = index;
+
+			for (int i = index; i < size; i++)
+				items [i].index = i + 1;
+		}
+
+		protected override void OnSet (VariableDefinition item, int index)
+		{
+			item.index = index;
+		}
+
+		protected override void OnRemove (VariableDefinition item, int index)
+		{
+			item.index = -1;
+
+			for (int i = index + 1; i < size; i++)
+				items [i].index = i - 1;
+		}
+	}
+
+	class InstructionCollection : Collection<Instruction> {
+
+		readonly MethodDefinition method;
+
+		internal InstructionCollection (MethodDefinition method)
+		{
+			this.method = method;
+		}
+
+		internal InstructionCollection (MethodDefinition method, int capacity)
+			: base (capacity)
+		{
+			this.method = method;
+		}
+
+		protected override void OnAdd (Instruction item, int index)
+		{
+			if (index == 0)
+				return;
+
+			var previous = items [index - 1];
+			previous.next = item;
+			item.previous = previous;
+		}
+
+		protected override void OnInsert (Instruction item, int index)
+		{
+			if (size == 0)
+				return;
+
+			var current = items [index];
+			if (current == null) {
+				var last = items [index - 1];
+				last.next = item;
+				item.previous = last;
+				return;
+			}
+
+			var previous = current.previous;
+			if (previous != null) {
+				previous.next = item;
+				item.previous = previous;
+			}
+
+			current.previous = item;
+			item.next = current;
+		}
+
+		protected override void OnSet (Instruction item, int index)
+		{
+			var current = items [index];
+
+			item.previous = current.previous;
+			item.next = current.next;
+
+			current.previous = null;
+			current.next = null;
+		}
+
+		protected override void OnRemove (Instruction item, int index)
+		{
+			var previous = item.previous;
+			if (previous != null)
+				previous.next = item.next;
+
+			var next = item.next;
+			if (next != null)
+				next.previous = item.previous;
+
+			RemoveSequencePoint (item);
+
+			item.previous = null;
+			item.next = null;
+		}
+
+		void RemoveSequencePoint (Instruction instruction)
+		{
+			var debug_info = method.debug_info;
+			if (debug_info == null || !debug_info.HasSequencePoints)
+				return;
+
+			var sequence_points = debug_info.sequence_points;
+			for (int i = 0; i < sequence_points.Count; i++) {
+				if (sequence_points [i].Offset == instruction.offset) {
+					sequence_points.RemoveAt (i);
+					return;
+				}
+			}
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/OpCode.cs b/src/Mono/Cecil/Cil/OpCode.cs
new file mode 100644
index 00000000..81ab0e12
--- /dev/null
+++ b/src/Mono/Cecil/Cil/OpCode.cs
@@ -0,0 +1,439 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil.Cil {
+
+	public enum FlowControl {
+		Branch,
+		Break,
+		Call,
+		Cond_Branch,
+		Meta,
+		Next,
+		Phi,
+		Return,
+		Throw,
+	}
+
+	public enum OpCodeType {
+		Annotation,
+		Macro,
+		Nternal,
+		Objmodel,
+		Prefix,
+		Primitive,
+	}
+
+	public enum OperandType {
+		InlineBrTarget,
+		InlineField,
+		InlineI,
+		InlineI8,
+		InlineMethod,
+		InlineNone,
+		InlinePhi,
+		InlineR,
+		InlineSig,
+		InlineString,
+		InlineSwitch,
+		InlineTok,
+		InlineType,
+		InlineVar,
+		InlineArg,
+		ShortInlineBrTarget,
+		ShortInlineI,
+		ShortInlineR,
+		ShortInlineVar,
+		ShortInlineArg,
+	}
+
+	public enum StackBehaviour {
+		Pop0,
+		Pop1,
+		Pop1_pop1,
+		Popi,
+		Popi_pop1,
+		Popi_popi,
+		Popi_popi8,
+		Popi_popi_popi,
+		Popi_popr4,
+		Popi_popr8,
+		Popref,
+		Popref_pop1,
+		Popref_popi,
+		Popref_popi_popi,
+		Popref_popi_popi8,
+		Popref_popi_popr4,
+		Popref_popi_popr8,
+		Popref_popi_popref,
+		PopAll,
+		Push0,
+		Push1,
+		Push1_push1,
+		Pushi,
+		Pushi8,
+		Pushr4,
+		Pushr8,
+		Pushref,
+		Varpop,
+		Varpush,
+	}
+
+	public struct OpCode : IEquatable<OpCode> {
+
+		readonly byte op1;
+		readonly byte op2;
+		readonly byte code;
+		readonly byte flow_control;
+		readonly byte opcode_type;
+		readonly byte operand_type;
+		readonly byte stack_behavior_pop;
+		readonly byte stack_behavior_push;
+
+		public string Name {
+			get { return OpCodeNames.names [(int) Code]; }
+		}
+
+		public int Size {
+			get { return op1 == 0xff ? 1 : 2; }
+		}
+
+		public byte Op1 {
+			get { return op1; }
+		}
+
+		public byte Op2 {
+			get { return op2; }
+		}
+
+		public short Value {
+			get { return op1 == 0xff ? op2 : (short) ((op1 << 8) | op2); }
+		}
+
+		public Code Code {
+			get { return (Code) code; }
+		}
+
+		public FlowControl FlowControl {
+			get { return (FlowControl) flow_control; }
+		}
+
+		public OpCodeType OpCodeType {
+			get { return (OpCodeType) opcode_type; }
+		}
+
+		public OperandType OperandType {
+			get { return (OperandType) operand_type; }
+		}
+
+		public StackBehaviour StackBehaviourPop {
+			get { return (StackBehaviour) stack_behavior_pop; }
+		}
+
+		public StackBehaviour StackBehaviourPush {
+			get { return (StackBehaviour) stack_behavior_push; }
+		}
+
+		internal OpCode (int x, int y)
+		{
+			this.op1 = (byte) ((x >> 0) & 0xff);
+			this.op2 = (byte) ((x >> 8) & 0xff);
+			this.code = (byte) ((x >> 16) & 0xff);
+			this.flow_control = (byte) ((x >> 24) & 0xff);
+
+			this.opcode_type = (byte) ((y >> 0) & 0xff);
+			this.operand_type = (byte) ((y >> 8) & 0xff);
+			this.stack_behavior_pop = (byte) ((y >> 16) & 0xff);
+			this.stack_behavior_push = (byte) ((y >> 24) & 0xff);
+
+			if (op1 == 0xff)
+				OpCodes.OneByteOpCode [op2] = this;
+			else
+				OpCodes.TwoBytesOpCode [op2] = this;
+		}
+
+		public override int GetHashCode ()
+		{
+			return Value;
+		}
+
+		public override bool Equals (object obj)
+		{
+			if (!(obj is OpCode))
+				return false;
+
+			var opcode = (OpCode) obj;
+			return op1 == opcode.op1 && op2 == opcode.op2;
+		}
+
+		public bool Equals (OpCode opcode)
+		{
+			return op1 == opcode.op1 && op2 == opcode.op2;
+		}
+
+		public static bool operator == (OpCode one, OpCode other)
+		{
+			return one.op1 == other.op1 && one.op2 == other.op2;
+		}
+
+		public static bool operator != (OpCode one, OpCode other)
+		{
+			return one.op1 != other.op1 || one.op2 != other.op2;
+		}
+
+		public override string ToString ()
+		{
+			return Name;
+		}
+	}
+
+	static class OpCodeNames {
+
+		internal static readonly string [] names;
+
+		static OpCodeNames ()
+		{
+			var table = new byte [] {
+				3, 110, 111, 112,
+				5, 98, 114, 101, 97, 107,
+				7, 108, 100, 97, 114, 103, 46, 48,
+				7, 108, 100, 97, 114, 103, 46, 49,
+				7, 108, 100, 97, 114, 103, 46, 50,
+				7, 108, 100, 97, 114, 103, 46, 51,
+				7, 108, 100, 108, 111, 99, 46, 48,
+				7, 108, 100, 108, 111, 99, 46, 49,
+				7, 108, 100, 108, 111, 99, 46, 50,
+				7, 108, 100, 108, 111, 99, 46, 51,
+				7, 115, 116, 108, 111, 99, 46, 48,
+				7, 115, 116, 108, 111, 99, 46, 49,
+				7, 115, 116, 108, 111, 99, 46, 50,
+				7, 115, 116, 108, 111, 99, 46, 51,
+				7, 108, 100, 97, 114, 103, 46, 115,
+				8, 108, 100, 97, 114, 103, 97, 46, 115,
+				7, 115, 116, 97, 114, 103, 46, 115,
+				7, 108, 100, 108, 111, 99, 46, 115,
+				8, 108, 100, 108, 111, 99, 97, 46, 115,
+				7, 115, 116, 108, 111, 99, 46, 115,
+				6, 108, 100, 110, 117, 108, 108,
+				9, 108, 100, 99, 46, 105, 52, 46, 109, 49,
+				8, 108, 100, 99, 46, 105, 52, 46, 48,
+				8, 108, 100, 99, 46, 105, 52, 46, 49,
+				8, 108, 100, 99, 46, 105, 52, 46, 50,
+				8, 108, 100, 99, 46, 105, 52, 46, 51,
+				8, 108, 100, 99, 46, 105, 52, 46, 52,
+				8, 108, 100, 99, 46, 105, 52, 46, 53,
+				8, 108, 100, 99, 46, 105, 52, 46, 54,
+				8, 108, 100, 99, 46, 105, 52, 46, 55,
+				8, 108, 100, 99, 46, 105, 52, 46, 56,
+				8, 108, 100, 99, 46, 105, 52, 46, 115,
+				6, 108, 100, 99, 46, 105, 52,
+				6, 108, 100, 99, 46, 105, 56,
+				6, 108, 100, 99, 46, 114, 52,
+				6, 108, 100, 99, 46, 114, 56,
+				3, 100, 117, 112,
+				3, 112, 111, 112,
+				3, 106, 109, 112,
+				4, 99, 97, 108, 108,
+				5, 99, 97, 108, 108, 105,
+				3, 114, 101, 116,
+				4, 98, 114, 46, 115,
+				9, 98, 114, 102, 97, 108, 115, 101, 46, 115,
+				8, 98, 114, 116, 114, 117, 101, 46, 115,
+				5, 98, 101, 113, 46, 115,
+				5, 98, 103, 101, 46, 115,
+				5, 98, 103, 116, 46, 115,
+				5, 98, 108, 101, 46, 115,
+				5, 98, 108, 116, 46, 115,
+				8, 98, 110, 101, 46, 117, 110, 46, 115,
+				8, 98, 103, 101, 46, 117, 110, 46, 115,
+				8, 98, 103, 116, 46, 117, 110, 46, 115,
+				8, 98, 108, 101, 46, 117, 110, 46, 115,
+				8, 98, 108, 116, 46, 117, 110, 46, 115,
+				2, 98, 114,
+				7, 98, 114, 102, 97, 108, 115, 101,
+				6, 98, 114, 116, 114, 117, 101,
+				3, 98, 101, 113,
+				3, 98, 103, 101,
+				3, 98, 103, 116,
+				3, 98, 108, 101,
+				3, 98, 108, 116,
+				6, 98, 110, 101, 46, 117, 110,
+				6, 98, 103, 101, 46, 117, 110,
+				6, 98, 103, 116, 46, 117, 110,
+				6, 98, 108, 101, 46, 117, 110,
+				6, 98, 108, 116, 46, 117, 110,
+				6, 115, 119, 105, 116, 99, 104,
+				8, 108, 100, 105, 110, 100, 46, 105, 49,
+				8, 108, 100, 105, 110, 100, 46, 117, 49,
+				8, 108, 100, 105, 110, 100, 46, 105, 50,
+				8, 108, 100, 105, 110, 100, 46, 117, 50,
+				8, 108, 100, 105, 110, 100, 46, 105, 52,
+				8, 108, 100, 105, 110, 100, 46, 117, 52,
+				8, 108, 100, 105, 110, 100, 46, 105, 56,
+				7, 108, 100, 105, 110, 100, 46, 105,
+				8, 108, 100, 105, 110, 100, 46, 114, 52,
+				8, 108, 100, 105, 110, 100, 46, 114, 56,
+				9, 108, 100, 105, 110, 100, 46, 114, 101, 102,
+				9, 115, 116, 105, 110, 100, 46, 114, 101, 102,
+				8, 115, 116, 105, 110, 100, 46, 105, 49,
+				8, 115, 116, 105, 110, 100, 46, 105, 50,
+				8, 115, 116, 105, 110, 100, 46, 105, 52,
+				8, 115, 116, 105, 110, 100, 46, 105, 56,
+				8, 115, 116, 105, 110, 100, 46, 114, 52,
+				8, 115, 116, 105, 110, 100, 46, 114, 56,
+				3, 97, 100, 100,
+				3, 115, 117, 98,
+				3, 109, 117, 108,
+				3, 100, 105, 118,
+				6, 100, 105, 118, 46, 117, 110,
+				3, 114, 101, 109,
+				6, 114, 101, 109, 46, 117, 110,
+				3, 97, 110, 100,
+				2, 111, 114,
+				3, 120, 111, 114,
+				3, 115, 104, 108,
+				3, 115, 104, 114,
+				6, 115, 104, 114, 46, 117, 110,
+				3, 110, 101, 103,
+				3, 110, 111, 116,
+				7, 99, 111, 110, 118, 46, 105, 49,
+				7, 99, 111, 110, 118, 46, 105, 50,
+				7, 99, 111, 110, 118, 46, 105, 52,
+				7, 99, 111, 110, 118, 46, 105, 56,
+				7, 99, 111, 110, 118, 46, 114, 52,
+				7, 99, 111, 110, 118, 46, 114, 56,
+				7, 99, 111, 110, 118, 46, 117, 52,
+				7, 99, 111, 110, 118, 46, 117, 56,
+				8, 99, 97, 108, 108, 118, 105, 114, 116,
+				5, 99, 112, 111, 98, 106,
+				5, 108, 100, 111, 98, 106,
+				5, 108, 100, 115, 116, 114,
+				6, 110, 101, 119, 111, 98, 106,
+				9, 99, 97, 115, 116, 99, 108, 97, 115, 115,
+				6, 105, 115, 105, 110, 115, 116,
+				9, 99, 111, 110, 118, 46, 114, 46, 117, 110,
+				5, 117, 110, 98, 111, 120,
+				5, 116, 104, 114, 111, 119,
+				5, 108, 100, 102, 108, 100,
+				6, 108, 100, 102, 108, 100, 97,
+				5, 115, 116, 102, 108, 100,
+				6, 108, 100, 115, 102, 108, 100,
+				7, 108, 100, 115, 102, 108, 100, 97,
+				6, 115, 116, 115, 102, 108, 100,
+				5, 115, 116, 111, 98, 106,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 49, 46, 117, 110,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 50, 46, 117, 110,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 52, 46, 117, 110,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 56, 46, 117, 110,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 49, 46, 117, 110,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 50, 46, 117, 110,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 52, 46, 117, 110,
+				14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 56, 46, 117, 110,
+				13, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 46, 117, 110,
+				13, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 46, 117, 110,
+				3, 98, 111, 120,
+				6, 110, 101, 119, 97, 114, 114,
+				5, 108, 100, 108, 101, 110,
+				7, 108, 100, 101, 108, 101, 109, 97,
+				9, 108, 100, 101, 108, 101, 109, 46, 105, 49,
+				9, 108, 100, 101, 108, 101, 109, 46, 117, 49,
+				9, 108, 100, 101, 108, 101, 109, 46, 105, 50,
+				9, 108, 100, 101, 108, 101, 109, 46, 117, 50,
+				9, 108, 100, 101, 108, 101, 109, 46, 105, 52,
+				9, 108, 100, 101, 108, 101, 109, 46, 117, 52,
+				9, 108, 100, 101, 108, 101, 109, 46, 105, 56,
+				8, 108, 100, 101, 108, 101, 109, 46, 105,
+				9, 108, 100, 101, 108, 101, 109, 46, 114, 52,
+				9, 108, 100, 101, 108, 101, 109, 46, 114, 56,
+				10, 108, 100, 101, 108, 101, 109, 46, 114, 101, 102,
+				8, 115, 116, 101, 108, 101, 109, 46, 105,
+				9, 115, 116, 101, 108, 101, 109, 46, 105, 49,
+				9, 115, 116, 101, 108, 101, 109, 46, 105, 50,
+				9, 115, 116, 101, 108, 101, 109, 46, 105, 52,
+				9, 115, 116, 101, 108, 101, 109, 46, 105, 56,
+				9, 115, 116, 101, 108, 101, 109, 46, 114, 52,
+				9, 115, 116, 101, 108, 101, 109, 46, 114, 56,
+				10, 115, 116, 101, 108, 101, 109, 46, 114, 101, 102,
+				10, 108, 100, 101, 108, 101, 109, 46, 97, 110, 121,
+				10, 115, 116, 101, 108, 101, 109, 46, 97, 110, 121,
+				9, 117, 110, 98, 111, 120, 46, 97, 110, 121,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 49,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 49,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 50,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 50,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 52,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 52,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 56,
+				11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 56,
+				9, 114, 101, 102, 97, 110, 121, 118, 97, 108,
+				8, 99, 107, 102, 105, 110, 105, 116, 101,
+				8, 109, 107, 114, 101, 102, 97, 110, 121,
+				7, 108, 100, 116, 111, 107, 101, 110,
+				7, 99, 111, 110, 118, 46, 117, 50,
+				7, 99, 111, 110, 118, 46, 117, 49,
+				6, 99, 111, 110, 118, 46, 105,
+				10, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105,
+				10, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117,
+				7, 97, 100, 100, 46, 111, 118, 102,
+				10, 97, 100, 100, 46, 111, 118, 102, 46, 117, 110,
+				7, 109, 117, 108, 46, 111, 118, 102,
+				10, 109, 117, 108, 46, 111, 118, 102, 46, 117, 110,
+				7, 115, 117, 98, 46, 111, 118, 102,
+				10, 115, 117, 98, 46, 111, 118, 102, 46, 117, 110,
+				10, 101, 110, 100, 102, 105, 110, 97, 108, 108, 121,
+				5, 108, 101, 97, 118, 101,
+				7, 108, 101, 97, 118, 101, 46, 115,
+				7, 115, 116, 105, 110, 100, 46, 105,
+				6, 99, 111, 110, 118, 46, 117,
+				7, 97, 114, 103, 108, 105, 115, 116,
+				3, 99, 101, 113,
+				3, 99, 103, 116,
+				6, 99, 103, 116, 46, 117, 110,
+				3, 99, 108, 116,
+				6, 99, 108, 116, 46, 117, 110,
+				5, 108, 100, 102, 116, 110,
+				9, 108, 100, 118, 105, 114, 116, 102, 116, 110,
+				5, 108, 100, 97, 114, 103,
+				6, 108, 100, 97, 114, 103, 97,
+				5, 115, 116, 97, 114, 103,
+				5, 108, 100, 108, 111, 99,
+				6, 108, 100, 108, 111, 99, 97,
+				5, 115, 116, 108, 111, 99,
+				8, 108, 111, 99, 97, 108, 108, 111, 99,
+				9, 101, 110, 100, 102, 105, 108, 116, 101, 114,
+				10, 117, 110, 97, 108, 105, 103, 110, 101, 100, 46,
+				9, 118, 111, 108, 97, 116, 105, 108, 101, 46,
+				5, 116, 97, 105, 108, 46,
+				7, 105, 110, 105, 116, 111, 98, 106,
+				12, 99, 111, 110, 115, 116, 114, 97, 105, 110, 101, 100, 46,
+				5, 99, 112, 98, 108, 107,
+				7, 105, 110, 105, 116, 98, 108, 107,
+				3, 110, 111, 46,
+				7, 114, 101, 116, 104, 114, 111, 119,
+				6, 115, 105, 122, 101, 111, 102,
+				10, 114, 101, 102, 97, 110, 121, 116, 121, 112, 101,
+				9, 114, 101, 97, 100, 111, 110, 108, 121, 46,
+			};
+
+			names = new string [219];
+
+			for (int i = 0, p = 0; i < names.Length; i++) {
+				var buffer = new char [table [p++]];
+
+				for (int j = 0; j < buffer.Length; j++)
+					buffer [j] = (char) table [p++];
+
+				names [i] = new string (buffer);
+			}
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/OpCodes.cs b/src/Mono/Cecil/Cil/OpCodes.cs
new file mode 100644
index 00000000..ba0468d3
--- /dev/null
+++ b/src/Mono/Cecil/Cil/OpCodes.cs
@@ -0,0 +1,894 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Cil {
+
+	public static class OpCodes {
+
+		internal static readonly OpCode [] OneByteOpCode = new OpCode [0xe0 + 1];
+		internal static readonly OpCode [] TwoBytesOpCode = new OpCode [0x1e + 1];
+
+		public static readonly OpCode Nop = new OpCode (
+			0xff << 0 | 0x00 << 8 | (byte) Code.Nop << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Break = new OpCode (
+			0xff << 0 | 0x01 << 8 | (byte) Code.Break << 16 | (byte) FlowControl.Break << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldarg_0 = new OpCode (
+			0xff << 0 | 0x02 << 8 | (byte) Code.Ldarg_0 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldarg_1 = new OpCode (
+			0xff << 0 | 0x03 << 8 | (byte) Code.Ldarg_1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldarg_2 = new OpCode (
+			0xff << 0 | 0x04 << 8 | (byte) Code.Ldarg_2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldarg_3 = new OpCode (
+			0xff << 0 | 0x05 << 8 | (byte) Code.Ldarg_3 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldloc_0 = new OpCode (
+			0xff << 0 | 0x06 << 8 | (byte) Code.Ldloc_0 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldloc_1 = new OpCode (
+			0xff << 0 | 0x07 << 8 | (byte) Code.Ldloc_1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldloc_2 = new OpCode (
+			0xff << 0 | 0x08 << 8 | (byte) Code.Ldloc_2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldloc_3 = new OpCode (
+			0xff << 0 | 0x09 << 8 | (byte) Code.Ldloc_3 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Stloc_0 = new OpCode (
+			0xff << 0 | 0x0a << 8 | (byte) Code.Stloc_0 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stloc_1 = new OpCode (
+			0xff << 0 | 0x0b << 8 | (byte) Code.Stloc_1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stloc_2 = new OpCode (
+			0xff << 0 | 0x0c << 8 | (byte) Code.Stloc_2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stloc_3 = new OpCode (
+			0xff << 0 | 0x0d << 8 | (byte) Code.Stloc_3 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldarg_S = new OpCode (
+			0xff << 0 | 0x0e << 8 | (byte) Code.Ldarg_S << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineArg << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldarga_S = new OpCode (
+			0xff << 0 | 0x0f << 8 | (byte) Code.Ldarga_S << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineArg << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Starg_S = new OpCode (
+			0xff << 0 | 0x10 << 8 | (byte) Code.Starg_S << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineArg << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldloc_S = new OpCode (
+			0xff << 0 | 0x11 << 8 | (byte) Code.Ldloc_S << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineVar << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldloca_S = new OpCode (
+			0xff << 0 | 0x12 << 8 | (byte) Code.Ldloca_S << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineVar << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Stloc_S = new OpCode (
+			0xff << 0 | 0x13 << 8 | (byte) Code.Stloc_S << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineVar << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldnull = new OpCode (
+			0xff << 0 | 0x14 << 8 | (byte) Code.Ldnull << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Ldc_I4_M1 = new OpCode (
+			0xff << 0 | 0x15 << 8 | (byte) Code.Ldc_I4_M1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_0 = new OpCode (
+			0xff << 0 | 0x16 << 8 | (byte) Code.Ldc_I4_0 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_1 = new OpCode (
+			0xff << 0 | 0x17 << 8 | (byte) Code.Ldc_I4_1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_2 = new OpCode (
+			0xff << 0 | 0x18 << 8 | (byte) Code.Ldc_I4_2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_3 = new OpCode (
+			0xff << 0 | 0x19 << 8 | (byte) Code.Ldc_I4_3 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_4 = new OpCode (
+			0xff << 0 | 0x1a << 8 | (byte) Code.Ldc_I4_4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_5 = new OpCode (
+			0xff << 0 | 0x1b << 8 | (byte) Code.Ldc_I4_5 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_6 = new OpCode (
+			0xff << 0 | 0x1c << 8 | (byte) Code.Ldc_I4_6 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_7 = new OpCode (
+			0xff << 0 | 0x1d << 8 | (byte) Code.Ldc_I4_7 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_8 = new OpCode (
+			0xff << 0 | 0x1e << 8 | (byte) Code.Ldc_I4_8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4_S = new OpCode (
+			0xff << 0 | 0x1f << 8 | (byte) Code.Ldc_I4_S << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineI << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I4 = new OpCode (
+			0xff << 0 | 0x20 << 8 | (byte) Code.Ldc_I4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineI << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldc_I8 = new OpCode (
+			0xff << 0 | 0x21 << 8 | (byte) Code.Ldc_I8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineI8 << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Ldc_R4 = new OpCode (
+			0xff << 0 | 0x22 << 8 | (byte) Code.Ldc_R4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.ShortInlineR << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushr4 << 24);
+
+		public static readonly OpCode Ldc_R8 = new OpCode (
+			0xff << 0 | 0x23 << 8 | (byte) Code.Ldc_R8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineR << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushr8 << 24);
+
+		public static readonly OpCode Dup = new OpCode (
+			0xff << 0 | 0x25 << 8 | (byte) Code.Dup << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push1_push1 << 24);
+
+		public static readonly OpCode Pop = new OpCode (
+			0xff << 0 | 0x26 << 8 | (byte) Code.Pop << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Jmp = new OpCode (
+			0xff << 0 | 0x27 << 8 | (byte) Code.Jmp << 16 | (byte) FlowControl.Call << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineMethod << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Call = new OpCode (
+			0xff << 0 | 0x28 << 8 | (byte) Code.Call << 16 | (byte) FlowControl.Call << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineMethod << 8 | (byte) StackBehaviour.Varpop << 16 | (byte) StackBehaviour.Varpush << 24);
+
+		public static readonly OpCode Calli = new OpCode (
+			0xff << 0 | 0x29 << 8 | (byte) Code.Calli << 16 | (byte) FlowControl.Call << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineSig << 8 | (byte) StackBehaviour.Varpop << 16 | (byte) StackBehaviour.Varpush << 24);
+
+		public static readonly OpCode Ret = new OpCode (
+			0xff << 0 | 0x2a << 8 | (byte) Code.Ret << 16 | (byte) FlowControl.Return << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Varpop << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Br_S = new OpCode (
+			0xff << 0 | 0x2b << 8 | (byte) Code.Br_S << 16 | (byte) FlowControl.Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Brfalse_S = new OpCode (
+			0xff << 0 | 0x2c << 8 | (byte) Code.Brfalse_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Brtrue_S = new OpCode (
+			0xff << 0 | 0x2d << 8 | (byte) Code.Brtrue_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Beq_S = new OpCode (
+			0xff << 0 | 0x2e << 8 | (byte) Code.Beq_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bge_S = new OpCode (
+			0xff << 0 | 0x2f << 8 | (byte) Code.Bge_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bgt_S = new OpCode (
+			0xff << 0 | 0x30 << 8 | (byte) Code.Bgt_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ble_S = new OpCode (
+			0xff << 0 | 0x31 << 8 | (byte) Code.Ble_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Blt_S = new OpCode (
+			0xff << 0 | 0x32 << 8 | (byte) Code.Blt_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bne_Un_S = new OpCode (
+			0xff << 0 | 0x33 << 8 | (byte) Code.Bne_Un_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bge_Un_S = new OpCode (
+			0xff << 0 | 0x34 << 8 | (byte) Code.Bge_Un_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bgt_Un_S = new OpCode (
+			0xff << 0 | 0x35 << 8 | (byte) Code.Bgt_Un_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ble_Un_S = new OpCode (
+			0xff << 0 | 0x36 << 8 | (byte) Code.Ble_Un_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Blt_Un_S = new OpCode (
+			0xff << 0 | 0x37 << 8 | (byte) Code.Blt_Un_S << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Br = new OpCode (
+			0xff << 0 | 0x38 << 8 | (byte) Code.Br << 16 | (byte) FlowControl.Branch << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Brfalse = new OpCode (
+			0xff << 0 | 0x39 << 8 | (byte) Code.Brfalse << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Brtrue = new OpCode (
+			0xff << 0 | 0x3a << 8 | (byte) Code.Brtrue << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Beq = new OpCode (
+			0xff << 0 | 0x3b << 8 | (byte) Code.Beq << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bge = new OpCode (
+			0xff << 0 | 0x3c << 8 | (byte) Code.Bge << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bgt = new OpCode (
+			0xff << 0 | 0x3d << 8 | (byte) Code.Bgt << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ble = new OpCode (
+			0xff << 0 | 0x3e << 8 | (byte) Code.Ble << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Blt = new OpCode (
+			0xff << 0 | 0x3f << 8 | (byte) Code.Blt << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bne_Un = new OpCode (
+			0xff << 0 | 0x40 << 8 | (byte) Code.Bne_Un << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bge_Un = new OpCode (
+			0xff << 0 | 0x41 << 8 | (byte) Code.Bge_Un << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Bgt_Un = new OpCode (
+			0xff << 0 | 0x42 << 8 | (byte) Code.Bgt_Un << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ble_Un = new OpCode (
+			0xff << 0 | 0x43 << 8 | (byte) Code.Ble_Un << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Blt_Un = new OpCode (
+			0xff << 0 | 0x44 << 8 | (byte) Code.Blt_Un << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Switch = new OpCode (
+			0xff << 0 | 0x45 << 8 | (byte) Code.Switch << 16 | (byte) FlowControl.Cond_Branch << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineSwitch << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldind_I1 = new OpCode (
+			0xff << 0 | 0x46 << 8 | (byte) Code.Ldind_I1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldind_U1 = new OpCode (
+			0xff << 0 | 0x47 << 8 | (byte) Code.Ldind_U1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldind_I2 = new OpCode (
+			0xff << 0 | 0x48 << 8 | (byte) Code.Ldind_I2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldind_U2 = new OpCode (
+			0xff << 0 | 0x49 << 8 | (byte) Code.Ldind_U2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldind_I4 = new OpCode (
+			0xff << 0 | 0x4a << 8 | (byte) Code.Ldind_I4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldind_U4 = new OpCode (
+			0xff << 0 | 0x4b << 8 | (byte) Code.Ldind_U4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldind_I8 = new OpCode (
+			0xff << 0 | 0x4c << 8 | (byte) Code.Ldind_I8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Ldind_I = new OpCode (
+			0xff << 0 | 0x4d << 8 | (byte) Code.Ldind_I << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldind_R4 = new OpCode (
+			0xff << 0 | 0x4e << 8 | (byte) Code.Ldind_R4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushr4 << 24);
+
+		public static readonly OpCode Ldind_R8 = new OpCode (
+			0xff << 0 | 0x4f << 8 | (byte) Code.Ldind_R8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushr8 << 24);
+
+		public static readonly OpCode Ldind_Ref = new OpCode (
+			0xff << 0 | 0x50 << 8 | (byte) Code.Ldind_Ref << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Stind_Ref = new OpCode (
+			0xff << 0 | 0x51 << 8 | (byte) Code.Stind_Ref << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stind_I1 = new OpCode (
+			0xff << 0 | 0x52 << 8 | (byte) Code.Stind_I1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stind_I2 = new OpCode (
+			0xff << 0 | 0x53 << 8 | (byte) Code.Stind_I2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stind_I4 = new OpCode (
+			0xff << 0 | 0x54 << 8 | (byte) Code.Stind_I4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stind_I8 = new OpCode (
+			0xff << 0 | 0x55 << 8 | (byte) Code.Stind_I8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi8 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stind_R4 = new OpCode (
+			0xff << 0 | 0x56 << 8 | (byte) Code.Stind_R4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popr4 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stind_R8 = new OpCode (
+			0xff << 0 | 0x57 << 8 | (byte) Code.Stind_R8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popr8 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Add = new OpCode (
+			0xff << 0 | 0x58 << 8 | (byte) Code.Add << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Sub = new OpCode (
+			0xff << 0 | 0x59 << 8 | (byte) Code.Sub << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Mul = new OpCode (
+			0xff << 0 | 0x5a << 8 | (byte) Code.Mul << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Div = new OpCode (
+			0xff << 0 | 0x5b << 8 | (byte) Code.Div << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Div_Un = new OpCode (
+			0xff << 0 | 0x5c << 8 | (byte) Code.Div_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Rem = new OpCode (
+			0xff << 0 | 0x5d << 8 | (byte) Code.Rem << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Rem_Un = new OpCode (
+			0xff << 0 | 0x5e << 8 | (byte) Code.Rem_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode And = new OpCode (
+			0xff << 0 | 0x5f << 8 | (byte) Code.And << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Or = new OpCode (
+			0xff << 0 | 0x60 << 8 | (byte) Code.Or << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Xor = new OpCode (
+			0xff << 0 | 0x61 << 8 | (byte) Code.Xor << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Shl = new OpCode (
+			0xff << 0 | 0x62 << 8 | (byte) Code.Shl << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Shr = new OpCode (
+			0xff << 0 | 0x63 << 8 | (byte) Code.Shr << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Shr_Un = new OpCode (
+			0xff << 0 | 0x64 << 8 | (byte) Code.Shr_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Neg = new OpCode (
+			0xff << 0 | 0x65 << 8 | (byte) Code.Neg << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Not = new OpCode (
+			0xff << 0 | 0x66 << 8 | (byte) Code.Not << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Conv_I1 = new OpCode (
+			0xff << 0 | 0x67 << 8 | (byte) Code.Conv_I1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_I2 = new OpCode (
+			0xff << 0 | 0x68 << 8 | (byte) Code.Conv_I2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_I4 = new OpCode (
+			0xff << 0 | 0x69 << 8 | (byte) Code.Conv_I4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_I8 = new OpCode (
+			0xff << 0 | 0x6a << 8 | (byte) Code.Conv_I8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Conv_R4 = new OpCode (
+			0xff << 0 | 0x6b << 8 | (byte) Code.Conv_R4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushr4 << 24);
+
+		public static readonly OpCode Conv_R8 = new OpCode (
+			0xff << 0 | 0x6c << 8 | (byte) Code.Conv_R8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushr8 << 24);
+
+		public static readonly OpCode Conv_U4 = new OpCode (
+			0xff << 0 | 0x6d << 8 | (byte) Code.Conv_U4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_U8 = new OpCode (
+			0xff << 0 | 0x6e << 8 | (byte) Code.Conv_U8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Callvirt = new OpCode (
+			0xff << 0 | 0x6f << 8 | (byte) Code.Callvirt << 16 | (byte) FlowControl.Call << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineMethod << 8 | (byte) StackBehaviour.Varpop << 16 | (byte) StackBehaviour.Varpush << 24);
+
+		public static readonly OpCode Cpobj = new OpCode (
+			0xff << 0 | 0x70 << 8 | (byte) Code.Cpobj << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldobj = new OpCode (
+			0xff << 0 | 0x71 << 8 | (byte) Code.Ldobj << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldstr = new OpCode (
+			0xff << 0 | 0x72 << 8 | (byte) Code.Ldstr << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineString << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Newobj = new OpCode (
+			0xff << 0 | 0x73 << 8 | (byte) Code.Newobj << 16 | (byte) FlowControl.Call << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineMethod << 8 | (byte) StackBehaviour.Varpop << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Castclass = new OpCode (
+			0xff << 0 | 0x74 << 8 | (byte) Code.Castclass << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Isinst = new OpCode (
+			0xff << 0 | 0x75 << 8 | (byte) Code.Isinst << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_R_Un = new OpCode (
+			0xff << 0 | 0x76 << 8 | (byte) Code.Conv_R_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushr8 << 24);
+
+		public static readonly OpCode Unbox = new OpCode (
+			0xff << 0 | 0x79 << 8 | (byte) Code.Unbox << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Throw = new OpCode (
+			0xff << 0 | 0x7a << 8 | (byte) Code.Throw << 16 | (byte) FlowControl.Throw << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldfld = new OpCode (
+			0xff << 0 | 0x7b << 8 | (byte) Code.Ldfld << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineField << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldflda = new OpCode (
+			0xff << 0 | 0x7c << 8 | (byte) Code.Ldflda << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineField << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Stfld = new OpCode (
+			0xff << 0 | 0x7d << 8 | (byte) Code.Stfld << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineField << 8 | (byte) StackBehaviour.Popref_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldsfld = new OpCode (
+			0xff << 0 | 0x7e << 8 | (byte) Code.Ldsfld << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineField << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldsflda = new OpCode (
+			0xff << 0 | 0x7f << 8 | (byte) Code.Ldsflda << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineField << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Stsfld = new OpCode (
+			0xff << 0 | 0x80 << 8 | (byte) Code.Stsfld << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineField << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stobj = new OpCode (
+			0xff << 0 | 0x81 << 8 | (byte) Code.Stobj << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popi_pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Conv_Ovf_I1_Un = new OpCode (
+			0xff << 0 | 0x82 << 8 | (byte) Code.Conv_Ovf_I1_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_I2_Un = new OpCode (
+			0xff << 0 | 0x83 << 8 | (byte) Code.Conv_Ovf_I2_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_I4_Un = new OpCode (
+			0xff << 0 | 0x84 << 8 | (byte) Code.Conv_Ovf_I4_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_I8_Un = new OpCode (
+			0xff << 0 | 0x85 << 8 | (byte) Code.Conv_Ovf_I8_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Conv_Ovf_U1_Un = new OpCode (
+			0xff << 0 | 0x86 << 8 | (byte) Code.Conv_Ovf_U1_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U2_Un = new OpCode (
+			0xff << 0 | 0x87 << 8 | (byte) Code.Conv_Ovf_U2_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U4_Un = new OpCode (
+			0xff << 0 | 0x88 << 8 | (byte) Code.Conv_Ovf_U4_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U8_Un = new OpCode (
+			0xff << 0 | 0x89 << 8 | (byte) Code.Conv_Ovf_U8_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Conv_Ovf_I_Un = new OpCode (
+			0xff << 0 | 0x8a << 8 | (byte) Code.Conv_Ovf_I_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U_Un = new OpCode (
+			0xff << 0 | 0x8b << 8 | (byte) Code.Conv_Ovf_U_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Box = new OpCode (
+			0xff << 0 | 0x8c << 8 | (byte) Code.Box << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Newarr = new OpCode (
+			0xff << 0 | 0x8d << 8 | (byte) Code.Newarr << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Ldlen = new OpCode (
+			0xff << 0 | 0x8e << 8 | (byte) Code.Ldlen << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelema = new OpCode (
+			0xff << 0 | 0x8f << 8 | (byte) Code.Ldelema << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_I1 = new OpCode (
+			0xff << 0 | 0x90 << 8 | (byte) Code.Ldelem_I1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_U1 = new OpCode (
+			0xff << 0 | 0x91 << 8 | (byte) Code.Ldelem_U1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_I2 = new OpCode (
+			0xff << 0 | 0x92 << 8 | (byte) Code.Ldelem_I2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_U2 = new OpCode (
+			0xff << 0 | 0x93 << 8 | (byte) Code.Ldelem_U2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_I4 = new OpCode (
+			0xff << 0 | 0x94 << 8 | (byte) Code.Ldelem_I4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_U4 = new OpCode (
+			0xff << 0 | 0x95 << 8 | (byte) Code.Ldelem_U4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_I8 = new OpCode (
+			0xff << 0 | 0x96 << 8 | (byte) Code.Ldelem_I8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Ldelem_I = new OpCode (
+			0xff << 0 | 0x97 << 8 | (byte) Code.Ldelem_I << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldelem_R4 = new OpCode (
+			0xff << 0 | 0x98 << 8 | (byte) Code.Ldelem_R4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushr4 << 24);
+
+		public static readonly OpCode Ldelem_R8 = new OpCode (
+			0xff << 0 | 0x99 << 8 | (byte) Code.Ldelem_R8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushr8 << 24);
+
+		public static readonly OpCode Ldelem_Ref = new OpCode (
+			0xff << 0 | 0x9a << 8 | (byte) Code.Ldelem_Ref << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Pushref << 24);
+
+		public static readonly OpCode Stelem_I = new OpCode (
+			0xff << 0 | 0x9b << 8 | (byte) Code.Stelem_I << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stelem_I1 = new OpCode (
+			0xff << 0 | 0x9c << 8 | (byte) Code.Stelem_I1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stelem_I2 = new OpCode (
+			0xff << 0 | 0x9d << 8 | (byte) Code.Stelem_I2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stelem_I4 = new OpCode (
+			0xff << 0 | 0x9e << 8 | (byte) Code.Stelem_I4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stelem_I8 = new OpCode (
+			0xff << 0 | 0x9f << 8 | (byte) Code.Stelem_I8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popi8 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stelem_R4 = new OpCode (
+			0xff << 0 | 0xa0 << 8 | (byte) Code.Stelem_R4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popr4 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stelem_R8 = new OpCode (
+			0xff << 0 | 0xa1 << 8 | (byte) Code.Stelem_R8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popr8 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stelem_Ref = new OpCode (
+			0xff << 0 | 0xa2 << 8 | (byte) Code.Stelem_Ref << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popref_popi_popref << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldelem_Any = new OpCode (
+			0xff << 0 | 0xa3 << 8 | (byte) Code.Ldelem_Any << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popref_popi << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Stelem_Any = new OpCode (
+			0xff << 0 | 0xa4 << 8 | (byte) Code.Stelem_Any << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popref_popi_popref << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Unbox_Any = new OpCode (
+			0xff << 0 | 0xa5 << 8 | (byte) Code.Unbox_Any << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Conv_Ovf_I1 = new OpCode (
+			0xff << 0 | 0xb3 << 8 | (byte) Code.Conv_Ovf_I1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U1 = new OpCode (
+			0xff << 0 | 0xb4 << 8 | (byte) Code.Conv_Ovf_U1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_I2 = new OpCode (
+			0xff << 0 | 0xb5 << 8 | (byte) Code.Conv_Ovf_I2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U2 = new OpCode (
+			0xff << 0 | 0xb6 << 8 | (byte) Code.Conv_Ovf_U2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_I4 = new OpCode (
+			0xff << 0 | 0xb7 << 8 | (byte) Code.Conv_Ovf_I4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U4 = new OpCode (
+			0xff << 0 | 0xb8 << 8 | (byte) Code.Conv_Ovf_U4 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_I8 = new OpCode (
+			0xff << 0 | 0xb9 << 8 | (byte) Code.Conv_Ovf_I8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Conv_Ovf_U8 = new OpCode (
+			0xff << 0 | 0xba << 8 | (byte) Code.Conv_Ovf_U8 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi8 << 24);
+
+		public static readonly OpCode Refanyval = new OpCode (
+			0xff << 0 | 0xc2 << 8 | (byte) Code.Refanyval << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ckfinite = new OpCode (
+			0xff << 0 | 0xc3 << 8 | (byte) Code.Ckfinite << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushr8 << 24);
+
+		public static readonly OpCode Mkrefany = new OpCode (
+			0xff << 0 | 0xc6 << 8 | (byte) Code.Mkrefany << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldtoken = new OpCode (
+			0xff << 0 | 0xd0 << 8 | (byte) Code.Ldtoken << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineTok << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_U2 = new OpCode (
+			0xff << 0 | 0xd1 << 8 | (byte) Code.Conv_U2 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_U1 = new OpCode (
+			0xff << 0 | 0xd2 << 8 | (byte) Code.Conv_U1 << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_I = new OpCode (
+			0xff << 0 | 0xd3 << 8 | (byte) Code.Conv_I << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_I = new OpCode (
+			0xff << 0 | 0xd4 << 8 | (byte) Code.Conv_Ovf_I << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Conv_Ovf_U = new OpCode (
+			0xff << 0 | 0xd5 << 8 | (byte) Code.Conv_Ovf_U << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Add_Ovf = new OpCode (
+			0xff << 0 | 0xd6 << 8 | (byte) Code.Add_Ovf << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Add_Ovf_Un = new OpCode (
+			0xff << 0 | 0xd7 << 8 | (byte) Code.Add_Ovf_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Mul_Ovf = new OpCode (
+			0xff << 0 | 0xd8 << 8 | (byte) Code.Mul_Ovf << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Mul_Ovf_Un = new OpCode (
+			0xff << 0 | 0xd9 << 8 | (byte) Code.Mul_Ovf_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Sub_Ovf = new OpCode (
+			0xff << 0 | 0xda << 8 | (byte) Code.Sub_Ovf << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Sub_Ovf_Un = new OpCode (
+			0xff << 0 | 0xdb << 8 | (byte) Code.Sub_Ovf_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Endfinally = new OpCode (
+			0xff << 0 | 0xdc << 8 | (byte) Code.Endfinally << 16 | (byte) FlowControl.Return << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Leave = new OpCode (
+			0xff << 0 | 0xdd << 8 | (byte) Code.Leave << 16 | (byte) FlowControl.Branch << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineBrTarget << 8 | (byte) StackBehaviour.PopAll << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Leave_S = new OpCode (
+			0xff << 0 | 0xde << 8 | (byte) Code.Leave_S << 16 | (byte) FlowControl.Branch << 24,
+			(byte) OpCodeType.Macro << 0 | (byte) OperandType.ShortInlineBrTarget << 8 | (byte) StackBehaviour.PopAll << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Stind_I = new OpCode (
+			0xff << 0 | 0xdf << 8 | (byte) Code.Stind_I << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Conv_U = new OpCode (
+			0xff << 0 | 0xe0 << 8 | (byte) Code.Conv_U << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Arglist = new OpCode (
+			0xfe << 0 | 0x00 << 8 | (byte) Code.Arglist << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ceq = new OpCode (
+			0xfe << 0 | 0x01 << 8 | (byte) Code.Ceq << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Cgt = new OpCode (
+			0xfe << 0 | 0x02 << 8 | (byte) Code.Cgt << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Cgt_Un = new OpCode (
+			0xfe << 0 | 0x03 << 8 | (byte) Code.Cgt_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Clt = new OpCode (
+			0xfe << 0 | 0x04 << 8 | (byte) Code.Clt << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Clt_Un = new OpCode (
+			0xfe << 0 | 0x05 << 8 | (byte) Code.Clt_Un << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1_pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldftn = new OpCode (
+			0xfe << 0 | 0x06 << 8 | (byte) Code.Ldftn << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineMethod << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldvirtftn = new OpCode (
+			0xfe << 0 | 0x07 << 8 | (byte) Code.Ldvirtftn << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineMethod << 8 | (byte) StackBehaviour.Popref << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Ldarg = new OpCode (
+			0xfe << 0 | 0x09 << 8 | (byte) Code.Ldarg << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineArg << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldarga = new OpCode (
+			0xfe << 0 | 0x0a << 8 | (byte) Code.Ldarga << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineArg << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Starg = new OpCode (
+			0xfe << 0 | 0x0b << 8 | (byte) Code.Starg << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineArg << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Ldloc = new OpCode (
+			0xfe << 0 | 0x0c << 8 | (byte) Code.Ldloc << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineVar << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push1 << 24);
+
+		public static readonly OpCode Ldloca = new OpCode (
+			0xfe << 0 | 0x0d << 8 | (byte) Code.Ldloca << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineVar << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Stloc = new OpCode (
+			0xfe << 0 | 0x0e << 8 | (byte) Code.Stloc << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineVar << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Localloc = new OpCode (
+			0xfe << 0 | 0x0f << 8 | (byte) Code.Localloc << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Endfilter = new OpCode (
+			0xfe << 0 | 0x11 << 8 | (byte) Code.Endfilter << 16 | (byte) FlowControl.Return << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Unaligned = new OpCode (
+			0xfe << 0 | 0x12 << 8 | (byte) Code.Unaligned << 16 | (byte) FlowControl.Meta << 24,
+			(byte) OpCodeType.Prefix << 0 | (byte) OperandType.ShortInlineI << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Volatile = new OpCode (
+			0xfe << 0 | 0x13 << 8 | (byte) Code.Volatile << 16 | (byte) FlowControl.Meta << 24,
+			(byte) OpCodeType.Prefix << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Tail = new OpCode (
+			0xfe << 0 | 0x14 << 8 | (byte) Code.Tail << 16 | (byte) FlowControl.Meta << 24,
+			(byte) OpCodeType.Prefix << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Initobj = new OpCode (
+			0xfe << 0 | 0x15 << 8 | (byte) Code.Initobj << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Constrained = new OpCode (
+			0xfe << 0 | 0x16 << 8 | (byte) Code.Constrained << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Prefix << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Cpblk = new OpCode (
+			0xfe << 0 | 0x17 << 8 | (byte) Code.Cpblk << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Initblk = new OpCode (
+			0xfe << 0 | 0x18 << 8 | (byte) Code.Initblk << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Popi_popi_popi << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode No = new OpCode (
+			0xfe << 0 | 0x19 << 8 | (byte) Code.No << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Prefix << 0 | (byte) OperandType.ShortInlineI << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Rethrow = new OpCode (
+			0xfe << 0 | 0x1a << 8 | (byte) Code.Rethrow << 16 | (byte) FlowControl.Throw << 24,
+			(byte) OpCodeType.Objmodel << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+
+		public static readonly OpCode Sizeof = new OpCode (
+			0xfe << 0 | 0x1c << 8 | (byte) Code.Sizeof << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineType << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Refanytype = new OpCode (
+			0xfe << 0 | 0x1d << 8 | (byte) Code.Refanytype << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Primitive << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop1 << 16 | (byte) StackBehaviour.Pushi << 24);
+
+		public static readonly OpCode Readonly = new OpCode (
+			0xfe << 0 | 0x1e << 8 | (byte) Code.Readonly << 16 | (byte) FlowControl.Next << 24,
+			(byte) OpCodeType.Prefix << 0 | (byte) OperandType.InlineNone << 8 | (byte) StackBehaviour.Pop0 << 16 | (byte) StackBehaviour.Push0 << 24);
+	}
+}
diff --git a/src/Mono/Cecil/Cil/PortablePdb.cs b/src/Mono/Cecil/Cil/PortablePdb.cs
new file mode 100644
index 00000000..4f734f38
--- /dev/null
+++ b/src/Mono/Cecil/Cil/PortablePdb.cs
@@ -0,0 +1,590 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+
+using Mono.Cecil.Metadata;
+using Mono.Cecil.PE;
+
+namespace Mono.Cecil.Cil {
+
+	public sealed class PortablePdbReaderProvider : ISymbolReaderProvider {
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName)
+		{
+			Mixin.CheckModule (module);
+			Mixin.CheckFileName (fileName);
+
+			var file = File.OpenRead (Mixin.GetPdbFileName (fileName));
+			return GetSymbolReader (module, Disposable.Owned (file as Stream), file.Name);
+		}
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream)
+		{
+			Mixin.CheckModule (module);
+			Mixin.CheckStream (symbolStream);
+
+			return GetSymbolReader (module, Disposable.NotOwned (symbolStream), symbolStream.GetFileName ());
+		}
+
+		ISymbolReader GetSymbolReader (ModuleDefinition module, Disposable<Stream> symbolStream, string fileName)
+		{
+			return new PortablePdbReader (ImageReader.ReadPortablePdb (symbolStream, fileName), module);
+		}
+	}
+
+	public sealed class PortablePdbReader : ISymbolReader {
+
+		readonly Image image;
+		readonly ModuleDefinition module;
+		readonly MetadataReader reader;
+		readonly MetadataReader debug_reader;
+
+		bool IsEmbedded { get { return reader.image == debug_reader.image; } }
+
+		internal PortablePdbReader (Image image, ModuleDefinition module)
+		{
+			this.image = image;
+			this.module = module;
+			this.reader = module.reader;
+			this.debug_reader = new MetadataReader (image, module, this.reader);
+		}
+
+#if !READ_ONLY
+		public ISymbolWriterProvider GetWriterProvider ()
+		{
+			return new PortablePdbWriterProvider ();
+		}
+#endif
+
+		public bool ProcessDebugHeader (ImageDebugHeader header)
+		{
+			if (image == module.Image)
+				return true;
+
+			var entry = header.GetCodeViewEntry ();
+			if (entry == null)
+				return false;
+
+			var data = entry.Data;
+
+			if (data.Length < 24)
+				return false;
+
+			var magic = ReadInt32 (data, 0);
+			if (magic != 0x53445352)
+				return false;
+
+			var buffer = new byte [16];
+			Buffer.BlockCopy (data, 4, buffer, 0, 16);
+
+			var module_guid = new Guid (buffer);
+
+			Buffer.BlockCopy (image.PdbHeap.Id, 0, buffer, 0, 16);
+
+			var pdb_guid = new Guid (buffer);
+
+			if (module_guid != pdb_guid)
+				return false;
+
+			ReadModule ();
+			return true;
+		}
+
+		static int ReadInt32 (byte [] bytes, int start)
+		{
+			return (bytes [start]
+				| (bytes [start + 1] << 8)
+				| (bytes [start + 2] << 16)
+				| (bytes [start + 3] << 24));
+		}
+
+		void ReadModule ()
+		{
+			module.custom_infos = debug_reader.GetCustomDebugInformation (module);
+		}
+
+		public MethodDebugInformation Read (MethodDefinition method)
+		{
+			var info = new MethodDebugInformation (method);
+			ReadSequencePoints (info);
+			ReadScope (info);
+			ReadStateMachineKickOffMethod (info);
+			ReadCustomDebugInformations (info);
+			return info;
+		}
+
+		void ReadSequencePoints (MethodDebugInformation method_info)
+		{
+			method_info.sequence_points = debug_reader.ReadSequencePoints (method_info.method);
+		}
+
+		void ReadScope (MethodDebugInformation method_info)
+		{
+			method_info.scope = debug_reader.ReadScope (method_info.method);
+		}
+
+		void ReadStateMachineKickOffMethod (MethodDebugInformation method_info)
+		{
+			method_info.kickoff_method = debug_reader.ReadStateMachineKickoffMethod (method_info.method);
+		}
+
+		void ReadCustomDebugInformations (MethodDebugInformation info)
+		{
+			info.method.custom_infos = debug_reader.GetCustomDebugInformation (info.method);
+		}
+
+		public void Dispose ()
+		{
+			if (IsEmbedded)
+				return;
+
+			image.Dispose ();
+		}
+	}
+
+	public sealed class EmbeddedPortablePdbReaderProvider : ISymbolReaderProvider {
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName)
+		{
+			Mixin.CheckModule (module);
+
+			var header = module.GetDebugHeader ();
+			var entry = header.GetEmbeddedPortablePdbEntry ();
+			if (entry == null)
+				throw new InvalidOperationException ();
+
+			return new EmbeddedPortablePdbReader (
+				(PortablePdbReader) new PortablePdbReaderProvider ().GetSymbolReader (module, GetPortablePdbStream (entry)));
+		}
+
+		static Stream GetPortablePdbStream (ImageDebugHeaderEntry entry)
+		{
+			var compressed_stream = new MemoryStream (entry.Data);
+			var reader = new BinaryStreamReader (compressed_stream);
+			reader.ReadInt32 (); // signature
+			var length = reader.ReadInt32 ();
+			var decompressed_stream = new MemoryStream (length);
+
+			using (var deflate_stream = new DeflateStream (compressed_stream, CompressionMode.Decompress, leaveOpen: true))
+				deflate_stream.CopyTo (decompressed_stream);
+
+			return decompressed_stream;
+		}
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
+	public sealed class EmbeddedPortablePdbReader : ISymbolReader
+	{
+		private readonly PortablePdbReader reader;
+
+		internal EmbeddedPortablePdbReader (PortablePdbReader reader)
+		{
+			if (reader == null)
+				throw new ArgumentNullException ();
+
+			this.reader = reader;
+		}
+
+#if !READ_ONLY
+		public ISymbolWriterProvider GetWriterProvider ()
+		{
+			return new EmbeddedPortablePdbWriterProvider ();
+		}
+#endif
+		public bool ProcessDebugHeader (ImageDebugHeader header)
+		{
+			return reader.ProcessDebugHeader (header);
+		}
+
+		public MethodDebugInformation Read (MethodDefinition method)
+		{
+			return reader.Read (method);
+		}
+
+		public void Dispose ()
+		{
+			reader.Dispose ();
+		}
+	}
+
+
+#if !READ_ONLY
+
+	public sealed class PortablePdbWriterProvider : ISymbolWriterProvider
+	{
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName)
+		{
+			Mixin.CheckModule (module);
+			Mixin.CheckFileName (fileName);
+
+			var file = File.OpenWrite (Mixin.GetPdbFileName (fileName));
+			return GetSymbolWriter (module, Disposable.Owned (file as Stream));
+		}
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream)
+		{
+			Mixin.CheckModule (module);
+			Mixin.CheckStream (symbolStream);
+
+			return GetSymbolWriter (module, Disposable.NotOwned (symbolStream));
+		}
+
+		ISymbolWriter GetSymbolWriter (ModuleDefinition module, Disposable<Stream> stream)
+		{
+			var metadata = new MetadataBuilder (module, this);
+			var writer = ImageWriter.CreateDebugWriter (module, metadata, stream);
+
+			return new PortablePdbWriter (metadata, module, writer);
+		}
+	}
+
+	public sealed class PortablePdbWriter : ISymbolWriter {
+
+		readonly MetadataBuilder pdb_metadata;
+		readonly ModuleDefinition module;
+		readonly ImageWriter writer;
+
+		MetadataBuilder module_metadata;
+
+		bool IsEmbedded { get { return writer == null; } }
+
+		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module)
+		{
+			this.pdb_metadata = pdb_metadata;
+			this.module = module;
+
+			this.module_metadata = module.metadata_builder;
+
+			if (module_metadata != pdb_metadata)
+				this.pdb_metadata.metadata_builder = this.module_metadata;
+
+			pdb_metadata.AddCustomDebugInformations (module);
+		}
+
+		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer)
+			: this (pdb_metadata, module)
+		{
+			this.writer = writer;
+		}
+
+		public ISymbolReaderProvider GetReaderProvider ()
+		{
+			return new PortablePdbReaderProvider ();
+		}
+
+		public ImageDebugHeader GetDebugHeader ()
+		{
+			if (IsEmbedded)
+				return new ImageDebugHeader ();
+
+			var directory = new ImageDebugDirectory () {
+				MajorVersion = 256,
+				MinorVersion = 20557,
+				Type = ImageDebugType.CodeView,
+				TimeDateStamp = (int) module.timestamp,
+			};
+
+			var buffer = new ByteBuffer ();
+			// RSDS
+			buffer.WriteUInt32 (0x53445352);
+			// Module ID
+			buffer.WriteBytes (module.Mvid.ToByteArray ());
+			// PDB Age
+			buffer.WriteUInt32 (1);
+			// PDB Path
+			buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes (writer.BaseStream.GetFileName ()));
+			buffer.WriteByte (0);
+
+			var data = new byte [buffer.length];
+			Buffer.BlockCopy (buffer.buffer, 0, data, 0, buffer.length);
+			directory.SizeOfData = data.Length;
+
+			return new ImageDebugHeader (new ImageDebugHeaderEntry (directory, data));
+		}
+
+		public void Write (MethodDebugInformation info)
+		{
+			CheckMethodDebugInformationTable ();
+
+			pdb_metadata.AddMethodDebugInformation (info);
+		}
+
+		void CheckMethodDebugInformationTable ()
+		{
+			var mdi = pdb_metadata.table_heap.GetTable<MethodDebugInformationTable> (Table.MethodDebugInformation);
+			if (mdi.length > 0)
+				return;
+
+			// The MethodDebugInformation table has the same length as the Method table
+			mdi.rows = new Row<uint, uint> [module_metadata.method_rid - 1];
+			mdi.length = mdi.rows.Length;
+		}
+
+		public void Dispose ()
+		{
+			if (IsEmbedded)
+				return;
+
+			WritePdbFile ();
+		}
+
+		void WritePdbFile ()
+		{
+			WritePdbHeap ();
+
+			WriteTableHeap ();
+
+			writer.BuildMetadataTextMap ();
+			writer.WriteMetadataHeader ();
+			writer.WriteMetadata ();
+
+			writer.Flush ();
+			writer.stream.Dispose ();
+		}
+
+		void WritePdbHeap ()
+		{
+			var pdb_heap = pdb_metadata.pdb_heap;
+
+			pdb_heap.WriteBytes (module.Mvid.ToByteArray ());
+			pdb_heap.WriteUInt32 (module_metadata.timestamp);
+
+			pdb_heap.WriteUInt32 (module_metadata.entry_point.ToUInt32 ());
+
+			var table_heap = module_metadata.table_heap;
+			var tables = table_heap.tables;
+
+			ulong valid = 0;
+			for (int i = 0; i < tables.Length; i++) {
+				if (tables [i] == null || tables [i].Length == 0)
+					continue;
+
+				valid |= (1UL << i);
+			}
+
+			pdb_heap.WriteUInt64 (valid);
+
+			for (int i = 0; i < tables.Length; i++) {
+				if (tables [i] == null || tables [i].Length == 0)
+					continue;
+
+				pdb_heap.WriteUInt32 ((uint) tables [i].Length);
+			}
+		}
+
+		void WriteTableHeap ()
+		{
+			pdb_metadata.table_heap.string_offsets = pdb_metadata.string_heap.WriteStrings ();
+			pdb_metadata.table_heap.ComputeTableInformations ();
+			pdb_metadata.table_heap.WriteTableHeap ();
+		}
+	}
+
+	public sealed class EmbeddedPortablePdbWriterProvider : ISymbolWriterProvider {
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName)
+		{
+			Mixin.CheckModule (module);
+			Mixin.CheckFileName (fileName);
+
+			var stream = new MemoryStream ();
+			var pdb_writer = (PortablePdbWriter) new PortablePdbWriterProvider ().GetSymbolWriter (module, stream);
+			return new EmbeddedPortablePdbWriter (stream, pdb_writer);
+		}
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
+	public sealed class EmbeddedPortablePdbWriter : ISymbolWriter {
+
+		readonly Stream stream;
+		readonly PortablePdbWriter writer;
+
+		internal EmbeddedPortablePdbWriter (Stream stream, PortablePdbWriter writer)
+		{
+			this.stream = stream;
+			this.writer = writer;
+		}
+
+		public ISymbolReaderProvider GetReaderProvider ()
+		{
+			return new EmbeddedPortablePdbReaderProvider ();
+		}
+
+		public ImageDebugHeader GetDebugHeader ()
+		{
+			writer.Dispose ();
+
+			var directory = new ImageDebugDirectory {
+				Type = ImageDebugType.EmbeddedPortablePdb,
+				MajorVersion = 0x0100,
+				MinorVersion = 0x0100,
+			};
+
+			var data = new MemoryStream ();
+
+			var w = new BinaryStreamWriter (data);
+			w.WriteByte (0x4d);
+			w.WriteByte (0x50);
+			w.WriteByte (0x44);
+			w.WriteByte (0x42);
+
+			w.WriteInt32 ((int) stream.Length);
+
+			stream.Position = 0;
+
+			using (var compress_stream = new DeflateStream (data, CompressionMode.Compress, leaveOpen: true))
+				stream.CopyTo (compress_stream);
+
+			directory.SizeOfData = (int) data.Length;
+
+			return new ImageDebugHeader (new [] {
+				writer.GetDebugHeader ().Entries [0],
+				new ImageDebugHeaderEntry (directory, data.ToArray ())
+			});
+		}
+
+		public void Write (MethodDebugInformation info)
+		{
+			writer.Write (info);
+		}
+
+		public void Dispose ()
+		{
+		}
+	}
+
+#endif
+
+	static class PdbGuidMapping {
+
+		static readonly Dictionary<Guid, DocumentLanguage> guid_language = new Dictionary<Guid, DocumentLanguage> ();
+		static readonly Dictionary<DocumentLanguage, Guid> language_guid = new Dictionary<DocumentLanguage, Guid> ();
+
+		static PdbGuidMapping ()
+		{
+			AddMapping (DocumentLanguage.C, new Guid ("63a08714-fc37-11d2-904c-00c04fa302a1"));
+			AddMapping (DocumentLanguage.Cpp, new Guid ("3a12d0b7-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.CSharp, new Guid ("3f5162f8-07c6-11d3-9053-00c04fa302a1"));
+			AddMapping (DocumentLanguage.Basic, new Guid ("3a12d0b8-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.Java, new Guid ("3a12d0b4-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.Cobol, new Guid ("af046cd1-d0e1-11d2-977c-00a0c9b4d50c"));
+			AddMapping (DocumentLanguage.Pascal, new Guid ("af046cd2-d0e1-11d2-977c-00a0c9b4d50c"));
+			AddMapping (DocumentLanguage.Cil, new Guid ("af046cd3-d0e1-11d2-977c-00a0c9b4d50c"));
+			AddMapping (DocumentLanguage.JScript, new Guid ("3a12d0b6-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.Smc, new Guid ("0d9b9f7b-6611-11d3-bd2a-0000f80849bd"));
+			AddMapping (DocumentLanguage.MCpp, new Guid ("4b35fde8-07c6-11d3-9053-00c04fa302a1"));
+			AddMapping (DocumentLanguage.FSharp, new Guid ("ab4f38c9-b6e6-43ba-be3b-58080b2ccce3"));
+		}
+
+		static void AddMapping (DocumentLanguage language, Guid guid)
+		{
+			guid_language.Add (guid, language);
+			language_guid.Add (language, guid);
+		}
+
+		static readonly Guid type_text = new Guid ("5a869d0b-6611-11d3-bd2a-0000f80849bd");
+
+		public static DocumentType ToType (this Guid guid)
+		{
+			if (guid == type_text)
+				return DocumentType.Text;
+
+			return DocumentType.Other;
+		}
+
+		public static Guid ToGuid (this DocumentType type)
+		{
+			if (type == DocumentType.Text)
+				return type_text;
+
+			return new Guid ();
+		}
+
+		static readonly Guid hash_md5 = new Guid ("406ea660-64cf-4c82-b6f0-42d48172a799");
+		static readonly Guid hash_sha1 = new Guid ("ff1816ec-aa5e-4d10-87f7-6f4963833460");
+		static readonly Guid hash_sha256 = new Guid ("8829d00f-11b8-4213-878b-770e8597ac16");
+
+		public static DocumentHashAlgorithm ToHashAlgorithm (this Guid guid)
+		{
+			if (guid == hash_md5)
+				return DocumentHashAlgorithm.MD5;
+
+			if (guid == hash_sha1)
+				return DocumentHashAlgorithm.SHA1;
+
+			if (guid == hash_sha256)
+				return DocumentHashAlgorithm.SHA256;
+
+			return DocumentHashAlgorithm.None;
+		}
+
+		public static Guid ToGuid (this DocumentHashAlgorithm hash_algo)
+		{
+			if (hash_algo == DocumentHashAlgorithm.MD5)
+				return hash_md5;
+
+			if (hash_algo == DocumentHashAlgorithm.SHA1)
+				return hash_sha1;
+
+			if (hash_algo == DocumentHashAlgorithm.SHA256)
+				return hash_sha256;
+
+			return new Guid ();
+		}
+
+		public static DocumentLanguage ToLanguage (this Guid guid)
+		{
+			DocumentLanguage language;
+			if (!guid_language.TryGetValue (guid, out language))
+				return DocumentLanguage.Other;
+
+			return language;
+		}
+
+		public static Guid ToGuid (this DocumentLanguage language)
+		{
+			Guid guid;
+			if (!language_guid.TryGetValue (language, out guid))
+				return new Guid ();
+
+			return guid;
+		}
+
+		static readonly Guid vendor_ms = new Guid ("994b45c4-e6e9-11d2-903f-00c04fa302a1");
+
+		public static DocumentLanguageVendor ToVendor (this Guid guid)
+		{
+			if (guid == vendor_ms)
+				return DocumentLanguageVendor.Microsoft;
+
+			return DocumentLanguageVendor.Other;
+		}
+
+		public static Guid ToGuid (this DocumentLanguageVendor vendor)
+		{
+			if (vendor == DocumentLanguageVendor.Microsoft)
+				return vendor_ms;
+
+			return new Guid ();
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/SequencePoint.cs b/src/Mono/Cecil/Cil/SequencePoint.cs
new file mode 100644
index 00000000..725d307a
--- /dev/null
+++ b/src/Mono/Cecil/Cil/SequencePoint.cs
@@ -0,0 +1,76 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil.Cil {
+
+	public sealed class SequencePoint {
+
+		internal InstructionOffset offset;
+		Document document;
+
+		int start_line;
+		int start_column;
+		int end_line;
+		int end_column;
+
+		public int Offset {
+			get { return offset.Offset; }
+		}
+
+		public int StartLine {
+			get { return start_line; }
+			set { start_line = value; }
+		}
+
+		public int StartColumn {
+			get { return start_column; }
+			set { start_column = value; }
+		}
+
+		public int EndLine {
+			get { return end_line; }
+			set { end_line = value; }
+		}
+
+		public int EndColumn {
+			get { return end_column; }
+			set { end_column = value; }
+		}
+
+		public bool IsHidden {
+			get { return start_line == 0xfeefee && start_line == end_line; }
+		}
+
+		public Document Document {
+			get { return document; }
+			set { document = value; }
+		}
+
+		internal SequencePoint (int offset, Document document)
+		{
+			if (document == null)
+				throw new ArgumentNullException ("document");
+
+			this.offset = new InstructionOffset (offset);
+			this.document = document;
+		}
+
+		public SequencePoint (Instruction instruction, Document document)
+		{
+			if (document == null)
+				throw new ArgumentNullException ("document");
+
+			this.offset = new InstructionOffset (instruction);
+			this.document = document;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/Symbols.cs b/src/Mono/Cecil/Cil/Symbols.cs
new file mode 100644
index 00000000..30953180
--- /dev/null
+++ b/src/Mono/Cecil/Cil/Symbols.cs
@@ -0,0 +1,1127 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using SR = System.Reflection;
+
+using Mono.Collections.Generic;
+using Mono.Cecil.Cil;
+using Mono.Cecil.PE;
+
+namespace Mono.Cecil.Cil {
+
+	[StructLayout (LayoutKind.Sequential)]
+	public struct ImageDebugDirectory {
+		public const int Size = 28;
+
+		public int Characteristics;
+		public int TimeDateStamp;
+		public short MajorVersion;
+		public short MinorVersion;
+		public ImageDebugType Type;
+		public int SizeOfData;
+		public int AddressOfRawData;
+		public int PointerToRawData;
+	}
+
+	public enum ImageDebugType {
+		CodeView = 2,
+		Deterministic = 16,
+		EmbeddedPortablePdb = 17,
+	}
+
+	public sealed class ImageDebugHeader {
+
+		readonly ImageDebugHeaderEntry [] entries;
+
+		public bool HasEntries {
+			get { return !entries.IsNullOrEmpty (); }
+		}
+
+		public ImageDebugHeaderEntry [] Entries {
+			get { return entries; }
+		}
+
+		public ImageDebugHeader (ImageDebugHeaderEntry [] entries)
+		{
+			this.entries = entries ?? Empty<ImageDebugHeaderEntry>.Array;
+		}
+
+		public ImageDebugHeader ()
+			: this (Empty<ImageDebugHeaderEntry>.Array)
+		{
+		}
+
+		public ImageDebugHeader (ImageDebugHeaderEntry entry)
+			: this (new [] { entry })
+		{
+		}
+	}
+
+	public sealed class ImageDebugHeaderEntry {
+
+		ImageDebugDirectory directory;
+		readonly byte [] data;
+
+		public ImageDebugDirectory Directory {
+			get { return directory; }
+			internal set { directory = value; }
+		}
+
+		public byte [] Data {
+			get { return data; }
+		}
+
+		public ImageDebugHeaderEntry (ImageDebugDirectory directory, byte [] data)
+		{
+			this.directory = directory;
+			this.data = data ?? Empty<byte>.Array;
+		}
+	}
+
+	public sealed class ScopeDebugInformation : DebugInformation {
+
+		internal InstructionOffset start;
+		internal InstructionOffset end;
+		internal ImportDebugInformation import;
+		internal Collection<ScopeDebugInformation> scopes;
+		internal Collection<VariableDebugInformation> variables;
+		internal Collection<ConstantDebugInformation> constants;
+
+		public InstructionOffset Start {
+			get { return start; }
+			set { start = value; }
+		}
+
+		public InstructionOffset End {
+			get { return end; }
+			set { end = value; }
+		}
+
+		public ImportDebugInformation Import {
+			get { return import; }
+			set { import = value; }
+		}
+
+		public bool HasScopes {
+			get { return !scopes.IsNullOrEmpty (); }
+		}
+
+		public Collection<ScopeDebugInformation> Scopes {
+			get { return scopes ?? (scopes = new Collection<ScopeDebugInformation> ()); }
+		}
+
+		public bool HasVariables {
+			get { return !variables.IsNullOrEmpty (); }
+		}
+
+		public Collection<VariableDebugInformation> Variables {
+			get { return variables ?? (variables = new Collection<VariableDebugInformation> ()); }
+		}
+
+		public bool HasConstants {
+			get { return !constants.IsNullOrEmpty (); }
+		}
+
+		public Collection<ConstantDebugInformation> Constants {
+			get { return constants ?? (constants = new Collection<ConstantDebugInformation> ()); }
+		}
+
+		internal ScopeDebugInformation ()
+		{
+			this.token = new MetadataToken (TokenType.LocalScope);
+		}
+
+		public ScopeDebugInformation (Instruction start, Instruction end)
+			: this ()
+		{
+			if (start == null)
+				throw new ArgumentNullException ("start");
+
+			this.start = new InstructionOffset (start);
+
+			if (end != null)
+				this.end = new InstructionOffset (end);
+		}
+
+		public bool TryGetName (VariableDefinition variable, out string name)
+		{
+			name = null;
+			if (variables == null || variables.Count == 0)
+				return false;
+
+			for (int i = 0; i < variables.Count; i++) {
+				if (variables [i].Index == variable.Index) {
+					name = variables [i].Name;
+					return true;
+				}
+			}
+
+			return false;
+		}
+	}
+
+	public struct InstructionOffset {
+
+		readonly Instruction instruction;
+		readonly int? offset;
+
+		public int Offset {
+			get {
+				if (instruction != null)
+					return instruction.Offset;
+				if (offset.HasValue)
+					return offset.Value;
+
+				throw new NotSupportedException ();
+			}
+		}
+
+		public bool IsEndOfMethod {
+			get { return instruction == null && !offset.HasValue; }
+		}
+
+		public InstructionOffset (Instruction instruction)
+		{
+			if (instruction == null)
+				throw new ArgumentNullException ("instruction");
+
+			this.instruction = instruction;
+			this.offset = null;
+		}
+
+		public InstructionOffset (int offset)
+		{
+			this.instruction = null;
+			this.offset = offset;
+		}
+	}
+
+	[Flags]
+	public enum VariableAttributes : ushort {
+		None = 0,
+		DebuggerHidden = 1,
+	}
+
+	public struct VariableIndex {
+		readonly VariableDefinition variable;
+		readonly int? index;
+
+		public int Index {
+			get {
+				if (variable != null)
+					return variable.Index;
+				if (index.HasValue)
+					return index.Value;
+
+				throw new NotSupportedException ();
+			}
+		}
+
+		public VariableIndex (VariableDefinition variable)
+		{
+			if (variable == null)
+				throw new ArgumentNullException ("variable");
+
+			this.variable = variable;
+			this.index = null;
+		}
+
+		public VariableIndex (int index)
+		{
+			this.variable = null;
+			this.index = index;
+		}
+	}
+
+	public abstract class DebugInformation : ICustomDebugInformationProvider {
+
+		internal MetadataToken token;
+		internal Collection<CustomDebugInformation> custom_infos;
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		public bool HasCustomDebugInformations {
+			get { return !custom_infos.IsNullOrEmpty (); }
+		}
+
+		public Collection<CustomDebugInformation> CustomDebugInformations {
+			get { return custom_infos ?? (custom_infos = new Collection<CustomDebugInformation> ()); }
+		}
+
+		internal DebugInformation ()
+		{
+		}
+	}
+
+	public sealed class VariableDebugInformation : DebugInformation {
+
+		string name;
+		ushort attributes;
+		internal VariableIndex index;
+
+		public int Index {
+			get { return index.Index; }
+		}
+
+		public string Name {
+			get { return name; }
+			set { name = value; }
+		}
+
+		public VariableAttributes Attributes {
+			get { return (VariableAttributes) attributes; }
+			set { attributes = (ushort) value; }
+		}
+
+		public bool IsDebuggerHidden {
+			get { return attributes.GetAttributes ((ushort) VariableAttributes.DebuggerHidden); }
+			set { attributes = attributes.SetAttributes ((ushort) VariableAttributes.DebuggerHidden, value); }
+		}
+
+		internal VariableDebugInformation (int index, string name)
+		{
+			if (name == null)
+				throw new ArgumentNullException ("name");
+
+			this.index = new VariableIndex (index);
+			this.name = name;
+		}
+
+		public VariableDebugInformation (VariableDefinition variable, string name)
+		{
+			if (variable == null)
+				throw new ArgumentNullException ("variable");
+			if (name == null)
+				throw new ArgumentNullException ("name");
+
+			this.index = new VariableIndex (variable);
+			this.name = name;
+			this.token = new MetadataToken (TokenType.LocalVariable);
+		}
+	}
+
+	public sealed class ConstantDebugInformation : DebugInformation {
+
+		string name;
+		TypeReference constant_type;
+		object value;
+
+		public string Name {
+			get { return name; }
+			set { name = value; }
+		}
+
+		public TypeReference ConstantType {
+			get { return constant_type; }
+			set { constant_type = value; }
+		}
+
+		public object Value {
+			get { return value; }
+			set { this.value = value; }
+		}
+
+		public ConstantDebugInformation (string name, TypeReference constant_type, object value)
+		{
+			if (name == null)
+				throw new ArgumentNullException ("name");
+
+			this.name = name;
+			this.constant_type = constant_type;
+			this.value = value;
+			this.token = new MetadataToken (TokenType.LocalConstant);
+		}
+	}
+
+	public enum ImportTargetKind : byte {
+		ImportNamespace = 1,
+		ImportNamespaceInAssembly = 2,
+		ImportType = 3,
+		ImportXmlNamespaceWithAlias = 4,
+		ImportAlias = 5,
+		DefineAssemblyAlias = 6,
+		DefineNamespaceAlias = 7,
+		DefineNamespaceInAssemblyAlias = 8,
+		DefineTypeAlias = 9,
+	}
+
+	public sealed class ImportTarget {
+
+		internal ImportTargetKind kind;
+
+		internal string @namespace;
+		internal TypeReference type;
+		internal AssemblyNameReference reference;
+		internal string alias;
+
+		public string Namespace {
+			get { return @namespace; }
+			set { @namespace = value; }
+		}
+
+		public TypeReference Type {
+			get { return type; }
+			set { type = value; }
+		}
+
+		public AssemblyNameReference AssemblyReference {
+			get { return reference; }
+			set { reference = value; }
+		}
+
+		public string Alias {
+			get { return alias; }
+			set { alias = value; }
+		}
+
+		public ImportTargetKind Kind {
+			get { return kind; }
+			set { kind = value; }
+		}
+
+		public ImportTarget (ImportTargetKind kind)
+		{
+			this.kind = kind;
+		}
+	}
+
+	public sealed class ImportDebugInformation : DebugInformation {
+
+		internal ImportDebugInformation parent;
+		internal Collection<ImportTarget> targets;
+
+		public bool HasTargets {
+			get { return !targets.IsNullOrEmpty (); }
+		}
+
+		public Collection<ImportTarget> Targets {
+			get { return targets ?? (targets = new Collection<ImportTarget> ()); }
+		}
+
+		public ImportDebugInformation Parent {
+			get { return parent; }
+			set { parent = value; }
+		}
+
+		public ImportDebugInformation ()
+		{
+			this.token = new MetadataToken (TokenType.ImportScope);
+		}
+	}
+
+	public interface ICustomDebugInformationProvider : IMetadataTokenProvider {
+		bool HasCustomDebugInformations { get; }
+		Collection<CustomDebugInformation> CustomDebugInformations { get; }
+	}
+
+	public enum CustomDebugInformationKind {
+		Binary,
+		StateMachineScope,
+		DynamicVariable,
+		DefaultNamespace,
+		AsyncMethodBody,
+		EmbeddedSource,
+		SourceLink,
+	}
+
+	public abstract class CustomDebugInformation : DebugInformation {
+
+		Guid identifier;
+
+		public Guid Identifier {
+			get { return identifier; }
+		}
+
+		public abstract CustomDebugInformationKind Kind { get; }
+
+		internal CustomDebugInformation (Guid identifier)
+		{
+			this.identifier = identifier;
+			this.token = new MetadataToken (TokenType.CustomDebugInformation);
+		}
+	}
+
+	public sealed class BinaryCustomDebugInformation : CustomDebugInformation {
+
+		byte [] data;
+
+		public byte [] Data {
+			get { return data; }
+			set { data = value; }
+		}
+
+		public override CustomDebugInformationKind Kind {
+			get { return CustomDebugInformationKind.Binary; }
+		}
+
+		public BinaryCustomDebugInformation (Guid identifier, byte [] data)
+			: base (identifier)
+		{
+			this.data = data;
+		}
+	}
+
+	public sealed class AsyncMethodBodyDebugInformation : CustomDebugInformation {
+
+		internal InstructionOffset catch_handler;
+		internal Collection<InstructionOffset> yields;
+		internal Collection<InstructionOffset> resumes;
+		internal Collection<MethodDefinition> resume_methods;
+
+		public InstructionOffset CatchHandler {
+			get { return catch_handler; }
+			set { catch_handler = value; }
+		}
+
+		public Collection<InstructionOffset> Yields {
+			get { return yields ?? (yields = new Collection<InstructionOffset> ()); }
+		}
+
+		public Collection<InstructionOffset> Resumes {
+			get { return resumes ?? (resumes = new Collection<InstructionOffset> ()); }
+		}
+
+		public Collection<MethodDefinition> ResumeMethods {
+			get { return resume_methods ?? (resume_methods = new Collection<MethodDefinition> ()); }
+		}
+
+		public override CustomDebugInformationKind Kind {
+			get { return CustomDebugInformationKind.AsyncMethodBody; }
+		}
+
+		public static Guid KindIdentifier = new Guid ("{54FD2AC5-E925-401A-9C2A-F94F171072F8}");
+
+		internal AsyncMethodBodyDebugInformation (int catchHandler)
+			: base (KindIdentifier)
+		{
+			this.catch_handler = new InstructionOffset (catchHandler);
+		}
+
+		public AsyncMethodBodyDebugInformation (Instruction catchHandler)
+			: base (KindIdentifier)
+		{
+			this.catch_handler = new InstructionOffset (catchHandler);
+		}
+
+		public AsyncMethodBodyDebugInformation ()
+			: base (KindIdentifier)
+		{
+			this.catch_handler = new InstructionOffset (-1);
+		}
+	}
+
+	public sealed class StateMachineScope {
+
+		internal InstructionOffset start;
+		internal InstructionOffset end;
+
+		public InstructionOffset Start {
+			get { return start; }
+			set { start = value; }
+		}
+
+		public InstructionOffset End {
+			get { return end; }
+			set { end = value; }
+		}
+
+		internal StateMachineScope (int start, int end)
+		{
+			this.start = new InstructionOffset (start);
+			this.end = new InstructionOffset (end);
+		}
+
+		public StateMachineScope (Instruction start, Instruction end)
+		{
+			this.start = new InstructionOffset (start);
+			this.end = end != null ? new InstructionOffset (end) : new InstructionOffset ();
+		}
+	}
+
+	public sealed class StateMachineScopeDebugInformation : CustomDebugInformation {
+
+		internal Collection<StateMachineScope> scopes;
+
+		public Collection<StateMachineScope> Scopes {
+			get { return scopes ?? (scopes = new Collection<StateMachineScope> ()); }
+		}
+
+		public override CustomDebugInformationKind Kind {
+			get { return CustomDebugInformationKind.StateMachineScope; }
+		}
+
+		public static Guid KindIdentifier = new Guid ("{6DA9A61E-F8C7-4874-BE62-68BC5630DF71}");
+
+		public StateMachineScopeDebugInformation ()
+			: base (KindIdentifier)
+		{
+		}
+	}
+
+	public sealed class EmbeddedSourceDebugInformation : CustomDebugInformation {
+
+		internal byte [] content;
+		internal bool compress;
+
+		public byte [] Content {
+			get { return content; }
+			set { content = value; }
+		}
+
+		public bool Compress {
+			get { return compress; }
+			set { compress = value; }
+		}
+
+		public override CustomDebugInformationKind Kind {
+			get { return CustomDebugInformationKind.EmbeddedSource; }
+		}
+
+		public static Guid KindIdentifier = new Guid ("{0E8A571B-6926-466E-B4AD-8AB04611F5FE}");
+
+		public EmbeddedSourceDebugInformation (byte [] content, bool compress)
+			: base (KindIdentifier)
+		{
+			this.content = content;
+			this.compress = compress;
+		}
+	}
+
+	public sealed class SourceLinkDebugInformation : CustomDebugInformation {
+
+		internal string content;
+
+		public string Content {
+			get { return content; }
+			set { content = value; }
+		}
+
+		public override CustomDebugInformationKind Kind {
+			get { return CustomDebugInformationKind.SourceLink; }
+		}
+
+		public static Guid KindIdentifier = new Guid ("{CC110556-A091-4D38-9FEC-25AB9A351A6A}");
+
+		public SourceLinkDebugInformation (string content)
+			: base (KindIdentifier)
+		{
+			this.content = content;
+		}
+	}
+
+	public sealed class MethodDebugInformation : DebugInformation {
+
+		internal MethodDefinition method;
+		internal Collection<SequencePoint> sequence_points;
+		internal ScopeDebugInformation scope;
+		internal MethodDefinition kickoff_method;
+		internal int code_size;
+		internal MetadataToken local_var_token;
+
+		public MethodDefinition Method {
+			get { return method; }
+		}
+
+		public bool HasSequencePoints {
+			get { return !sequence_points.IsNullOrEmpty (); }
+		}
+
+		public Collection<SequencePoint> SequencePoints {
+			get { return sequence_points ?? (sequence_points = new Collection<SequencePoint> ()); }
+		}
+
+		public ScopeDebugInformation Scope {
+			get { return scope; }
+			set { scope = value; }
+		}
+
+		public MethodDefinition StateMachineKickOffMethod {
+			get { return kickoff_method; }
+			set { kickoff_method = value; }
+		}
+
+		internal MethodDebugInformation (MethodDefinition method)
+		{
+			if (method == null)
+				throw new ArgumentNullException ("method");
+
+			this.method = method;
+			this.token = new MetadataToken (TokenType.MethodDebugInformation, method.MetadataToken.RID);
+		}
+
+		public SequencePoint GetSequencePoint (Instruction instruction)
+		{
+			if (!HasSequencePoints)
+				return null;
+
+			for (int i = 0; i < sequence_points.Count; i++)
+				if (sequence_points [i].Offset == instruction.Offset)
+					return sequence_points [i];
+
+			return null;
+		}
+
+		public IDictionary<Instruction, SequencePoint> GetSequencePointMapping ()
+		{
+			var instruction_mapping = new Dictionary<Instruction, SequencePoint> ();
+			if (!HasSequencePoints || !method.HasBody)
+				return instruction_mapping;
+
+			var offset_mapping = new Dictionary<int, SequencePoint> (sequence_points.Count);
+
+			for (int i = 0; i < sequence_points.Count; i++) {
+				if (!offset_mapping.ContainsKey (sequence_points [i].Offset))
+					offset_mapping.Add (sequence_points [i].Offset, sequence_points [i]);
+			}
+
+			var instructions = method.Body.Instructions;
+
+			for (int i = 0; i < instructions.Count; i++) {
+				SequencePoint sequence_point;
+				if (offset_mapping.TryGetValue (instructions [i].Offset, out sequence_point))
+					instruction_mapping.Add (instructions [i], sequence_point);
+			}
+
+			return instruction_mapping;
+		}
+
+		public IEnumerable<ScopeDebugInformation> GetScopes ()
+		{
+			if (scope == null)
+				return Empty<ScopeDebugInformation>.Array;
+
+			return GetScopes (new[] { scope });
+		}
+
+		static IEnumerable<ScopeDebugInformation> GetScopes (IList<ScopeDebugInformation> scopes)
+		{
+			for (int i = 0; i < scopes.Count; i++) {
+				var scope = scopes [i];
+
+				yield return scope;
+
+				if (!scope.HasScopes)
+					continue;
+
+				foreach (var sub_scope in GetScopes (scope.Scopes))
+					yield return sub_scope;
+			}
+		}
+
+		public bool TryGetName (VariableDefinition variable, out string name)
+		{
+			name = null;
+
+			var has_name = false;
+			var unique_name = "";
+
+			foreach (var scope in GetScopes ()) {
+				string slot_name;
+				if (!scope.TryGetName (variable, out slot_name))
+					continue;
+
+				if (!has_name) {
+					has_name = true;
+					unique_name = slot_name;
+					continue;
+				}
+
+				if (unique_name != slot_name)
+					return false;
+			}
+
+			name = unique_name;
+			return has_name;
+		}
+	}
+
+	public interface ISymbolReader : IDisposable {
+#if !READ_ONLY
+		ISymbolWriterProvider GetWriterProvider ();
+#endif
+		bool ProcessDebugHeader (ImageDebugHeader header);
+		MethodDebugInformation Read (MethodDefinition method);
+	}
+
+	public interface ISymbolReaderProvider {
+		ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName);
+		ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream);
+	}
+
+#if !NET_CORE
+	[Serializable]
+#endif
+	public sealed class SymbolsNotFoundException : FileNotFoundException {
+
+		public SymbolsNotFoundException (string message) : base (message)
+		{
+		}
+
+#if !NET_CORE
+		SymbolsNotFoundException (
+			System.Runtime.Serialization.SerializationInfo info,
+			System.Runtime.Serialization.StreamingContext context)
+			: base (info, context)
+		{
+		}
+#endif
+	}
+
+#if !NET_CORE
+	[Serializable]
+#endif
+	public sealed class SymbolsNotMatchingException : InvalidOperationException {
+
+		public SymbolsNotMatchingException (string message) : base (message)
+		{
+		}
+
+#if !NET_CORE
+		SymbolsNotMatchingException (
+			System.Runtime.Serialization.SerializationInfo info,
+			System.Runtime.Serialization.StreamingContext context)
+			: base (info, context)
+		{
+		}
+#endif
+	}
+
+	public class DefaultSymbolReaderProvider : ISymbolReaderProvider {
+
+		readonly bool throw_if_no_symbol;
+
+		public DefaultSymbolReaderProvider ()
+			: this (throwIfNoSymbol: true)
+		{
+		}
+
+		public DefaultSymbolReaderProvider (bool throwIfNoSymbol)
+		{
+			throw_if_no_symbol = throwIfNoSymbol;
+		}
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName)
+		{
+			if (module.Image.HasDebugTables ())
+				return null;
+
+			if (module.HasDebugHeader) {
+				var header = module.GetDebugHeader ();
+				var entry = header.GetEmbeddedPortablePdbEntry ();
+				if (entry != null)
+					return new EmbeddedPortablePdbReaderProvider ().GetSymbolReader (module, fileName);
+			}
+
+			var pdb_file_name = Mixin.GetPdbFileName (fileName);
+
+			if (File.Exists (pdb_file_name)) {
+				if (Mixin.IsPortablePdb (Mixin.GetPdbFileName (fileName)))
+					return new PortablePdbReaderProvider ().GetSymbolReader (module, fileName);
+
+				try {
+					return SymbolProvider.GetReaderProvider (SymbolKind.NativePdb).GetSymbolReader (module, fileName);
+				} catch (Exception) {
+					// We might not include support for native pdbs.
+				}
+			}
+
+			var mdb_file_name = Mixin.GetMdbFileName (fileName);
+			if (File.Exists (mdb_file_name)) {
+				try {
+					return SymbolProvider.GetReaderProvider (SymbolKind.Mdb).GetSymbolReader (module, fileName);
+				} catch (Exception) {
+					// We might not include support for mdbs.
+				}
+			}
+
+			if (throw_if_no_symbol)
+				throw new SymbolsNotFoundException (string.Format ("No symbol found for file: {0}", fileName));
+
+			return null;
+		}
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream)
+		{
+			if (module.Image.HasDebugTables ())
+				return null;
+
+			if (module.HasDebugHeader) {
+				var header = module.GetDebugHeader ();
+				var entry = header.GetEmbeddedPortablePdbEntry ();
+				if (entry != null)
+					return new EmbeddedPortablePdbReaderProvider ().GetSymbolReader (module, "");
+			}
+
+			Mixin.CheckStream (symbolStream);
+			Mixin.CheckReadSeek (symbolStream);
+
+			var position = symbolStream.Position;
+
+			const int portablePdbHeader = 0x424a5342;
+
+			var reader = new BinaryStreamReader (symbolStream);
+			var intHeader = reader.ReadInt32 ();
+			symbolStream.Position = position;
+
+			if (intHeader == portablePdbHeader) {
+				return new PortablePdbReaderProvider ().GetSymbolReader (module, symbolStream);
+			}
+
+			const string nativePdbHeader = "Microsoft C/C++ MSF 7.00";
+
+			var bytesHeader = reader.ReadBytes (nativePdbHeader.Length);
+			symbolStream.Position = position;
+			var isNativePdb = true;
+
+			for (var i = 0; i < bytesHeader.Length; i++) {
+				if (bytesHeader [i] != (byte) nativePdbHeader [i]) {
+					isNativePdb = false;
+					break;
+				}
+			}
+
+			if (isNativePdb) {
+				try {
+					return SymbolProvider.GetReaderProvider (SymbolKind.NativePdb).GetSymbolReader (module, symbolStream);
+				} catch (Exception) {
+					// We might not include support for native pdbs.
+				}
+			}
+
+			const long mdbHeader = 0x45e82623fd7fa614;
+
+			var longHeader = reader.ReadInt64 ();
+			symbolStream.Position = position;
+
+			if (longHeader == mdbHeader) {
+				try {
+					return SymbolProvider.GetReaderProvider (SymbolKind.Mdb).GetSymbolReader (module, symbolStream);
+				} catch (Exception) {
+					// We might not include support for mdbs.
+				}
+			}
+
+			if (throw_if_no_symbol)
+				throw new SymbolsNotFoundException (string.Format ("No symbols found in stream"));
+
+			return null;
+		}
+	}
+
+	enum SymbolKind {
+		NativePdb,
+		PortablePdb,
+		EmbeddedPortablePdb,
+		Mdb,
+	}
+
+	static class SymbolProvider {
+
+		static SR.AssemblyName GetSymbolAssemblyName (SymbolKind kind)
+		{
+			if (kind == SymbolKind.PortablePdb)
+				throw new ArgumentException ();
+
+			var suffix = GetSymbolNamespace (kind);
+
+			var cecil_name = typeof (SymbolProvider).Assembly ().GetName ();
+
+			var name = new SR.AssemblyName {
+				Name = cecil_name.Name + "." + suffix,
+				Version = cecil_name.Version,
+#if NET_CORE
+				CultureName = cecil_name.CultureName,
+#else
+				CultureInfo = cecil_name.CultureInfo,
+#endif
+			};
+
+			name.SetPublicKeyToken (cecil_name.GetPublicKeyToken ());
+
+			return name;
+		}
+
+		static Type GetSymbolType (SymbolKind kind, string fullname)
+		{
+			var type = Type.GetType (fullname);
+			if (type != null)
+				return type;
+
+			var assembly_name = GetSymbolAssemblyName (kind);
+
+			type = Type.GetType (fullname + ", " + assembly_name.FullName);
+			if (type != null)
+				return type;
+
+			try {
+				var assembly = SR.Assembly.Load (assembly_name);
+				if (assembly != null)
+					return assembly.GetType (fullname);
+			} catch (FileNotFoundException) {
+			} catch (FileLoadException) {
+			}
+
+			return null;
+		}
+
+		public static ISymbolReaderProvider GetReaderProvider (SymbolKind kind)
+		{
+			if (kind == SymbolKind.PortablePdb)
+				return new PortablePdbReaderProvider ();
+			if (kind == SymbolKind.EmbeddedPortablePdb)
+				return new EmbeddedPortablePdbReaderProvider ();
+
+			var provider_name = GetSymbolTypeName (kind, "ReaderProvider");
+			var type = GetSymbolType (kind, provider_name);
+			if (type == null)
+				throw new TypeLoadException ("Could not find symbol provider type " + provider_name);
+
+			return (ISymbolReaderProvider) Activator.CreateInstance (type);
+		}
+
+		static string GetSymbolTypeName (SymbolKind kind, string name)
+		{
+			return "Mono.Cecil" + "." + GetSymbolNamespace (kind) + "." + kind + name;
+		}
+
+		static string GetSymbolNamespace (SymbolKind kind)
+		{
+			if (kind == SymbolKind.PortablePdb || kind == SymbolKind.EmbeddedPortablePdb)
+				return "Cil";
+			if (kind == SymbolKind.NativePdb)
+				return "Pdb";
+			if (kind == SymbolKind.Mdb)
+				return "Mdb";
+
+			throw new ArgumentException ();
+		}
+	}
+
+#if !READ_ONLY
+
+	public interface ISymbolWriter : IDisposable {
+
+		ISymbolReaderProvider GetReaderProvider ();
+		ImageDebugHeader GetDebugHeader ();
+		void Write (MethodDebugInformation info);
+	}
+
+	public interface ISymbolWriterProvider {
+
+		ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName);
+		ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream);
+	}
+
+	public class DefaultSymbolWriterProvider : ISymbolWriterProvider {
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName)
+		{
+			var reader = module.SymbolReader;
+			if (reader == null)
+				throw new InvalidOperationException ();
+
+			if (module.Image != null && module.Image.HasDebugTables ())
+				return null;
+
+			return reader.GetWriterProvider ().GetSymbolWriter (module, fileName);
+		}
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
+#endif
+}
+
+namespace Mono.Cecil {
+
+	static partial class Mixin {
+
+		public static ImageDebugHeaderEntry GetCodeViewEntry (this ImageDebugHeader header)
+		{
+			return GetEntry (header, ImageDebugType.CodeView);
+		}
+
+		public static ImageDebugHeaderEntry GetDeterministicEntry (this ImageDebugHeader header)
+		{
+			return GetEntry (header, ImageDebugType.Deterministic);
+		}
+
+		public static ImageDebugHeader AddDeterministicEntry (this ImageDebugHeader header)
+		{
+			var entry = new ImageDebugHeaderEntry (new ImageDebugDirectory { Type = ImageDebugType.Deterministic }, Empty<byte>.Array);
+			if (header == null)
+				return new ImageDebugHeader (entry);
+
+			var entries = new ImageDebugHeaderEntry [header.Entries.Length + 1];
+			Array.Copy (header.Entries, entries, header.Entries.Length);
+			entries [entries.Length - 1] = entry;
+			return new ImageDebugHeader (entries);
+		}
+
+		public static ImageDebugHeaderEntry GetEmbeddedPortablePdbEntry (this ImageDebugHeader header)
+		{
+			return GetEntry (header, ImageDebugType.EmbeddedPortablePdb);
+		}
+
+		private static ImageDebugHeaderEntry GetEntry (this ImageDebugHeader header, ImageDebugType type)
+		{
+			if (!header.HasEntries)
+				return null;
+
+			for (var i = 0; i < header.Entries.Length; i++) {
+				var entry = header.Entries [i];
+				if (entry.Directory.Type == type)
+					return entry;
+			}
+
+			return null;
+		}
+
+		public static string GetPdbFileName (string assemblyFileName)
+		{
+			return Path.ChangeExtension (assemblyFileName, ".pdb");
+		}
+
+		public static string GetMdbFileName (string assemblyFileName)
+		{
+			return assemblyFileName + ".mdb";
+		}
+
+		public static bool IsPortablePdb (string fileName)
+		{
+			using (var file = new FileStream (fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+				return IsPortablePdb (file);
+		}
+
+		public static bool IsPortablePdb (Stream stream)
+		{
+			const uint ppdb_signature = 0x424a5342;
+
+			if (stream.Length < 4) return false;
+			var position = stream.Position;
+			try {
+				var reader = new BinaryReader (stream);
+				return reader.ReadUInt32 () == ppdb_signature;
+			} finally {
+				stream.Position = position;
+			}
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/VariableDefinition.cs b/src/Mono/Cecil/Cil/VariableDefinition.cs
new file mode 100644
index 00000000..bd132846
--- /dev/null
+++ b/src/Mono/Cecil/Cil/VariableDefinition.cs
@@ -0,0 +1,29 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Cil {
+
+	public sealed class VariableDefinition : VariableReference {
+
+		public bool IsPinned {
+			get { return variable_type.IsPinned; }
+		}
+
+		public VariableDefinition (TypeReference variableType)
+			: base (variableType)
+		{
+		}
+
+		public override VariableDefinition Resolve ()
+		{
+			return this;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Cil/VariableReference.cs b/src/Mono/Cecil/Cil/VariableReference.cs
new file mode 100644
index 00000000..fb12e8c1
--- /dev/null
+++ b/src/Mono/Cecil/Cil/VariableReference.cs
@@ -0,0 +1,42 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Cil {
+
+	public abstract class VariableReference {
+
+		internal int index = -1;
+		protected TypeReference variable_type;
+
+		public TypeReference VariableType {
+			get { return variable_type; }
+			set { variable_type = value; }
+		}
+
+		public int Index {
+			get { return index; }
+		}
+
+		internal VariableReference (TypeReference variable_type)
+		{
+			this.variable_type = variable_type;
+		}
+
+		public abstract VariableDefinition Resolve ();
+
+		public override string ToString ()
+		{
+			if (index >= 0)
+				return "V_" + index;
+
+			return string.Empty;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Consts.cs b/src/Mono/Cecil/Consts.cs
new file mode 100644
index 00000000..3b80461c
--- /dev/null
+++ b/src/Mono/Cecil/Consts.cs
@@ -0,0 +1,5 @@
+static class Consts
+{
+	public const string AssemblyName = "Mono.Cecil";
+	public const string PublicKey = "00240000048000009400000006020000002400005253413100040000010001002b5c9f7f04346c324a3176f8d3ee823bbf2d60efdbc35f86fd9e65ea3e6cd11bcdcba3a353e55133c8ac5c4caaba581b2c6dfff2cc2d0edc43959ddb86b973300a479a82419ef489c3225f1fe429a708507bd515835160e10bc743d20ca33ab9570cfd68d479fcf0bc797a763bec5d1000f0159ef619e709d915975e87beebaf";
+}
\ No newline at end of file
diff --git a/src/Mono/Cecil/CustomAttribute.cs b/src/Mono/Cecil/CustomAttribute.cs
new file mode 100644
index 00000000..d64411fc
--- /dev/null
+++ b/src/Mono/Cecil/CustomAttribute.cs
@@ -0,0 +1,205 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Diagnostics;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public struct CustomAttributeArgument {
+
+		readonly TypeReference type;
+		readonly object value;
+
+		public TypeReference Type {
+			get { return type; }
+		}
+
+		public object Value {
+			get { return value; }
+		}
+
+		public CustomAttributeArgument (TypeReference type, object value)
+		{
+			Mixin.CheckType (type);
+			this.type = type;
+			this.value = value;
+		}
+	}
+
+	public struct CustomAttributeNamedArgument {
+
+		readonly string name;
+		readonly CustomAttributeArgument argument;
+
+		public string Name {
+			get { return name; }
+		}
+
+		public CustomAttributeArgument Argument {
+			get { return argument; }
+		}
+
+		public CustomAttributeNamedArgument (string name, CustomAttributeArgument argument)
+		{
+			Mixin.CheckName (name);
+			this.name = name;
+			this.argument = argument;
+		}
+	}
+
+	public interface ICustomAttribute {
+
+		TypeReference AttributeType { get; }
+
+		bool HasFields { get; }
+		bool HasProperties { get; }
+		bool HasConstructorArguments { get; }
+		Collection<CustomAttributeNamedArgument> Fields { get; }
+		Collection<CustomAttributeNamedArgument> Properties { get; }
+		Collection<CustomAttributeArgument> ConstructorArguments { get; }
+	}
+
+	[DebuggerDisplay ("{AttributeType}")]
+	public sealed class CustomAttribute : ICustomAttribute {
+
+		internal CustomAttributeValueProjection projection;
+		readonly internal uint signature;
+		internal bool resolved;
+		MethodReference constructor;
+		byte [] blob;
+		internal Collection<CustomAttributeArgument> arguments;
+		internal Collection<CustomAttributeNamedArgument> fields;
+		internal Collection<CustomAttributeNamedArgument> properties;
+
+		public MethodReference Constructor {
+			get { return constructor; }
+			set { constructor = value; }
+		}
+
+		public TypeReference AttributeType {
+			get { return constructor.DeclaringType; }
+		}
+
+		public bool IsResolved {
+			get { return resolved; }
+		}
+
+		public bool HasConstructorArguments {
+			get {
+				Resolve ();
+
+				return !arguments.IsNullOrEmpty ();
+			}
+		}
+
+		public Collection<CustomAttributeArgument> ConstructorArguments {
+			get {
+				Resolve ();
+
+				return arguments ?? (arguments = new Collection<CustomAttributeArgument> ());
+			}
+		}
+
+		public bool HasFields {
+			get {
+				Resolve ();
+
+				return !fields.IsNullOrEmpty ();
+			}
+		}
+
+		public Collection<CustomAttributeNamedArgument> Fields {
+			get {
+				Resolve ();
+
+				return fields ?? (fields = new Collection<CustomAttributeNamedArgument> ());
+			}
+		}
+
+		public bool HasProperties {
+			get {
+				Resolve ();
+
+				return !properties.IsNullOrEmpty ();
+			}
+		}
+
+		public Collection<CustomAttributeNamedArgument> Properties {
+			get {
+				Resolve ();
+
+				return properties ?? (properties = new Collection<CustomAttributeNamedArgument> ());
+			}
+		}
+
+		internal bool HasImage {
+			get { return constructor != null && constructor.HasImage; }
+		}
+
+		internal ModuleDefinition Module {
+			get { return constructor.Module; }
+		}
+
+		internal CustomAttribute (uint signature, MethodReference constructor)
+		{
+			this.signature = signature;
+			this.constructor = constructor;
+			this.resolved = false;
+		}
+
+		public CustomAttribute (MethodReference constructor)
+		{
+			this.constructor = constructor;
+			this.resolved = true;
+		}
+
+		public CustomAttribute (MethodReference constructor, byte [] blob)
+		{
+			this.constructor = constructor;
+			this.resolved = false;
+			this.blob = blob;
+		}
+
+		public byte [] GetBlob ()
+		{
+			if (blob != null)
+				return blob;
+
+			if (!HasImage)
+				throw new NotSupportedException ();
+
+			return Module.Read (ref blob, this, (attribute, reader) => reader.ReadCustomAttributeBlob (attribute.signature));
+		}
+
+		void Resolve ()
+		{
+			if (resolved || !HasImage)
+				return;
+
+			Module.Read (this, (attribute, reader) => {
+				try {
+					reader.ReadCustomAttributeSignature (attribute);
+					resolved = true;
+				} catch (ResolutionException) {
+					if (arguments != null)
+						arguments.Clear ();
+					if (fields != null)
+						fields.Clear ();
+					if (properties != null)
+						properties.Clear ();
+
+					resolved = false;
+				}
+			});
+		}
+	}
+}
diff --git a/src/Mono/Cecil/DefaultAssemblyResolver.cs b/src/Mono/Cecil/DefaultAssemblyResolver.cs
new file mode 100644
index 00000000..755071ea
--- /dev/null
+++ b/src/Mono/Cecil/DefaultAssemblyResolver.cs
@@ -0,0 +1,61 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public class DefaultAssemblyResolver : BaseAssemblyResolver {
+
+		readonly IDictionary<string, AssemblyDefinition> cache;
+
+		public DefaultAssemblyResolver ()
+		{
+			cache = new Dictionary<string, AssemblyDefinition> (StringComparer.Ordinal);
+		}
+
+		public override AssemblyDefinition Resolve (AssemblyNameReference name)
+		{
+			Mixin.CheckName (name);
+
+			AssemblyDefinition assembly;
+			if (cache.TryGetValue (name.FullName, out assembly))
+				return assembly;
+
+			assembly = base.Resolve (name);
+			cache [name.FullName] = assembly;
+
+			return assembly;
+		}
+
+		protected void RegisterAssembly (AssemblyDefinition assembly)
+		{
+			if (assembly == null)
+				throw new ArgumentNullException ("assembly");
+
+			var name = assembly.Name.FullName;
+			if (cache.ContainsKey (name))
+				return;
+
+			cache [name] = assembly;
+		}
+
+		protected override void Dispose (bool disposing)
+		{
+			foreach (var assembly in cache.Values)
+				assembly.Dispose ();
+
+			cache.Clear ();
+
+			base.Dispose (disposing);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/EmbeddedResource.cs b/src/Mono/Cecil/EmbeddedResource.cs
new file mode 100644
index 00000000..6b5f86a1
--- /dev/null
+++ b/src/Mono/Cecil/EmbeddedResource.cs
@@ -0,0 +1,98 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.IO;
+
+namespace Mono.Cecil {
+
+	public sealed class EmbeddedResource : Resource {
+
+		readonly MetadataReader reader;
+
+		uint? offset;
+		byte [] data;
+		Stream stream;
+
+		public override ResourceType ResourceType {
+			get { return ResourceType.Embedded; }
+		}
+
+		public EmbeddedResource (string name, ManifestResourceAttributes attributes, byte [] data) :
+			base (name, attributes)
+		{
+			this.data = data;
+		}
+
+		public EmbeddedResource (string name, ManifestResourceAttributes attributes, Stream stream) :
+			base (name, attributes)
+		{
+			this.stream = stream;
+		}
+
+		internal EmbeddedResource (string name, ManifestResourceAttributes attributes, uint offset, MetadataReader reader)
+			: base (name, attributes)
+		{
+			this.offset = offset;
+			this.reader = reader;
+		}
+
+		public Stream GetResourceStream ()
+		{
+			if (stream != null)
+				return stream;
+
+			if (data != null)
+				return new MemoryStream (data);
+
+			if (offset.HasValue)
+				return new MemoryStream (reader.GetManagedResource (offset.Value));
+
+			throw new InvalidOperationException ();
+		}
+
+		public byte [] GetResourceData ()
+		{
+			if (stream != null)
+				return ReadStream (stream);
+
+			if (data != null)
+				return data;
+
+			if (offset.HasValue)
+				return reader.GetManagedResource (offset.Value);
+
+			throw new InvalidOperationException ();
+		}
+
+		static byte [] ReadStream (Stream stream)
+		{
+			int read;
+
+			if (stream.CanSeek) {
+				var length = (int) stream.Length;
+				var data = new byte [length];
+				int offset = 0;
+
+				while ((read = stream.Read (data, offset, length - offset)) > 0)
+					offset += read;
+
+				return data;
+			}
+
+			var buffer = new byte [1024 * 8];
+			var memory = new MemoryStream ();
+			while ((read = stream.Read (buffer, 0, buffer.Length)) > 0)
+				memory.Write (buffer, 0, read);
+
+			return memory.ToArray ();
+		}
+	}
+}
diff --git a/src/Mono/Cecil/EventAttributes.cs b/src/Mono/Cecil/EventAttributes.cs
new file mode 100644
index 00000000..9f823fd1
--- /dev/null
+++ b/src/Mono/Cecil/EventAttributes.cs
@@ -0,0 +1,21 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum EventAttributes : ushort {
+		None			= 0x0000,
+		SpecialName		= 0x0200,	// Event is special
+		RTSpecialName	= 0x0400	 // CLI provides 'special' behavior, depending upon the name of the event
+	}
+}
diff --git a/src/Mono/Cecil/EventDefinition.cs b/src/Mono/Cecil/EventDefinition.cs
new file mode 100644
index 00000000..33bc341a
--- /dev/null
+++ b/src/Mono/Cecil/EventDefinition.cs
@@ -0,0 +1,155 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class EventDefinition : EventReference, IMemberDefinition {
+
+		ushort attributes;
+
+		Collection<CustomAttribute> custom_attributes;
+
+		internal MethodDefinition add_method;
+		internal MethodDefinition invoke_method;
+		internal MethodDefinition remove_method;
+		internal Collection<MethodDefinition> other_methods;
+
+		public EventAttributes Attributes {
+			get { return (EventAttributes) attributes; }
+			set { attributes = (ushort) value; }
+		}
+
+		public MethodDefinition AddMethod {
+			get {
+				if (add_method != null)
+					return add_method;
+
+				InitializeMethods ();
+				return add_method;
+			}
+			set { add_method = value; }
+		}
+
+		public MethodDefinition InvokeMethod {
+			get {
+				if (invoke_method != null)
+					return invoke_method;
+
+				InitializeMethods ();
+				return invoke_method;
+			}
+			set { invoke_method = value; }
+		}
+
+		public MethodDefinition RemoveMethod {
+			get {
+				if (remove_method != null)
+					return remove_method;
+
+				InitializeMethods ();
+				return remove_method;
+			}
+			set { remove_method = value; }
+		}
+
+		public bool HasOtherMethods {
+			get {
+				if (other_methods != null)
+					return other_methods.Count > 0;
+
+				InitializeMethods ();
+				return !other_methods.IsNullOrEmpty ();
+			}
+		}
+
+		public Collection<MethodDefinition> OtherMethods {
+			get {
+				if (other_methods != null)
+					return other_methods;
+
+				InitializeMethods ();
+
+				if (other_methods != null)
+					return other_methods;
+
+				return other_methods = new Collection<MethodDefinition> ();
+			}
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, Module)); }
+		}
+
+		#region EventAttributes
+
+		public bool IsSpecialName {
+			get { return attributes.GetAttributes ((ushort) EventAttributes.SpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) EventAttributes.SpecialName, value); }
+		}
+
+		public bool IsRuntimeSpecialName {
+			get { return attributes.GetAttributes ((ushort) EventAttributes.RTSpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) EventAttributes.RTSpecialName, value); }
+		}
+
+		#endregion
+
+		public new TypeDefinition DeclaringType {
+			get { return (TypeDefinition) base.DeclaringType; }
+			set { base.DeclaringType = value; }
+		}
+
+		public override bool IsDefinition {
+			get { return true; }
+		}
+
+		public EventDefinition (string name, EventAttributes attributes, TypeReference eventType)
+			: base (name, eventType)
+		{
+			this.attributes = (ushort) attributes;
+			this.token = new MetadataToken (TokenType.Event);
+		}
+
+		void InitializeMethods ()
+		{
+			var module = this.Module;
+			if (module == null)
+				return;
+
+			lock (module.SyncRoot) {
+				if (add_method != null
+					|| invoke_method != null
+					|| remove_method != null)
+					return;
+
+				if (!module.HasImage ())
+					return;
+
+				module.Read (this, (@event, reader) => reader.ReadMethods (@event));
+			}
+		}
+
+		public override EventDefinition Resolve ()
+		{
+			return this;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/EventReference.cs b/src/Mono/Cecil/EventReference.cs
new file mode 100644
index 00000000..d4df72b4
--- /dev/null
+++ b/src/Mono/Cecil/EventReference.cs
@@ -0,0 +1,42 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public abstract class EventReference : MemberReference {
+
+		TypeReference event_type;
+
+		public TypeReference EventType {
+			get { return event_type; }
+			set { event_type = value; }
+		}
+
+		public override string FullName {
+			get { return event_type.FullName + " " + MemberFullName (); }
+		}
+
+		protected EventReference (string name, TypeReference eventType)
+			: base (name)
+		{
+			Mixin.CheckType (eventType, Mixin.Argument.eventType);
+			event_type = eventType;
+		}
+
+		protected override IMemberDefinition ResolveDefinition ()
+		{
+			return this.Resolve ();
+		}
+
+		public new abstract EventDefinition Resolve ();
+	}
+}
diff --git a/src/Mono/Cecil/ExportedType.cs b/src/Mono/Cecil/ExportedType.cs
new file mode 100644
index 00000000..8238a0c6
--- /dev/null
+++ b/src/Mono/Cecil/ExportedType.cs
@@ -0,0 +1,240 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public sealed class ExportedType : IMetadataTokenProvider {
+
+		string @namespace;
+		string name;
+		uint attributes;
+		IMetadataScope scope;
+		ModuleDefinition module;
+		int identifier;
+		ExportedType declaring_type;
+		internal MetadataToken token;
+
+		public string Namespace {
+			get { return @namespace; }
+			set { @namespace = value; }
+		}
+
+		public string Name {
+			get { return name; }
+			set { name = value; }
+		}
+
+		public TypeAttributes Attributes {
+			get { return (TypeAttributes) attributes; }
+			set { attributes = (uint) value; }
+		}
+
+		public IMetadataScope Scope {
+			get {
+				if (declaring_type != null)
+					return declaring_type.Scope;
+
+				return scope;
+			}
+			set {
+				if (declaring_type != null) {
+					declaring_type.Scope = value;
+					return;
+				}
+
+				scope = value;
+			}
+		}
+
+		public ExportedType DeclaringType {
+			get { return declaring_type; }
+			set { declaring_type = value; }
+		}
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		public int Identifier {
+			get { return identifier; }
+			set { identifier = value; }
+		}
+
+		#region TypeAttributes
+
+		public bool IsNotPublic {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NotPublic); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NotPublic, value); }
+		}
+
+		public bool IsPublic {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.Public); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.Public, value); }
+		}
+
+		public bool IsNestedPublic {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPublic); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPublic, value); }
+		}
+
+		public bool IsNestedPrivate {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPrivate); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPrivate, value); }
+		}
+
+		public bool IsNestedFamily {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamily); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamily, value); }
+		}
+
+		public bool IsNestedAssembly {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedAssembly); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedAssembly, value); }
+		}
+
+		public bool IsNestedFamilyAndAssembly {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamANDAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamANDAssem, value); }
+		}
+
+		public bool IsNestedFamilyOrAssembly {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamORAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamORAssem, value); }
+		}
+
+		public bool IsAutoLayout {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.AutoLayout); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.AutoLayout, value); }
+		}
+
+		public bool IsSequentialLayout {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.SequentialLayout); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.SequentialLayout, value); }
+		}
+
+		public bool IsExplicitLayout {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.ExplicitLayout); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.ExplicitLayout, value); }
+		}
+
+		public bool IsClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Class); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Class, value); }
+		}
+
+		public bool IsInterface {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Interface); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Interface, value); }
+		}
+
+		public bool IsAbstract {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Abstract); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Abstract, value); }
+		}
+
+		public bool IsSealed {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Sealed); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Sealed, value); }
+		}
+
+		public bool IsSpecialName {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.SpecialName); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.SpecialName, value); }
+		}
+
+		public bool IsImport {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Import); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Import, value); }
+		}
+
+		public bool IsSerializable {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Serializable); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Serializable, value); }
+		}
+
+		public bool IsAnsiClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AnsiClass); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AnsiClass, value); }
+		}
+
+		public bool IsUnicodeClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.UnicodeClass); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.UnicodeClass, value); }
+		}
+
+		public bool IsAutoClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AutoClass); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AutoClass, value); }
+		}
+
+		public bool IsBeforeFieldInit {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.BeforeFieldInit); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.BeforeFieldInit, value); }
+		}
+
+		public bool IsRuntimeSpecialName {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.RTSpecialName); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.RTSpecialName, value); }
+		}
+
+		public bool HasSecurity {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.HasSecurity); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.HasSecurity, value); }
+		}
+
+		#endregion
+
+		public bool IsForwarder {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Forwarder); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Forwarder, value); }
+		}
+
+		public string FullName {
+			get {
+				var fullname = string.IsNullOrEmpty (@namespace)
+					? name
+					: @namespace + '.' + name;
+
+				if (declaring_type != null)
+					return declaring_type.FullName + "/" + fullname;
+
+				return fullname;
+			}
+		}
+
+		public ExportedType (string @namespace, string name, ModuleDefinition module, IMetadataScope scope)
+		{
+			this.@namespace = @namespace;
+			this.name = name;
+			this.scope = scope;
+			this.module = module;
+		}
+
+		public override string ToString ()
+		{
+			return FullName;
+		}
+
+		public TypeDefinition Resolve ()
+		{
+			return module.Resolve (CreateReference ());
+		}
+
+		internal TypeReference CreateReference ()
+		{
+			return new TypeReference (@namespace, name, module, scope) {
+				DeclaringType = declaring_type != null ? declaring_type.CreateReference () : null,
+			};
+		}
+	}
+}
diff --git a/src/Mono/Cecil/FieldAttributes.cs b/src/Mono/Cecil/FieldAttributes.cs
new file mode 100644
index 00000000..7d5bb544
--- /dev/null
+++ b/src/Mono/Cecil/FieldAttributes.cs
@@ -0,0 +1,41 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum FieldAttributes : ushort {
+		FieldAccessMask		= 0x0007,
+		CompilerControlled	= 0x0000,	// Member not referenceable
+		Private				= 0x0001,	// Accessible only by the parent type
+		FamANDAssem			= 0x0002,	// Accessible by sub-types only in this assembly
+		Assembly			= 0x0003,	// Accessible by anyone in the Assembly
+		Family				= 0x0004,	// Accessible only by type and sub-types
+		FamORAssem			= 0x0005,	// Accessible by sub-types anywhere, plus anyone in the assembly
+		Public				= 0x0006,	// Accessible by anyone who has visibility to this scope field contract attributes
+
+		Static				= 0x0010,	// Defined on type, else per instance
+		InitOnly			= 0x0020,	// Field may only be initialized, not written after init
+		Literal				= 0x0040,	// Value is compile time constant
+		NotSerialized		= 0x0080,	// Field does not have to be serialized when type is remoted
+		SpecialName			= 0x0200,	// Field is special
+
+		// Interop Attributes
+		PInvokeImpl			= 0x2000,	// Implementation is forwarded through PInvoke
+
+		// Additional flags
+		RTSpecialName		= 0x0400,	// CLI provides 'special' behavior, depending upon the name of the field
+		HasFieldMarshal		= 0x1000,	// Field has marshalling information
+		HasDefault			= 0x8000,	// Field has default
+		HasFieldRVA			= 0x0100	 // Field has RVA
+	}
+}
diff --git a/src/Mono/Cecil/FieldDefinition.cs b/src/Mono/Cecil/FieldDefinition.cs
new file mode 100644
index 00000000..593b77e5
--- /dev/null
+++ b/src/Mono/Cecil/FieldDefinition.cs
@@ -0,0 +1,267 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class FieldDefinition : FieldReference, IMemberDefinition, IConstantProvider, IMarshalInfoProvider {
+
+		ushort attributes;
+		Collection<CustomAttribute> custom_attributes;
+
+		int offset = Mixin.NotResolvedMarker;
+
+		internal int rva = Mixin.NotResolvedMarker;
+		byte [] initial_value;
+
+		object constant = Mixin.NotResolved;
+
+		MarshalInfo marshal_info;
+
+		void ResolveLayout ()
+		{
+			if (offset != Mixin.NotResolvedMarker)
+				return;
+
+			if (!HasImage) {
+				offset = Mixin.NoDataMarker;
+				return;
+			}
+
+			offset = Module.Read (this, (field, reader) => reader.ReadFieldLayout (field));
+		}
+
+		public bool HasLayoutInfo {
+			get {
+				if (offset >= 0)
+					return true;
+
+				ResolveLayout ();
+
+				return offset >= 0;
+			}
+		}
+
+		public int Offset {
+			get {
+				if (offset >= 0)
+					return offset;
+
+				ResolveLayout ();
+
+				return offset >= 0 ? offset : -1;
+			}
+			set { offset = value; }
+		}
+
+		internal new FieldDefinitionProjection WindowsRuntimeProjection {
+			get { return (FieldDefinitionProjection) projection; }
+			set { projection = value; }
+		}
+
+		void ResolveRVA ()
+		{
+			if (rva != Mixin.NotResolvedMarker)
+				return;
+
+			if (!HasImage)
+				return;
+
+			rva = Module.Read (this, (field, reader) => reader.ReadFieldRVA (field));
+		}
+
+		public int RVA {
+			get {
+				if (rva > 0)
+					return rva;
+
+				ResolveRVA ();
+
+				return rva > 0 ? rva : 0;
+			}
+		}
+
+		public byte [] InitialValue {
+			get {
+				if (initial_value != null)
+					return initial_value;
+
+				ResolveRVA ();
+
+				if (initial_value == null)
+					initial_value = Empty<byte>.Array;
+
+				return initial_value;
+			}
+			set {
+				initial_value = value;
+				rva = 0;
+			}
+		}
+
+		public FieldAttributes Attributes {
+			get { return (FieldAttributes) attributes; }
+			set {
+				if (IsWindowsRuntimeProjection && (ushort) value != attributes)
+					throw new InvalidOperationException ();
+
+				attributes = (ushort) value;
+			}
+		}
+
+		public bool HasConstant {
+			get {
+				this.ResolveConstant (ref constant, Module);
+
+				return constant != Mixin.NoValue;
+			}
+			set { if (!value) constant = Mixin.NoValue; }
+		}
+
+		public object Constant {
+			get { return HasConstant ? constant : null;	}
+			set { constant = value; }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, Module)); }
+		}
+
+		public bool HasMarshalInfo {
+			get {
+				if (marshal_info != null)
+					return true;
+
+				return this.GetHasMarshalInfo (Module);
+			}
+		}
+
+		public MarshalInfo MarshalInfo {
+			get { return marshal_info ?? (this.GetMarshalInfo (ref marshal_info, Module)); }
+			set { marshal_info = value; }
+		}
+
+		#region FieldAttributes
+
+		public bool IsCompilerControlled {
+			get { return attributes.GetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.CompilerControlled); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.CompilerControlled, value); }
+		}
+
+		public bool IsPrivate {
+			get { return attributes.GetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Private); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Private, value); }
+		}
+
+		public bool IsFamilyAndAssembly {
+			get { return attributes.GetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.FamANDAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.FamANDAssem, value); }
+		}
+
+		public bool IsAssembly {
+			get { return attributes.GetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Assembly); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Assembly, value); }
+		}
+
+		public bool IsFamily {
+			get { return attributes.GetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Family); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Family, value); }
+		}
+
+		public bool IsFamilyOrAssembly {
+			get { return attributes.GetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.FamORAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.FamORAssem, value); }
+		}
+
+		public bool IsPublic {
+			get { return attributes.GetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Public); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) FieldAttributes.FieldAccessMask, (ushort) FieldAttributes.Public, value); }
+		}
+
+		public bool IsStatic {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.Static); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.Static, value); }
+		}
+
+		public bool IsInitOnly {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.InitOnly); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.InitOnly, value); }
+		}
+
+		public bool IsLiteral {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.Literal); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.Literal, value); }
+		}
+
+		public bool IsNotSerialized {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.NotSerialized); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.NotSerialized, value); }
+		}
+
+		public bool IsSpecialName {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.SpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.SpecialName, value); }
+		}
+
+		public bool IsPInvokeImpl {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.PInvokeImpl); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.PInvokeImpl, value); }
+		}
+
+		public bool IsRuntimeSpecialName {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.RTSpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.RTSpecialName, value); }
+		}
+
+		public bool HasDefault {
+			get { return attributes.GetAttributes ((ushort) FieldAttributes.HasDefault); }
+			set { attributes = attributes.SetAttributes ((ushort) FieldAttributes.HasDefault, value); }
+		}
+
+		#endregion
+
+		public override bool IsDefinition {
+			get { return true; }
+		}
+
+		public new TypeDefinition DeclaringType {
+			get { return (TypeDefinition) base.DeclaringType; }
+			set { base.DeclaringType = value; }
+		}
+
+		public FieldDefinition (string name, FieldAttributes attributes, TypeReference fieldType)
+			: base (name, fieldType)
+		{
+			this.attributes = (ushort) attributes;
+		}
+
+		public override FieldDefinition Resolve ()
+		{
+			return this;
+		}
+	}
+
+	static partial class Mixin {
+
+		public const int NotResolvedMarker = -2;
+		public const int NoDataMarker = -1;
+	}
+}
diff --git a/src/Mono/Cecil/FieldReference.cs b/src/Mono/Cecil/FieldReference.cs
new file mode 100644
index 00000000..944c2259
--- /dev/null
+++ b/src/Mono/Cecil/FieldReference.cs
@@ -0,0 +1,68 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public class FieldReference : MemberReference {
+
+		TypeReference field_type;
+
+		public TypeReference FieldType {
+			get { return field_type; }
+			set { field_type = value; }
+		}
+
+		public override string FullName {
+			get { return field_type.FullName + " " + MemberFullName (); }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return field_type.ContainsGenericParameter || base.ContainsGenericParameter; }
+		}
+
+		internal FieldReference ()
+		{
+			this.token = new MetadataToken (TokenType.MemberRef);
+		}
+
+		public FieldReference (string name, TypeReference fieldType)
+			: base (name)
+		{
+			Mixin.CheckType (fieldType, Mixin.Argument.fieldType);
+
+			this.field_type = fieldType;
+			this.token = new MetadataToken (TokenType.MemberRef);
+		}
+
+		public FieldReference (string name, TypeReference fieldType, TypeReference declaringType)
+			: this (name, fieldType)
+		{
+			Mixin.CheckType (declaringType, Mixin.Argument.declaringType);
+
+			this.DeclaringType = declaringType;
+		}
+
+		protected override IMemberDefinition ResolveDefinition ()
+		{
+			return this.Resolve ();
+		}
+
+		public new virtual FieldDefinition Resolve ()
+		{
+			var module = this.Module;
+			if (module == null)
+				throw new NotSupportedException ();
+
+			return module.Resolve (this);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/FileAttributes.cs b/src/Mono/Cecil/FileAttributes.cs
new file mode 100644
index 00000000..171f174b
--- /dev/null
+++ b/src/Mono/Cecil/FileAttributes.cs
@@ -0,0 +1,17 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	enum FileAttributes : uint {
+		ContainsMetaData	= 0x0000,	// This is not a resource file
+		ContainsNoMetaData  = 0x0001,	// This is a resource file or other non-metadata-containing file
+	}
+}
diff --git a/src/Mono/Cecil/FunctionPointerType.cs b/src/Mono/Cecil/FunctionPointerType.cs
new file mode 100644
index 00000000..0602fcbe
--- /dev/null
+++ b/src/Mono/Cecil/FunctionPointerType.cs
@@ -0,0 +1,111 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+using Mono.Collections.Generic;
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public sealed class FunctionPointerType : TypeSpecification, IMethodSignature {
+
+		readonly MethodReference function;
+
+		public bool HasThis {
+			get { return function.HasThis; }
+			set { function.HasThis = value; }
+		}
+
+		public bool ExplicitThis {
+			get { return function.ExplicitThis; }
+			set { function.ExplicitThis = value; }
+		}
+
+		public MethodCallingConvention CallingConvention {
+			get { return function.CallingConvention; }
+			set { function.CallingConvention = value; }
+		}
+
+		public bool HasParameters {
+			get { return function.HasParameters; }
+		}
+
+		public Collection<ParameterDefinition> Parameters {
+			get { return function.Parameters; }
+		}
+
+		public TypeReference ReturnType {
+			get { return function.MethodReturnType.ReturnType; }
+			set { function.MethodReturnType.ReturnType = value; }
+		}
+
+		public MethodReturnType MethodReturnType {
+			get { return function.MethodReturnType; }
+		}
+
+		public override string Name {
+			get { return function.Name; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override string Namespace {
+			get { return string.Empty; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override ModuleDefinition Module {
+			get { return ReturnType.Module; }
+		}
+
+		public override IMetadataScope Scope {
+			get { return function.ReturnType.Scope; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool IsFunctionPointer {
+			get { return true; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return function.ContainsGenericParameter; }
+		}
+
+		public override string FullName {
+			get {
+				var signature = new StringBuilder ();
+				signature.Append (function.Name);
+				signature.Append (" ");
+				signature.Append (function.ReturnType.FullName);
+				signature.Append (" *");
+				this.MethodSignatureFullName (signature);
+				return signature.ToString ();
+			}
+		}
+
+		public FunctionPointerType ()
+			: base (null)
+		{
+			this.function = new MethodReference ();
+			this.function.Name = "method";
+			this.etype = MD.ElementType.FnPtr;
+		}
+
+		public override TypeDefinition Resolve ()
+		{
+			return null;
+		}
+
+		public override TypeReference GetElementType ()
+		{
+			return this;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/GenericInstanceMethod.cs b/src/Mono/Cecil/GenericInstanceMethod.cs
new file mode 100644
index 00000000..00de03a3
--- /dev/null
+++ b/src/Mono/Cecil/GenericInstanceMethod.cs
@@ -0,0 +1,67 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class GenericInstanceMethod : MethodSpecification, IGenericInstance, IGenericContext {
+
+		Collection<TypeReference> arguments;
+
+		public bool HasGenericArguments {
+			get { return !arguments.IsNullOrEmpty (); }
+		}
+
+		public Collection<TypeReference> GenericArguments {
+			get { return arguments ?? (arguments = new Collection<TypeReference> ()); }
+		}
+
+		public override bool IsGenericInstance {
+			get { return true; }
+		}
+
+		IGenericParameterProvider IGenericContext.Method {
+			get { return ElementMethod; }
+		}
+
+		IGenericParameterProvider IGenericContext.Type {
+			get { return ElementMethod.DeclaringType; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return this.ContainsGenericParameter () || base.ContainsGenericParameter; }
+		}
+
+		public override string FullName {
+			get {
+				var signature = new StringBuilder ();
+				var method = this.ElementMethod;
+				signature.Append (method.ReturnType.FullName)
+					.Append (" ")
+					.Append (method.DeclaringType.FullName)
+					.Append ("::")
+					.Append (method.Name);
+				this.GenericInstanceFullName (signature);
+				this.MethodSignatureFullName (signature);
+				return signature.ToString ();
+
+			}
+		}
+
+		public GenericInstanceMethod (MethodReference method)
+			: base (method)
+		{
+		}
+	}
+}
diff --git a/src/Mono/Cecil/GenericInstanceType.cs b/src/Mono/Cecil/GenericInstanceType.cs
new file mode 100644
index 00000000..0e683e71
--- /dev/null
+++ b/src/Mono/Cecil/GenericInstanceType.cs
@@ -0,0 +1,65 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+
+using Mono.Collections.Generic;
+
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public sealed class GenericInstanceType : TypeSpecification, IGenericInstance, IGenericContext {
+
+		Collection<TypeReference> arguments;
+
+		public bool HasGenericArguments {
+			get { return !arguments.IsNullOrEmpty (); }
+		}
+
+		public Collection<TypeReference> GenericArguments {
+			get { return arguments ?? (arguments = new Collection<TypeReference> ()); }
+		}
+
+		public override TypeReference DeclaringType {
+			get { return ElementType.DeclaringType; }
+			set { throw new NotSupportedException (); }
+		}
+
+		public override string FullName {
+			get {
+				var name = new StringBuilder ();
+				name.Append (base.FullName);
+				this.GenericInstanceFullName (name);
+				return name.ToString ();
+			}
+		}
+
+		public override bool IsGenericInstance {
+			get { return true; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return this.ContainsGenericParameter () || base.ContainsGenericParameter; }
+		}
+
+		IGenericParameterProvider IGenericContext.Type {
+			get { return ElementType; }
+		}
+
+		public GenericInstanceType (TypeReference type)
+			: base (type)
+		{
+			base.IsValueType = type.IsValueType;
+			this.etype = MD.ElementType.GenericInst;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/GenericParameter.cs b/src/Mono/Cecil/GenericParameter.cs
new file mode 100644
index 00000000..f2997da6
--- /dev/null
+++ b/src/Mono/Cecil/GenericParameter.cs
@@ -0,0 +1,268 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Collections.Generic;
+
+using Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public sealed class GenericParameter : TypeReference, ICustomAttributeProvider {
+
+		internal int position;
+		internal GenericParameterType type;
+		internal IGenericParameterProvider owner;
+
+		ushort attributes;
+		Collection<TypeReference> constraints;
+		Collection<CustomAttribute> custom_attributes;
+
+		public GenericParameterAttributes Attributes {
+			get { return (GenericParameterAttributes) attributes; }
+			set { attributes = (ushort) value; }
+		}
+
+		public int Position {
+			get { return position; }
+		}
+
+		public GenericParameterType Type {
+			get { return type; }
+		}
+
+		public IGenericParameterProvider Owner {
+			get { return owner; }
+		}
+
+		public bool HasConstraints {
+			get {
+				if (constraints != null)
+					return constraints.Count > 0;
+
+				return HasImage && Module.Read (this, (generic_parameter, reader) => reader.HasGenericConstraints (generic_parameter));
+			}
+		}
+
+		public Collection<TypeReference> Constraints {
+			get {
+				if (constraints != null)
+					return constraints;
+
+				if (HasImage)
+					return Module.Read (ref constraints, this, (generic_parameter, reader) => reader.ReadGenericConstraints (generic_parameter));
+
+				return constraints = new Collection<TypeReference> ();
+			}
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, Module)); }
+		}
+
+		public override IMetadataScope Scope {
+			get {
+				if (owner == null)
+					return null;
+
+				return owner.GenericParameterType == GenericParameterType.Method
+					? ((MethodReference) owner).DeclaringType.Scope
+					: ((TypeReference) owner).Scope;
+			}
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override TypeReference DeclaringType {
+			get { return owner as TypeReference; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public MethodReference DeclaringMethod {
+			get { return owner as MethodReference; }
+		}
+
+		public override ModuleDefinition Module {
+			get { return module ?? owner.Module; }
+		}
+
+		public override string Name {
+			get {
+				if (!string.IsNullOrEmpty (base.Name))
+					return base.Name;
+
+				return base.Name = (type == GenericParameterType.Method ? "!!" : "!") + position;
+			}
+		}
+
+		public override string Namespace {
+			get { return string.Empty; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override string FullName {
+			get { return Name; }
+		}
+
+		public override bool IsGenericParameter {
+			get { return true; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return true; }
+		}
+
+		public override MetadataType MetadataType {
+			get { return (MetadataType) etype; }
+		}
+
+		#region GenericParameterAttributes
+
+		public bool IsNonVariant {
+			get { return attributes.GetMaskedAttributes ((ushort) GenericParameterAttributes.VarianceMask, (ushort) GenericParameterAttributes.NonVariant); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) GenericParameterAttributes.VarianceMask, (ushort) GenericParameterAttributes.NonVariant, value); }
+		}
+
+		public bool IsCovariant {
+			get { return attributes.GetMaskedAttributes ((ushort) GenericParameterAttributes.VarianceMask, (ushort) GenericParameterAttributes.Covariant); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) GenericParameterAttributes.VarianceMask, (ushort) GenericParameterAttributes.Covariant, value); }
+		}
+
+		public bool IsContravariant {
+			get { return attributes.GetMaskedAttributes ((ushort) GenericParameterAttributes.VarianceMask, (ushort) GenericParameterAttributes.Contravariant); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) GenericParameterAttributes.VarianceMask, (ushort) GenericParameterAttributes.Contravariant, value); }
+		}
+
+		public bool HasReferenceTypeConstraint {
+			get { return attributes.GetAttributes ((ushort) GenericParameterAttributes.ReferenceTypeConstraint); }
+			set { attributes = attributes.SetAttributes ((ushort) GenericParameterAttributes.ReferenceTypeConstraint, value); }
+		}
+
+		public bool HasNotNullableValueTypeConstraint {
+			get { return attributes.GetAttributes ((ushort) GenericParameterAttributes.NotNullableValueTypeConstraint); }
+			set { attributes = attributes.SetAttributes ((ushort) GenericParameterAttributes.NotNullableValueTypeConstraint, value); }
+		}
+
+		public bool HasDefaultConstructorConstraint {
+			get { return attributes.GetAttributes ((ushort) GenericParameterAttributes.DefaultConstructorConstraint); }
+			set { attributes = attributes.SetAttributes ((ushort) GenericParameterAttributes.DefaultConstructorConstraint, value); }
+		}
+
+		#endregion
+
+		public GenericParameter (IGenericParameterProvider owner)
+			: this (string.Empty, owner)
+		{
+		}
+
+		public GenericParameter (string name, IGenericParameterProvider owner)
+			: base (string.Empty, name)
+		{
+			if (owner == null)
+				throw new ArgumentNullException ();
+
+			this.position = -1;
+			this.owner = owner;
+			this.type = owner.GenericParameterType;
+			this.etype = ConvertGenericParameterType (this.type);
+			this.token = new MetadataToken (TokenType.GenericParam);
+
+		}
+
+		internal GenericParameter (int position, GenericParameterType type, ModuleDefinition module)
+			: base (string.Empty, string.Empty)
+		{
+			Mixin.CheckModule (module);
+
+			this.position = position;
+			this.type = type;
+			this.etype = ConvertGenericParameterType (type);
+			this.module = module;
+			this.token = new MetadataToken (TokenType.GenericParam);
+		}
+
+		static ElementType ConvertGenericParameterType (GenericParameterType type)
+		{
+			switch (type) {
+			case GenericParameterType.Type:
+				return ElementType.Var;
+			case GenericParameterType.Method:
+				return ElementType.MVar;
+			}
+
+			throw new ArgumentOutOfRangeException ();
+		}
+
+		public override TypeDefinition Resolve ()
+		{
+			return null;
+		}
+	}
+
+	sealed class GenericParameterCollection : Collection<GenericParameter> {
+
+		readonly IGenericParameterProvider owner;
+
+		internal GenericParameterCollection (IGenericParameterProvider owner)
+		{
+			this.owner = owner;
+		}
+
+		internal GenericParameterCollection (IGenericParameterProvider owner, int capacity)
+			: base (capacity)
+		{
+			this.owner = owner;
+		}
+
+		protected override void OnAdd (GenericParameter item, int index)
+		{
+			UpdateGenericParameter (item, index);
+		}
+
+		protected override void OnInsert (GenericParameter item, int index)
+		{
+			UpdateGenericParameter (item, index);
+
+			for (int i = index; i < size; i++)
+				items[i].position = i + 1;
+		}
+
+		protected override void OnSet (GenericParameter item, int index)
+		{
+			UpdateGenericParameter (item, index);
+		}
+
+		void UpdateGenericParameter (GenericParameter item, int index)
+		{
+			item.owner = owner;
+			item.position = index;
+			item.type = owner.GenericParameterType;
+		}
+
+		protected override void OnRemove (GenericParameter item, int index)
+		{
+			item.owner = null;
+			item.position = -1;
+			item.type = GenericParameterType.Type;
+
+			for (int i = index + 1; i < size; i++)
+				items[i].position = i - 1;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/GenericParameterAttributes.cs b/src/Mono/Cecil/GenericParameterAttributes.cs
new file mode 100644
index 00000000..149582cd
--- /dev/null
+++ b/src/Mono/Cecil/GenericParameterAttributes.cs
@@ -0,0 +1,27 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum GenericParameterAttributes : ushort {
+		VarianceMask	= 0x0003,
+		NonVariant		= 0x0000,
+		Covariant		= 0x0001,
+		Contravariant	= 0x0002,
+
+		SpecialConstraintMask			= 0x001c,
+		ReferenceTypeConstraint			= 0x0004,
+		NotNullableValueTypeConstraint	= 0x0008,
+		DefaultConstructorConstraint	= 0x0010
+	}
+}
diff --git a/src/Mono/Cecil/IConstantProvider.cs b/src/Mono/Cecil/IConstantProvider.cs
new file mode 100644
index 00000000..178b6651
--- /dev/null
+++ b/src/Mono/Cecil/IConstantProvider.cs
@@ -0,0 +1,44 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public interface IConstantProvider : IMetadataTokenProvider {
+
+		bool HasConstant { get; set; }
+		object Constant { get; set; }
+	}
+
+	static partial class Mixin {
+
+		internal static object NoValue = new object ();
+		internal static object NotResolved = new object ();
+
+		public static void ResolveConstant (
+			this IConstantProvider self,
+			ref object constant,
+			ModuleDefinition module)
+		{
+			if (module == null) {
+				constant = Mixin.NoValue;
+				return;
+			}
+
+			lock (module.SyncRoot) {
+				if (constant != Mixin.NotResolved)
+					return;
+				if (module.HasImage ())
+					constant = module.Read (self, (provider, reader) => reader.ReadConstant (provider));
+				else
+					constant = Mixin.NoValue;
+			}
+		}
+	}
+}
diff --git a/src/Mono/Cecil/ICustomAttributeProvider.cs b/src/Mono/Cecil/ICustomAttributeProvider.cs
new file mode 100644
index 00000000..36d7ed01
--- /dev/null
+++ b/src/Mono/Cecil/ICustomAttributeProvider.cs
@@ -0,0 +1,42 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public interface ICustomAttributeProvider : IMetadataTokenProvider {
+
+		Collection<CustomAttribute> CustomAttributes { get; }
+
+		bool HasCustomAttributes { get; }
+	}
+
+	static partial class Mixin {
+
+		public static bool GetHasCustomAttributes (
+			this ICustomAttributeProvider self,
+			ModuleDefinition module)
+		{
+			return module.HasImage () && module.Read (self, (provider, reader) => reader.HasCustomAttributes (provider));
+		}
+
+		public static Collection<CustomAttribute> GetCustomAttributes (
+			this ICustomAttributeProvider self,
+			ref Collection<CustomAttribute> variable,
+			ModuleDefinition module)
+		{
+			return module.HasImage ()
+				? module.Read (ref variable, self, (provider, reader) => reader.ReadCustomAttributes (provider))
+				: variable = new Collection<CustomAttribute>();
+		}
+	}
+}
diff --git a/src/Mono/Cecil/IGenericInstance.cs b/src/Mono/Cecil/IGenericInstance.cs
new file mode 100644
index 00000000..e98d8189
--- /dev/null
+++ b/src/Mono/Cecil/IGenericInstance.cs
@@ -0,0 +1,48 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System.Text;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public interface IGenericInstance : IMetadataTokenProvider {
+
+		bool HasGenericArguments { get; }
+		Collection<TypeReference> GenericArguments { get; }
+	}
+
+	static partial class Mixin {
+
+		public static bool ContainsGenericParameter (this IGenericInstance self)
+		{
+			var arguments = self.GenericArguments;
+
+			for (int i = 0; i < arguments.Count; i++)
+				if (arguments [i].ContainsGenericParameter)
+					return true;
+
+			return false;
+		}
+
+		public static void GenericInstanceFullName (this IGenericInstance self, StringBuilder builder)
+		{
+			builder.Append ("<");
+			var arguments = self.GenericArguments;
+			for (int i = 0; i < arguments.Count; i++) {
+				if (i > 0)
+					builder.Append (",");
+				builder.Append (arguments [i].FullName);
+			}
+			builder.Append (">");
+		}
+	}
+}
diff --git a/src/Mono/Cecil/IGenericParameterProvider.cs b/src/Mono/Cecil/IGenericParameterProvider.cs
new file mode 100644
index 00000000..4c8dfc4d
--- /dev/null
+++ b/src/Mono/Cecil/IGenericParameterProvider.cs
@@ -0,0 +1,56 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public interface IGenericParameterProvider : IMetadataTokenProvider {
+
+		bool HasGenericParameters { get; }
+		bool IsDefinition { get; }
+		ModuleDefinition Module { get; }
+		Collection<GenericParameter> GenericParameters { get; }
+		GenericParameterType GenericParameterType { get; }
+	}
+
+	public enum GenericParameterType {
+		Type,
+		Method
+	}
+
+	interface IGenericContext {
+
+		bool IsDefinition { get; }
+		IGenericParameterProvider Type { get; }
+		IGenericParameterProvider Method { get; }
+	}
+
+	static partial class Mixin {
+
+		public static bool GetHasGenericParameters (
+			this IGenericParameterProvider self,
+			ModuleDefinition module)
+		{
+			return module.HasImage () && module.Read (self, (provider, reader) => reader.HasGenericParameters (provider));
+		}
+
+		public static Collection<GenericParameter> GetGenericParameters (
+			this IGenericParameterProvider self,
+			ref Collection<GenericParameter> collection,
+			ModuleDefinition module)
+		{
+			return module.HasImage ()
+				? module.Read (ref collection, self, (provider, reader) => reader.ReadGenericParameters (provider))
+				: collection = new GenericParameterCollection (self);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/IMarshalInfoProvider.cs b/src/Mono/Cecil/IMarshalInfoProvider.cs
new file mode 100644
index 00000000..a1b9e883
--- /dev/null
+++ b/src/Mono/Cecil/IMarshalInfoProvider.cs
@@ -0,0 +1,38 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public interface IMarshalInfoProvider : IMetadataTokenProvider {
+
+		bool HasMarshalInfo { get; }
+		MarshalInfo MarshalInfo { get; set; }
+	}
+
+	static partial class Mixin {
+
+		public static bool GetHasMarshalInfo (
+			this IMarshalInfoProvider self,
+			ModuleDefinition module)
+		{
+			return module.HasImage () && module.Read (self, (provider, reader) => reader.HasMarshalInfo (provider));
+		}
+
+		public static MarshalInfo GetMarshalInfo (
+			this IMarshalInfoProvider self,
+			ref MarshalInfo variable,
+			ModuleDefinition module)
+		{
+			return module.HasImage ()
+				? module.Read (ref variable, self, (provider, reader) => reader.ReadMarshalInfo (provider))
+				: null;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/IMemberDefinition.cs b/src/Mono/Cecil/IMemberDefinition.cs
new file mode 100644
index 00000000..ad747002
--- /dev/null
+++ b/src/Mono/Cecil/IMemberDefinition.cs
@@ -0,0 +1,82 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public interface IMemberDefinition : ICustomAttributeProvider {
+
+		string Name { get; set; }
+		string FullName { get; }
+
+		bool IsSpecialName { get; set; }
+		bool IsRuntimeSpecialName { get; set; }
+
+		TypeDefinition DeclaringType { get; set; }
+	}
+
+	static partial class Mixin {
+
+		public static bool GetAttributes (this uint self, uint attributes)
+		{
+			return (self & attributes) != 0;
+		}
+
+		public static uint SetAttributes (this uint self, uint attributes, bool value)
+		{
+			if (value)
+				return self | attributes;
+
+			return self & ~attributes;
+		}
+
+		public static bool GetMaskedAttributes (this uint self, uint mask, uint attributes)
+		{
+			return (self & mask) == attributes;
+		}
+
+		public static uint SetMaskedAttributes (this uint self, uint mask, uint attributes, bool value)
+		{
+			if (value) {
+				self &= ~mask;
+				return self | attributes;
+			}
+
+			return self & ~(mask & attributes);
+		}
+
+		public static bool GetAttributes (this ushort self, ushort attributes)
+		{
+			return (self & attributes) != 0;
+		}
+
+		public static ushort SetAttributes (this ushort self, ushort attributes, bool value)
+		{
+			if (value)
+				return (ushort) (self | attributes);
+
+			return (ushort) (self & ~attributes);
+		}
+
+		public static bool GetMaskedAttributes (this ushort self, ushort mask, uint attributes)
+		{
+			return (self & mask) == attributes;
+		}
+
+		public static ushort SetMaskedAttributes (this ushort self, ushort mask, uint attributes, bool value)
+		{
+			if (value) {
+				self = (ushort) (self & ~mask);
+				return (ushort) (self | attributes);
+			}
+
+			return (ushort) (self & ~(mask & attributes));
+		}
+	}
+}
diff --git a/src/Mono/Cecil/IMetadataScope.cs b/src/Mono/Cecil/IMetadataScope.cs
new file mode 100644
index 00000000..2e56e758
--- /dev/null
+++ b/src/Mono/Cecil/IMetadataScope.cs
@@ -0,0 +1,23 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum MetadataScopeType {
+		AssemblyNameReference,
+		ModuleReference,
+		ModuleDefinition,
+	}
+
+	public interface IMetadataScope : IMetadataTokenProvider {
+		MetadataScopeType MetadataScopeType { get; }
+		string Name { get; set; }
+	}
+}
diff --git a/src/Mono/Cecil/IMetadataTokenProvider.cs b/src/Mono/Cecil/IMetadataTokenProvider.cs
new file mode 100644
index 00000000..dcd678b0
--- /dev/null
+++ b/src/Mono/Cecil/IMetadataTokenProvider.cs
@@ -0,0 +1,17 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public interface IMetadataTokenProvider {
+
+		MetadataToken MetadataToken { get; set; }
+	}
+}
diff --git a/src/Mono/Cecil/IMethodSignature.cs b/src/Mono/Cecil/IMethodSignature.cs
new file mode 100644
index 00000000..4d7766e4
--- /dev/null
+++ b/src/Mono/Cecil/IMethodSignature.cs
@@ -0,0 +1,57 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System.Text;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public interface IMethodSignature : IMetadataTokenProvider {
+
+		bool HasThis { get; set; }
+		bool ExplicitThis { get; set; }
+		MethodCallingConvention CallingConvention { get; set; }
+
+		bool HasParameters { get; }
+		Collection<ParameterDefinition> Parameters { get; }
+		TypeReference ReturnType { get; set; }
+		MethodReturnType MethodReturnType { get; }
+	}
+
+	static partial class Mixin {
+
+		public static bool HasImplicitThis (this IMethodSignature self)
+		{
+			return self.HasThis && !self.ExplicitThis;
+		}
+
+		public static void MethodSignatureFullName (this IMethodSignature self, StringBuilder builder)
+		{
+			builder.Append ("(");
+
+			if (self.HasParameters) {
+				var parameters = self.Parameters;
+				for (int i = 0; i < parameters.Count; i++) {
+					var parameter = parameters [i];
+					if (i > 0)
+						builder.Append (",");
+
+					if (parameter.ParameterType.IsSentinel)
+						builder.Append ("...,");
+
+					builder.Append (parameter.ParameterType.FullName);
+				}
+			}
+
+			builder.Append (")");
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Import.cs b/src/Mono/Cecil/Import.cs
new file mode 100644
index 00000000..6b5644a4
--- /dev/null
+++ b/src/Mono/Cecil/Import.cs
@@ -0,0 +1,829 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using Mono.Collections.Generic;
+using SR = System.Reflection;
+
+using Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+#if !READ_ONLY
+
+	public interface IMetadataImporterProvider {
+		IMetadataImporter GetMetadataImporter (ModuleDefinition module);
+	}
+
+	public interface IMetadataImporter {
+		AssemblyNameReference ImportReference (AssemblyNameReference reference);
+		TypeReference ImportReference (TypeReference type, IGenericParameterProvider context);
+		FieldReference ImportReference (FieldReference field, IGenericParameterProvider context);
+		MethodReference ImportReference (MethodReference method, IGenericParameterProvider context);
+	}
+
+	public interface IReflectionImporterProvider {
+		IReflectionImporter GetReflectionImporter (ModuleDefinition module);
+	}
+
+	public interface IReflectionImporter {
+		AssemblyNameReference ImportReference (SR.AssemblyName reference);
+		TypeReference ImportReference (Type type, IGenericParameterProvider context);
+		FieldReference ImportReference (SR.FieldInfo field, IGenericParameterProvider context);
+		MethodReference ImportReference (SR.MethodBase method, IGenericParameterProvider context);
+	}
+
+	struct ImportGenericContext {
+
+		Collection<IGenericParameterProvider> stack;
+
+		public bool IsEmpty { get { return stack == null; } }
+
+		public ImportGenericContext (IGenericParameterProvider provider)
+		{
+			if (provider == null)
+				throw new ArgumentNullException ("provider");
+
+			stack = null;
+
+			Push (provider);
+		}
+
+		public void Push (IGenericParameterProvider provider)
+		{
+			if (stack == null)
+				stack = new Collection<IGenericParameterProvider> (1) { provider };
+			else
+				stack.Add (provider);
+		}
+
+		public void Pop ()
+		{
+			stack.RemoveAt (stack.Count - 1);
+		}
+
+		public TypeReference MethodParameter (string method, int position)
+		{
+			for (int i = stack.Count - 1; i >= 0; i--) {
+				var candidate = stack [i] as MethodReference;
+				if (candidate == null)
+					continue;
+
+				if (method != NormalizeMethodName (candidate))
+					continue;
+
+				return candidate.GenericParameters [position];
+			}
+
+			throw new InvalidOperationException ();
+		}
+
+		public string NormalizeMethodName (MethodReference method)
+		{
+			return method.DeclaringType.GetElementType ().FullName + "." + method.Name;
+		}
+
+		public TypeReference TypeParameter (string type, int position)
+		{
+			for (int i = stack.Count - 1; i >= 0; i--) {
+				var candidate = GenericTypeFor (stack [i]);
+
+				if (candidate.FullName != type)
+					continue;
+
+				return candidate.GenericParameters [position];
+			}
+
+			throw new InvalidOperationException ();
+		}
+
+		static TypeReference GenericTypeFor (IGenericParameterProvider context)
+		{
+			var type = context as TypeReference;
+			if (type != null)
+				return type.GetElementType ();
+
+			var method = context as MethodReference;
+			if (method != null)
+				return method.DeclaringType.GetElementType ();
+
+			throw new InvalidOperationException ();
+		}
+
+		public static ImportGenericContext For (IGenericParameterProvider context)
+		{
+			return context != null ? new ImportGenericContext (context) : default (ImportGenericContext);
+		}
+	}
+
+	public class DefaultReflectionImporter : IReflectionImporter {
+
+		readonly protected ModuleDefinition module;
+
+		public DefaultReflectionImporter (ModuleDefinition module)
+		{
+			Mixin.CheckModule (module);
+
+			this.module = module;
+		}
+
+		enum ImportGenericKind {
+			Definition,
+			Open,
+		}
+
+		static readonly Dictionary<Type, ElementType> type_etype_mapping = new Dictionary<Type, ElementType> (18) {
+			{ typeof (void), ElementType.Void },
+			{ typeof (bool), ElementType.Boolean },
+			{ typeof (char), ElementType.Char },
+			{ typeof (sbyte), ElementType.I1 },
+			{ typeof (byte), ElementType.U1 },
+			{ typeof (short), ElementType.I2 },
+			{ typeof (ushort), ElementType.U2 },
+			{ typeof (int), ElementType.I4 },
+			{ typeof (uint), ElementType.U4 },
+			{ typeof (long), ElementType.I8 },
+			{ typeof (ulong), ElementType.U8 },
+			{ typeof (float), ElementType.R4 },
+			{ typeof (double), ElementType.R8 },
+			{ typeof (string), ElementType.String },
+#if !NET_CORE
+			{ typeof (TypedReference), ElementType.TypedByRef },
+#endif
+			{ typeof (IntPtr), ElementType.I },
+			{ typeof (UIntPtr), ElementType.U },
+			{ typeof (object), ElementType.Object },
+		};
+
+		TypeReference ImportType (Type type, ImportGenericContext context)
+		{
+			return ImportType (type, context, ImportGenericKind.Open);
+		}
+
+		TypeReference ImportType (Type type, ImportGenericContext context, ImportGenericKind import_kind)
+		{
+			if (IsTypeSpecification (type) || ImportOpenGenericType (type, import_kind))
+				return ImportTypeSpecification (type, context);
+
+			var reference = new TypeReference (
+				string.Empty,
+				type.Name,
+				module,
+				ImportScope (type),
+				type.IsValueType ());
+
+			reference.etype = ImportElementType (type);
+
+			if (IsNestedType (type))
+				reference.DeclaringType = ImportType (type.DeclaringType, context, import_kind);
+			else
+				reference.Namespace = type.Namespace ?? string.Empty;
+
+			if (type.IsGenericType ())
+				ImportGenericParameters (reference, type.GetGenericArguments ());
+
+			return reference;
+		}
+
+		protected virtual IMetadataScope ImportScope (Type type)
+		{
+			return ImportScope (type.Assembly ());
+		}
+
+		static bool ImportOpenGenericType (Type type, ImportGenericKind import_kind)
+		{
+			return type.IsGenericType () && type.IsGenericTypeDefinition () && import_kind == ImportGenericKind.Open;
+		}
+
+		static bool ImportOpenGenericMethod (SR.MethodBase method, ImportGenericKind import_kind)
+		{
+			return method.IsGenericMethod && method.IsGenericMethodDefinition && import_kind == ImportGenericKind.Open;
+		}
+
+		static bool IsNestedType (Type type)
+		{
+			return type.IsNested;
+		}
+
+		TypeReference ImportTypeSpecification (Type type, ImportGenericContext context)
+		{
+			if (type.IsByRef)
+				return new ByReferenceType (ImportType (type.GetElementType (), context));
+
+			if (type.IsPointer)
+				return new PointerType (ImportType (type.GetElementType (), context));
+
+			if (type.IsArray)
+				return new ArrayType (ImportType (type.GetElementType (), context), type.GetArrayRank ());
+
+			if (type.IsGenericType ())
+				return ImportGenericInstance (type, context);
+
+			if (type.IsGenericParameter)
+				return ImportGenericParameter (type, context);
+
+			throw new NotSupportedException (type.FullName);
+		}
+
+		static TypeReference ImportGenericParameter (Type type, ImportGenericContext context)
+		{
+			if (context.IsEmpty)
+				throw new InvalidOperationException ();
+
+			if (type.DeclaringMethod () != null)
+				return context.MethodParameter (NormalizeMethodName (type.DeclaringMethod ()), type.GenericParameterPosition);
+
+			if (type.DeclaringType != null)
+				return context.TypeParameter (NormalizeTypeFullName (type.DeclaringType), type.GenericParameterPosition);
+
+			throw new InvalidOperationException();
+		}
+
+		static string NormalizeMethodName (SR.MethodBase method)
+		{
+			return NormalizeTypeFullName (method.DeclaringType) + "." + method.Name;
+		}
+
+		static string NormalizeTypeFullName (Type type)
+		{
+			if (IsNestedType (type))
+				return NormalizeTypeFullName (type.DeclaringType) + "/" + type.Name;
+
+			return type.FullName;
+		}
+
+		TypeReference ImportGenericInstance (Type type, ImportGenericContext context)
+		{
+			var element_type = ImportType (type.GetGenericTypeDefinition (), context, ImportGenericKind.Definition);
+			var instance = new GenericInstanceType (element_type);
+			var arguments = type.GetGenericArguments ();
+			var instance_arguments = instance.GenericArguments;
+
+			context.Push (element_type);
+			try {
+				for (int i = 0; i < arguments.Length; i++)
+					instance_arguments.Add (ImportType (arguments [i], context));
+
+				return instance;
+			} finally {
+				context.Pop ();
+			}
+		}
+
+		static bool IsTypeSpecification (Type type)
+		{
+			return type.HasElementType
+				|| IsGenericInstance (type)
+				|| type.IsGenericParameter;
+		}
+
+		static bool IsGenericInstance (Type type)
+		{
+			return type.IsGenericType () && !type.IsGenericTypeDefinition ();
+		}
+
+		static ElementType ImportElementType (Type type)
+		{
+			ElementType etype;
+			if (!type_etype_mapping.TryGetValue (type, out etype))
+				return ElementType.None;
+
+			return etype;
+		}
+
+		protected AssemblyNameReference ImportScope (SR.Assembly assembly)
+		{
+			return ImportReference (assembly.GetName ());
+		}
+
+		public virtual AssemblyNameReference ImportReference (SR.AssemblyName name)
+		{
+			Mixin.CheckName (name);
+
+			AssemblyNameReference reference;
+			if (TryGetAssemblyNameReference (name, out reference))
+				return reference;
+
+			reference = new AssemblyNameReference (name.Name, name.Version)
+			{
+				PublicKeyToken = name.GetPublicKeyToken (),
+#if !NET_CORE
+				Culture = name.CultureInfo.Name,
+				HashAlgorithm = (AssemblyHashAlgorithm) name.HashAlgorithm,
+#endif
+			};
+
+			module.AssemblyReferences.Add (reference);
+
+			return reference;
+		}
+
+		bool TryGetAssemblyNameReference (SR.AssemblyName name, out AssemblyNameReference assembly_reference)
+		{
+			var references = module.AssemblyReferences;
+
+			for (int i = 0; i < references.Count; i++) {
+				var reference = references [i];
+				if (name.FullName != reference.FullName) // TODO compare field by field
+					continue;
+
+				assembly_reference = reference;
+				return true;
+			}
+
+			assembly_reference = null;
+			return false;
+		}
+
+		FieldReference ImportField (SR.FieldInfo field, ImportGenericContext context)
+		{
+			var declaring_type = ImportType (field.DeclaringType, context);
+
+			if (IsGenericInstance (field.DeclaringType))
+				field = ResolveFieldDefinition (field);
+
+			context.Push (declaring_type);
+			try {
+				return new FieldReference {
+					Name = field.Name,
+					DeclaringType = declaring_type,
+					FieldType = ImportType (field.FieldType, context),
+				};
+			} finally {
+				context.Pop ();
+			}
+		}
+
+		static SR.FieldInfo ResolveFieldDefinition (SR.FieldInfo field)
+		{
+#if NET_CORE
+			throw new NotImplementedException ();
+#else
+			return field.Module.ResolveField (field.MetadataToken);
+#endif
+		}
+
+		static SR.MethodBase ResolveMethodDefinition (SR.MethodBase method)
+		{
+#if NET_CORE
+			throw new NotImplementedException ();
+#else
+			return method.Module.ResolveMethod (method.MetadataToken);
+#endif
+		}
+
+		MethodReference ImportMethod (SR.MethodBase method, ImportGenericContext context, ImportGenericKind import_kind)
+		{
+			if (IsMethodSpecification (method) || ImportOpenGenericMethod (method, import_kind))
+				return ImportMethodSpecification (method, context);
+
+			var declaring_type = ImportType (method.DeclaringType, context);
+
+			if (IsGenericInstance (method.DeclaringType))
+				method = ResolveMethodDefinition (method);
+
+			var reference = new MethodReference {
+				Name = method.Name,
+				HasThis = HasCallingConvention (method, SR.CallingConventions.HasThis),
+				ExplicitThis = HasCallingConvention (method, SR.CallingConventions.ExplicitThis),
+				DeclaringType = ImportType (method.DeclaringType, context, ImportGenericKind.Definition),
+			};
+
+			if (HasCallingConvention (method, SR.CallingConventions.VarArgs))
+				reference.CallingConvention &= MethodCallingConvention.VarArg;
+
+			if (method.IsGenericMethod)
+				ImportGenericParameters (reference, method.GetGenericArguments ());
+
+			context.Push (reference);
+			try {
+				var method_info = method as SR.MethodInfo;
+				reference.ReturnType = method_info != null
+					? ImportType (method_info.ReturnType, context)
+					: ImportType (typeof (void), default (ImportGenericContext));
+
+				var parameters = method.GetParameters ();
+				var reference_parameters = reference.Parameters;
+
+				for (int i = 0; i < parameters.Length; i++)
+					reference_parameters.Add (
+						new ParameterDefinition (ImportType (parameters [i].ParameterType, context)));
+
+				reference.DeclaringType = declaring_type;
+
+				return reference;
+			} finally {
+				context.Pop ();
+			}
+		}
+
+		static void ImportGenericParameters (IGenericParameterProvider provider, Type [] arguments)
+		{
+			var provider_parameters = provider.GenericParameters;
+
+			for (int i = 0; i < arguments.Length; i++)
+				provider_parameters.Add (new GenericParameter (arguments [i].Name, provider));
+		}
+
+		static bool IsMethodSpecification (SR.MethodBase method)
+		{
+			return method.IsGenericMethod && !method.IsGenericMethodDefinition;
+		}
+
+		MethodReference ImportMethodSpecification (SR.MethodBase method, ImportGenericContext context)
+		{
+			var method_info = method as SR.MethodInfo;
+			if (method_info == null)
+				throw new InvalidOperationException ();
+
+			var element_method = ImportMethod (method_info.GetGenericMethodDefinition (), context, ImportGenericKind.Definition);
+			var instance = new GenericInstanceMethod (element_method);
+			var arguments = method.GetGenericArguments ();
+			var instance_arguments = instance.GenericArguments;
+
+			context.Push (element_method);
+			try {
+				for (int i = 0; i < arguments.Length; i++)
+					instance_arguments.Add (ImportType (arguments [i], context));
+
+				return instance;
+			} finally {
+				context.Pop ();
+			}
+		}
+
+		static bool HasCallingConvention (SR.MethodBase method, SR.CallingConventions conventions)
+		{
+			return (method.CallingConvention & conventions) != 0;
+		}
+
+		public virtual TypeReference ImportReference (Type type, IGenericParameterProvider context)
+		{
+			Mixin.CheckType (type);
+			return ImportType (
+				type,
+				ImportGenericContext.For (context),
+				context != null ? ImportGenericKind.Open : ImportGenericKind.Definition);
+		}
+
+		public virtual FieldReference ImportReference (SR.FieldInfo field, IGenericParameterProvider context)
+		{
+			Mixin.CheckField (field);
+			return ImportField (field, ImportGenericContext.For (context));
+		}
+
+		public virtual MethodReference ImportReference (SR.MethodBase method, IGenericParameterProvider context)
+		{
+			Mixin.CheckMethod (method);
+			return ImportMethod (method,
+				ImportGenericContext.For (context),
+				context != null ? ImportGenericKind.Open : ImportGenericKind.Definition);
+		}
+	}
+
+	public class DefaultMetadataImporter : IMetadataImporter {
+
+		readonly protected ModuleDefinition module;
+
+		public DefaultMetadataImporter (ModuleDefinition module)
+		{
+			Mixin.CheckModule (module);
+
+			this.module = module;
+		}
+
+		TypeReference ImportType (TypeReference type, ImportGenericContext context)
+		{
+			if (type.IsTypeSpecification ())
+				return ImportTypeSpecification (type, context);
+
+			var reference = new TypeReference (
+				type.Namespace,
+				type.Name,
+				module,
+				ImportScope (type),
+				type.IsValueType);
+
+			MetadataSystem.TryProcessPrimitiveTypeReference (reference);
+
+			if (type.IsNested)
+				reference.DeclaringType = ImportType (type.DeclaringType, context);
+
+			if (type.HasGenericParameters)
+				ImportGenericParameters (reference, type);
+
+			return reference;
+		}
+
+		protected virtual IMetadataScope ImportScope (TypeReference type)
+		{
+			return ImportScope (type.Scope);
+		}
+
+		protected IMetadataScope ImportScope (IMetadataScope scope)
+		{
+			switch (scope.MetadataScopeType) {
+			case MetadataScopeType.AssemblyNameReference:
+				return ImportReference ((AssemblyNameReference) scope);
+			case MetadataScopeType.ModuleDefinition:
+				if (scope == module) return scope;
+				return ImportReference (((ModuleDefinition) scope).Assembly.Name);
+			case MetadataScopeType.ModuleReference:
+				throw new NotImplementedException ();
+			}
+
+			throw new NotSupportedException ();
+		}
+
+		public virtual AssemblyNameReference ImportReference (AssemblyNameReference name)
+		{
+			Mixin.CheckName (name);
+
+			AssemblyNameReference reference;
+			if (module.TryGetAssemblyNameReference (name, out reference))
+				return reference;
+
+			reference = new AssemblyNameReference (name.Name, name.Version) {
+				Culture = name.Culture,
+				HashAlgorithm = name.HashAlgorithm,
+				IsRetargetable = name.IsRetargetable,
+				IsWindowsRuntime = name.IsWindowsRuntime,
+			};
+
+			var pk_token = !name.PublicKeyToken.IsNullOrEmpty ()
+				? new byte [name.PublicKeyToken.Length]
+				: Empty<byte>.Array;
+
+			if (pk_token.Length > 0)
+				Buffer.BlockCopy (name.PublicKeyToken, 0, pk_token, 0, pk_token.Length);
+
+			reference.PublicKeyToken = pk_token;
+
+			module.AssemblyReferences.Add (reference);
+
+			return reference;
+		}
+
+		static void ImportGenericParameters (IGenericParameterProvider imported, IGenericParameterProvider original)
+		{
+			var parameters = original.GenericParameters;
+			var imported_parameters = imported.GenericParameters;
+
+			for (int i = 0; i < parameters.Count; i++)
+				imported_parameters.Add (new GenericParameter (parameters [i].Name, imported));
+		}
+
+		TypeReference ImportTypeSpecification (TypeReference type, ImportGenericContext context)
+		{
+			switch (type.etype) {
+			case ElementType.SzArray:
+				var vector = (ArrayType) type;
+				return new ArrayType (ImportType (vector.ElementType, context));
+			case ElementType.Ptr:
+				var pointer = (PointerType) type;
+				return new PointerType (ImportType (pointer.ElementType, context));
+			case ElementType.ByRef:
+				var byref = (ByReferenceType) type;
+				return new ByReferenceType (ImportType (byref.ElementType, context));
+			case ElementType.Pinned:
+				var pinned = (PinnedType) type;
+				return new PinnedType (ImportType (pinned.ElementType, context));
+			case ElementType.Sentinel:
+				var sentinel = (SentinelType) type;
+				return new SentinelType (ImportType (sentinel.ElementType, context));
+			case ElementType.FnPtr:
+				var fnptr = (FunctionPointerType) type;
+				var imported_fnptr = new FunctionPointerType () {
+					HasThis = fnptr.HasThis,
+					ExplicitThis = fnptr.ExplicitThis,
+					CallingConvention = fnptr.CallingConvention,
+					ReturnType = ImportType (fnptr.ReturnType, context),
+				};
+
+				if (!fnptr.HasParameters)
+					return imported_fnptr;
+
+				for (int i = 0; i < fnptr.Parameters.Count; i++)
+					imported_fnptr.Parameters.Add (new ParameterDefinition (
+						ImportType (fnptr.Parameters [i].ParameterType, context)));
+
+				return imported_fnptr;
+			case ElementType.CModOpt:
+				var modopt = (OptionalModifierType) type;
+				return new OptionalModifierType (
+					ImportType (modopt.ModifierType, context),
+					ImportType (modopt.ElementType, context));
+			case ElementType.CModReqD:
+				var modreq = (RequiredModifierType) type;
+				return new RequiredModifierType (
+					ImportType (modreq.ModifierType, context),
+					ImportType (modreq.ElementType, context));
+			case ElementType.Array:
+				var array = (ArrayType) type;
+				var imported_array = new ArrayType (ImportType (array.ElementType, context));
+				if (array.IsVector)
+					return imported_array;
+
+				var dimensions = array.Dimensions;
+				var imported_dimensions = imported_array.Dimensions;
+
+				imported_dimensions.Clear ();
+
+				for (int i = 0; i < dimensions.Count; i++) {
+					var dimension = dimensions [i];
+
+					imported_dimensions.Add (new ArrayDimension (dimension.LowerBound, dimension.UpperBound));
+				}
+
+				return imported_array;
+			case ElementType.GenericInst:
+				var instance = (GenericInstanceType) type;
+				var element_type = ImportType (instance.ElementType, context);
+				var imported_instance = new GenericInstanceType (element_type);
+
+				var arguments = instance.GenericArguments;
+				var imported_arguments = imported_instance.GenericArguments;
+
+				for (int i = 0; i < arguments.Count; i++)
+					imported_arguments.Add (ImportType (arguments [i], context));
+
+				return imported_instance;
+			case ElementType.Var:
+				var var_parameter = (GenericParameter) type;
+				if (var_parameter.DeclaringType == null)
+					throw new InvalidOperationException ();
+				return context.TypeParameter (var_parameter.DeclaringType.FullName, var_parameter.Position);
+			case ElementType.MVar:
+				var mvar_parameter = (GenericParameter) type;
+				if (mvar_parameter.DeclaringMethod == null)
+					throw new InvalidOperationException ();
+				return context.MethodParameter (context.NormalizeMethodName (mvar_parameter.DeclaringMethod), mvar_parameter.Position);
+			}
+
+			throw new NotSupportedException (type.etype.ToString ());
+		}
+
+		FieldReference ImportField (FieldReference field, ImportGenericContext context)
+		{
+			var declaring_type = ImportType (field.DeclaringType, context);
+
+			context.Push (declaring_type);
+			try {
+				return new FieldReference {
+					Name = field.Name,
+					DeclaringType = declaring_type,
+					FieldType = ImportType (field.FieldType, context),
+				};
+			} finally {
+				context.Pop ();
+			}
+		}
+
+		MethodReference ImportMethod (MethodReference method, ImportGenericContext context)
+		{
+			if (method.IsGenericInstance)
+				return ImportMethodSpecification (method, context);
+
+			var declaring_type = ImportType (method.DeclaringType, context);
+
+			var reference = new MethodReference {
+				Name = method.Name,
+				HasThis = method.HasThis,
+				ExplicitThis = method.ExplicitThis,
+				DeclaringType = declaring_type,
+				CallingConvention = method.CallingConvention,
+			};
+
+			if (method.HasGenericParameters)
+				ImportGenericParameters (reference, method);
+
+			context.Push (reference);
+			try {
+				reference.ReturnType = ImportType (method.ReturnType, context);
+
+				if (!method.HasParameters)
+					return reference;
+
+				var parameters = method.Parameters;
+				var reference_parameters = reference.parameters = new ParameterDefinitionCollection (reference, parameters.Count);
+				for (int i = 0; i < parameters.Count; i++)
+					reference_parameters.Add (
+						new ParameterDefinition (ImportType (parameters [i].ParameterType, context)));
+
+				return reference;
+			} finally {
+				context.Pop();
+			}
+		}
+
+		MethodSpecification ImportMethodSpecification (MethodReference method, ImportGenericContext context)
+		{
+			if (!method.IsGenericInstance)
+				throw new NotSupportedException ();
+
+			var instance = (GenericInstanceMethod) method;
+			var element_method = ImportMethod (instance.ElementMethod, context);
+			var imported_instance = new GenericInstanceMethod (element_method);
+
+			var arguments = instance.GenericArguments;
+			var imported_arguments = imported_instance.GenericArguments;
+
+			for (int i = 0; i < arguments.Count; i++)
+				imported_arguments.Add (ImportType (arguments [i], context));
+
+			return imported_instance;
+		}
+
+		public virtual TypeReference ImportReference (TypeReference type, IGenericParameterProvider context)
+		{
+			Mixin.CheckType (type);
+			return ImportType (type, ImportGenericContext.For (context));
+		}
+
+		public virtual FieldReference ImportReference (FieldReference field, IGenericParameterProvider context)
+		{
+			Mixin.CheckField (field);
+			return ImportField (field, ImportGenericContext.For (context));
+		}
+
+		public virtual MethodReference ImportReference (MethodReference method, IGenericParameterProvider context)
+		{
+			Mixin.CheckMethod (method);
+			return ImportMethod (method, ImportGenericContext.For (context));
+		}
+	}
+
+#endif
+
+	static partial class Mixin {
+
+		public static void CheckModule (ModuleDefinition module)
+		{
+			if (module == null)
+				throw new ArgumentNullException (Argument.module.ToString ());
+		}
+
+		public static bool TryGetAssemblyNameReference (this ModuleDefinition module, AssemblyNameReference name_reference, out AssemblyNameReference assembly_reference)
+		{
+			var references = module.AssemblyReferences;
+
+			for (int i = 0; i < references.Count; i++) {
+				var reference = references [i];
+				if (!Equals (name_reference, reference))
+					continue;
+
+				assembly_reference = reference;
+				return true;
+			}
+
+			assembly_reference = null;
+			return false;
+		}
+
+		static bool Equals (byte [] a, byte [] b)
+		{
+			if (ReferenceEquals (a, b))
+				return true;
+			if (a == null)
+				return false;
+			if (a.Length != b.Length)
+				return false;
+			for (int i = 0; i < a.Length; i++)
+				if (a [i] != b [i])
+					return false;
+			return true;
+		}
+
+		static bool Equals<T> (T a, T b) where T : class, IEquatable<T>
+		{
+			if (ReferenceEquals (a, b))
+				return true;
+			if (a == null)
+				return false;
+			return a.Equals (b);
+		}
+
+		static bool Equals (AssemblyNameReference a, AssemblyNameReference b)
+		{
+			if (ReferenceEquals (a, b))
+				return true;
+			if (a.Name != b.Name)
+				return false;
+			if (!Equals (a.Version, b.Version))
+				return false;
+			if (a.Culture != b.Culture)
+				return false;
+			if (!Equals (a.PublicKeyToken, b.PublicKeyToken))
+				return false;
+			return true;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/LinkedResource.cs b/src/Mono/Cecil/LinkedResource.cs
new file mode 100644
index 00000000..e53430ec
--- /dev/null
+++ b/src/Mono/Cecil/LinkedResource.cs
@@ -0,0 +1,42 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public sealed class LinkedResource : Resource {
+
+		internal byte [] hash;
+		string file;
+
+		public byte [] Hash {
+			get { return hash; }
+		}
+
+		public string File {
+			get { return file; }
+			set { file = value; }
+		}
+
+		public override ResourceType ResourceType {
+			get { return ResourceType.Linked; }
+		}
+
+		public LinkedResource (string name, ManifestResourceAttributes flags)
+			: base (name, flags)
+		{
+		}
+
+		public LinkedResource (string name, ManifestResourceAttributes flags, string file)
+			: base (name, flags)
+		{
+			this.file = file;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/ManifestResourceAttributes.cs b/src/Mono/Cecil/ManifestResourceAttributes.cs
new file mode 100644
index 00000000..03ccb6b4
--- /dev/null
+++ b/src/Mono/Cecil/ManifestResourceAttributes.cs
@@ -0,0 +1,21 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum ManifestResourceAttributes : uint {
+		VisibilityMask	= 0x0007,
+		Public			= 0x0001,	// The resource is exported from the Assembly
+		Private			= 0x0002	 // The resource is private to the Assembly
+	}
+}
diff --git a/src/Mono/Cecil/MarshalInfo.cs b/src/Mono/Cecil/MarshalInfo.cs
new file mode 100644
index 00000000..47d935e2
--- /dev/null
+++ b/src/Mono/Cecil/MarshalInfo.cs
@@ -0,0 +1,153 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public class MarshalInfo {
+
+		internal NativeType native;
+
+		public NativeType NativeType {
+			get { return native; }
+			set { native = value; }
+		}
+
+		public MarshalInfo (NativeType native)
+		{
+			this.native = native;
+		}
+	}
+
+	public sealed class ArrayMarshalInfo : MarshalInfo {
+
+		internal NativeType element_type;
+		internal int size_parameter_index;
+		internal int size;
+		internal int size_parameter_multiplier;
+
+		public NativeType ElementType {
+			get { return element_type; }
+			set { element_type = value; }
+		}
+
+		public int SizeParameterIndex {
+			get { return size_parameter_index; }
+			set { size_parameter_index = value; }
+		}
+
+		public int Size {
+			get { return size; }
+			set { size = value; }
+		}
+
+		public int SizeParameterMultiplier {
+			get { return size_parameter_multiplier; }
+			set { size_parameter_multiplier = value; }
+		}
+
+		public ArrayMarshalInfo ()
+			: base (NativeType.Array)
+		{
+			element_type = NativeType.None;
+			size_parameter_index = -1;
+			size = -1;
+			size_parameter_multiplier = -1;
+		}
+	}
+
+	public sealed class CustomMarshalInfo : MarshalInfo {
+
+		internal Guid guid;
+		internal string unmanaged_type;
+		internal TypeReference managed_type;
+		internal string cookie;
+
+		public Guid Guid {
+			get { return guid; }
+			set { guid = value; }
+		}
+
+		public string UnmanagedType {
+			get { return unmanaged_type; }
+			set { unmanaged_type = value; }
+		}
+
+		public TypeReference ManagedType {
+			get { return managed_type; }
+			set { managed_type = value; }
+		}
+
+		public string Cookie {
+			get { return cookie; }
+			set { cookie = value; }
+		}
+
+		public CustomMarshalInfo ()
+			: base (NativeType.CustomMarshaler)
+		{
+		}
+	}
+
+	public sealed class SafeArrayMarshalInfo : MarshalInfo {
+
+		internal VariantType element_type;
+
+		public VariantType ElementType {
+			get { return element_type; }
+			set { element_type = value; }
+		}
+
+		public SafeArrayMarshalInfo ()
+			: base (NativeType.SafeArray)
+		{
+			element_type = VariantType.None;
+		}
+	}
+
+	public sealed class FixedArrayMarshalInfo : MarshalInfo {
+
+		internal NativeType element_type;
+		internal int size;
+
+		public NativeType ElementType {
+			get { return element_type; }
+			set { element_type = value; }
+		}
+
+		public int Size {
+			get { return size; }
+			set { size = value; }
+		}
+
+		public FixedArrayMarshalInfo ()
+			: base (NativeType.FixedArray)
+		{
+			element_type = NativeType.None;
+		}
+	}
+
+	public sealed class FixedSysStringMarshalInfo : MarshalInfo {
+
+		internal int size;
+
+		public int Size {
+			get { return size; }
+			set { size = value; }
+		}
+
+		public FixedSysStringMarshalInfo ()
+			: base (NativeType.FixedSysString)
+		{
+			size = -1;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MemberDefinitionCollection.cs b/src/Mono/Cecil/MemberDefinitionCollection.cs
new file mode 100644
index 00000000..3872b2a9
--- /dev/null
+++ b/src/Mono/Cecil/MemberDefinitionCollection.cs
@@ -0,0 +1,74 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	sealed class MemberDefinitionCollection<T> : Collection<T> where T : IMemberDefinition {
+
+		TypeDefinition container;
+
+		internal MemberDefinitionCollection (TypeDefinition container)
+		{
+			this.container = container;
+		}
+
+		internal MemberDefinitionCollection (TypeDefinition container, int capacity)
+			: base (capacity)
+		{
+			this.container = container;
+		}
+
+		protected override void OnAdd (T item, int index)
+		{
+			Attach (item);
+		}
+
+		protected sealed override void OnSet (T item, int index)
+		{
+			Attach (item);
+		}
+
+		protected sealed override void OnInsert (T item, int index)
+		{
+			Attach (item);
+		}
+
+		protected sealed override void OnRemove (T item, int index)
+		{
+			Detach (item);
+		}
+
+		protected sealed override void OnClear ()
+		{
+			foreach (var definition in this)
+				Detach (definition);
+		}
+
+		void Attach (T element)
+		{
+			if (element.DeclaringType == container)
+				return;
+
+			if (element.DeclaringType != null)
+				throw new ArgumentException ("Member already attached");
+
+			element.DeclaringType = this.container;
+		}
+
+		static void Detach (T element)
+		{
+			element.DeclaringType = null;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MemberReference.cs b/src/Mono/Cecil/MemberReference.cs
new file mode 100644
index 00000000..84fd38c5
--- /dev/null
+++ b/src/Mono/Cecil/MemberReference.cs
@@ -0,0 +1,107 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public abstract class MemberReference : IMetadataTokenProvider {
+
+		string name;
+		TypeReference declaring_type;
+
+		internal MetadataToken token;
+		internal object projection;
+
+		public virtual string Name {
+			get { return name; }
+			set {
+				if (IsWindowsRuntimeProjection && value != name)
+					throw new InvalidOperationException ();
+
+				name = value;
+			}
+		}
+
+		public abstract string FullName {
+			get;
+		}
+
+		public virtual TypeReference DeclaringType {
+			get { return declaring_type; }
+			set { declaring_type = value; }
+		}
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		public bool IsWindowsRuntimeProjection {
+			get { return projection != null; }
+		}
+
+		internal MemberReferenceProjection WindowsRuntimeProjection {
+			get { return (MemberReferenceProjection) projection; }
+			set { projection = value; }
+		}
+
+		internal bool HasImage {
+			get {
+				var module = Module;
+				if (module == null)
+					return false;
+
+				return module.HasImage;
+			}
+		}
+
+		public virtual ModuleDefinition Module {
+			get { return declaring_type != null ? declaring_type.Module : null; }
+		}
+
+		public virtual bool IsDefinition {
+			get { return false; }
+		}
+
+		public virtual bool ContainsGenericParameter {
+			get { return declaring_type != null && declaring_type.ContainsGenericParameter; }
+		}
+
+		internal MemberReference ()
+		{
+		}
+
+		internal MemberReference (string name)
+		{
+			this.name = name ?? string.Empty;
+		}
+
+		internal string MemberFullName ()
+		{
+			if (declaring_type == null)
+				return name;
+
+			return declaring_type.FullName + "::" + name;
+		}
+
+		public IMemberDefinition Resolve ()
+		{
+			return ResolveDefinition ();
+		}
+
+		protected abstract IMemberDefinition ResolveDefinition ();
+
+		public override string ToString ()
+		{
+			return FullName;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/BlobHeap.cs b/src/Mono/Cecil/Metadata/BlobHeap.cs
new file mode 100644
index 00000000..574a130c
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/BlobHeap.cs
@@ -0,0 +1,54 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil.Metadata {
+
+	sealed class BlobHeap : Heap {
+
+		public BlobHeap (byte [] data)
+			: base (data)
+		{
+		}
+
+		public byte [] Read (uint index)
+		{
+			if (index == 0 || index > this.data.Length - 1)
+				return Empty<byte>.Array;
+
+			int position = (int) index;
+			int length = (int) data.ReadCompressedUInt32 (ref position);
+
+			if (length > data.Length - position)
+				return Empty<byte>.Array;
+
+			var buffer = new byte [length];
+
+			Buffer.BlockCopy (data, position, buffer, 0, length);
+
+			return buffer;
+		}
+
+		public void GetView (uint signature, out byte [] buffer, out int index, out int length)
+		{
+			if (signature == 0 || signature > data.Length - 1) {
+				buffer = null;
+				index = length = 0;
+				return;
+			}
+
+			buffer = data;
+
+			index = (int) signature;
+			length = (int) buffer.ReadCompressedUInt32 (ref index);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/Buffers.cs b/src/Mono/Cecil/Metadata/Buffers.cs
new file mode 100644
index 00000000..d87cb2a2
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/Buffers.cs
@@ -0,0 +1,505 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using Mono.Cecil.PE;
+
+using RVA = System.UInt32;
+
+#if !READ_ONLY
+
+namespace Mono.Cecil.Metadata {
+
+	sealed class TableHeapBuffer : HeapBuffer {
+
+		readonly ModuleDefinition module;
+		readonly MetadataBuilder metadata;
+
+		readonly internal TableInformation [] table_infos = new TableInformation [Mixin.TableCount];
+		readonly internal MetadataTable [] tables = new MetadataTable [Mixin.TableCount];
+
+		bool large_string;
+		bool large_blob;
+		bool large_guid;
+
+		readonly int [] coded_index_sizes = new int [Mixin.CodedIndexCount];
+		readonly Func<Table, int> counter;
+
+		internal uint [] string_offsets;
+
+		public override bool IsEmpty {
+			get { return false; }
+		}
+
+		public TableHeapBuffer (ModuleDefinition module, MetadataBuilder metadata)
+			: base (24)
+		{
+			this.module = module;
+			this.metadata = metadata;
+			this.counter = GetTableLength;
+		}
+
+		int GetTableLength (Table table)
+		{
+			return (int) table_infos [(int) table].Length;
+		}
+
+		public TTable GetTable<TTable> (Table table) where TTable : MetadataTable, new ()
+		{
+			var md_table = (TTable) tables [(int) table];
+			if (md_table != null)
+				return md_table;
+
+			md_table = new TTable ();
+			tables [(int) table] = md_table;
+			return md_table;
+		}
+
+		public void WriteBySize (uint value, int size)
+		{
+			if (size == 4)
+				WriteUInt32 (value);
+			else
+				WriteUInt16 ((ushort) value);
+		}
+
+		public void WriteBySize (uint value, bool large)
+		{
+			if (large)
+				WriteUInt32 (value);
+			else
+				WriteUInt16 ((ushort) value);
+		}
+
+		public void WriteString (uint @string)
+		{
+			WriteBySize (string_offsets [@string], large_string);
+		}
+
+		public void WriteBlob (uint blob)
+		{
+			WriteBySize (blob, large_blob);
+		}
+
+		public void WriteGuid (uint guid)
+		{
+			WriteBySize (guid, large_guid);
+		}
+
+		public void WriteRID (uint rid, Table table)
+		{
+			WriteBySize (rid, table_infos [(int) table].IsLarge);
+		}
+
+		int GetCodedIndexSize (CodedIndex coded_index)
+		{
+			var index = (int) coded_index;
+			var size = coded_index_sizes [index];
+			if (size != 0)
+				return size;
+
+			return coded_index_sizes [index] = coded_index.GetSize (counter);
+		}
+
+		public void WriteCodedRID (uint rid, CodedIndex coded_index)
+		{
+			WriteBySize (rid, GetCodedIndexSize (coded_index));
+		}
+
+		public void WriteTableHeap ()
+		{
+			WriteUInt32 (0);					// Reserved
+			WriteByte (GetTableHeapVersion ());	// MajorVersion
+			WriteByte (0);						// MinorVersion
+			WriteByte (GetHeapSizes ());		// HeapSizes
+			WriteByte (10);						// Reserved2
+			WriteUInt64 (GetValid ());			// Valid
+			WriteUInt64 (0xc416003301fa00);		// Sorted
+
+			WriteRowCount ();
+			WriteTables ();
+		}
+
+		void WriteRowCount ()
+		{
+			for (int i = 0; i < tables.Length; i++) {
+				var table = tables [i];
+				if (table == null || table.Length == 0)
+					continue;
+
+				WriteUInt32 ((uint) table.Length);
+			}
+		}
+
+		void WriteTables ()
+		{
+			for (int i = 0; i < tables.Length; i++) {
+				var table = tables [i];
+				if (table == null || table.Length == 0)
+					continue;
+
+				table.Write (this);
+			}
+		}
+
+		ulong GetValid ()
+		{
+			ulong valid = 0;
+
+			for (int i = 0; i < tables.Length; i++) {
+				var table = tables [i];
+				if (table == null || table.Length == 0)
+					continue;
+
+				table.Sort ();
+				valid |= (1UL << i);
+			}
+
+			return valid;
+		}
+
+		public void ComputeTableInformations ()
+		{
+			if (metadata.metadata_builder != null)
+				ComputeTableInformations (metadata.metadata_builder.table_heap);
+
+			ComputeTableInformations (metadata.table_heap);
+		}
+
+		void ComputeTableInformations (TableHeapBuffer table_heap)
+		{
+			var tables = table_heap.tables;
+			for (int i = 0; i < tables.Length; i++) {
+				var table = tables [i];
+				if (table != null && table.Length > 0)
+					table_infos [i].Length = (uint) table.Length;
+			}
+		}
+
+		byte GetHeapSizes ()
+		{
+			byte heap_sizes = 0;
+
+			if (metadata.string_heap.IsLarge) {
+				large_string = true;
+				heap_sizes |= 0x01;
+			}
+
+			if (metadata.guid_heap.IsLarge) {
+				large_guid = true;
+				heap_sizes |= 0x02;
+			}
+
+			if (metadata.blob_heap.IsLarge) {
+				large_blob = true;
+				heap_sizes |= 0x04;
+			}
+
+			return heap_sizes;
+		}
+
+		byte GetTableHeapVersion ()
+		{
+			switch (module.Runtime) {
+			case TargetRuntime.Net_1_0:
+			case TargetRuntime.Net_1_1:
+				return 1;
+			default:
+				return 2;
+			}
+		}
+
+		public void FixupData (RVA data_rva)
+		{
+			var table = GetTable<FieldRVATable> (Table.FieldRVA);
+			if (table.length == 0)
+				return;
+
+			var field_idx_size = GetTable<FieldTable> (Table.Field).IsLarge ? 4 : 2;
+			var previous = this.position;
+
+			base.position = table.position;
+			for (int i = 0; i < table.length; i++) {
+				var rva = ReadUInt32 ();
+				base.position -= 4;
+				WriteUInt32 (rva + data_rva);
+				base.position += field_idx_size;
+			}
+
+			base.position = previous;
+		}
+	}
+
+	sealed class ResourceBuffer : ByteBuffer {
+
+		public ResourceBuffer ()
+			: base (0)
+		{
+		}
+
+		public uint AddResource (byte [] resource)
+		{
+			var offset = (uint) this.position;
+			WriteInt32 (resource.Length);
+			WriteBytes (resource);
+			return offset;
+		}
+	}
+
+	sealed class DataBuffer : ByteBuffer {
+
+		public DataBuffer ()
+			: base (0)
+		{
+		}
+
+		public RVA AddData (byte [] data)
+		{
+			var rva = (RVA) position;
+			WriteBytes (data);
+			return rva;
+		}
+	}
+
+	abstract class HeapBuffer : ByteBuffer {
+
+		public bool IsLarge {
+			get { return base.length > 65535; }
+		}
+
+		public abstract bool IsEmpty { get; }
+
+		protected HeapBuffer (int length)
+			: base (length)
+		{
+		}
+	}
+
+	sealed class GuidHeapBuffer : HeapBuffer {
+
+		readonly Dictionary<Guid, uint> guids = new Dictionary<Guid, uint> ();
+
+		public override bool IsEmpty {
+			get { return length == 0; }
+		}
+
+		public GuidHeapBuffer ()
+			: base (16)
+		{
+		}
+
+		public uint GetGuidIndex (Guid guid)
+		{
+			uint index;
+			if (guids.TryGetValue (guid, out index))
+				return index;
+
+			index = (uint) guids.Count + 1;
+			WriteGuid (guid);
+			guids.Add (guid, index);
+			return index;
+		}
+
+		void WriteGuid (Guid guid)
+		{
+			WriteBytes (guid.ToByteArray ());
+		}
+	}
+
+	class StringHeapBuffer : HeapBuffer {
+
+		protected Dictionary<string, uint> strings = new Dictionary<string, uint> (StringComparer.Ordinal);
+
+		public sealed override bool IsEmpty {
+			get { return length <= 1; }
+		}
+
+		public StringHeapBuffer ()
+			: base (1)
+		{
+			WriteByte (0);
+		}
+
+		public virtual uint GetStringIndex (string @string)
+		{
+			uint index;
+			if (strings.TryGetValue (@string, out index))
+				return index;
+
+			index = (uint) strings.Count + 1;
+			strings.Add (@string, index);
+			return index;
+		}
+
+		public uint [] WriteStrings ()
+		{
+			var sorted = SortStrings (strings);
+			strings = null;
+
+			// Add 1 for empty string whose index and offset are both 0
+			var string_offsets = new uint [sorted.Count + 1];
+			string_offsets [0] = 0;
+
+			// Find strings that can be folded
+			var previous = string.Empty;
+			foreach (var entry in sorted) {
+				var @string = entry.Key;
+				var index = entry.Value;
+				var position = base.position;
+
+				if (previous.EndsWith (@string, StringComparison.Ordinal) && !IsLowSurrogateChar (entry.Key [0])) {
+					// Map over the tail of prev string. Watch for null-terminator of prev string.
+					string_offsets [index] = (uint) (position - (Encoding.UTF8.GetByteCount (entry.Key) + 1));
+				} else {
+					string_offsets [index] = (uint) position;
+					WriteString (@string);
+				}
+
+				previous = entry.Key;
+			}
+
+			return string_offsets;
+		}
+
+		static List<KeyValuePair<string, uint>> SortStrings (Dictionary<string, uint> strings)
+		{
+			var sorted = new List<KeyValuePair<string, uint>> (strings);
+			sorted.Sort (new SuffixSort ());
+			return sorted;
+		}
+
+		static bool IsLowSurrogateChar (int c)
+		{
+			return unchecked((uint)(c - 0xDC00)) <= 0xDFFF - 0xDC00;
+		}
+
+		protected virtual void WriteString (string @string)
+		{
+			WriteBytes (Encoding.UTF8.GetBytes (@string));
+			WriteByte (0);
+		}
+
+		// Sorts strings such that a string is followed immediately by all strings
+		// that are a suffix of it.  
+		private class SuffixSort : IComparer<KeyValuePair<string, uint>> {
+
+			public int Compare(KeyValuePair<string, uint> xPair, KeyValuePair<string, uint> yPair)
+			{
+				var x = xPair.Key;
+				var y = yPair.Key;
+
+				for (int i = x.Length - 1, j = y.Length - 1; i >= 0 & j >= 0; i--, j--) {
+					if (x [i] < y [j]) {
+						return -1;
+					}
+
+					if (x [i] > y [j]) {
+						return +1;
+					}
+				}
+
+				return y.Length.CompareTo (x.Length);
+			}
+		}
+	}
+
+	sealed class BlobHeapBuffer : HeapBuffer {
+
+		readonly Dictionary<ByteBuffer, uint> blobs = new Dictionary<ByteBuffer, uint> (new ByteBufferEqualityComparer ());
+
+		public override bool IsEmpty {
+			get { return length <= 1; }
+		}
+
+		public BlobHeapBuffer ()
+			: base (1)
+		{
+			WriteByte (0);
+		}
+
+		public uint GetBlobIndex (ByteBuffer blob)
+		{
+			uint index;
+			if (blobs.TryGetValue (blob, out index))
+				return index;
+
+			index = (uint) base.position;
+			WriteBlob (blob);
+			blobs.Add (blob, index);
+			return index;
+		}
+
+		void WriteBlob (ByteBuffer blob)
+		{
+			WriteCompressedUInt32 ((uint) blob.length);
+			WriteBytes (blob);
+		}
+	}
+
+	sealed class UserStringHeapBuffer : StringHeapBuffer {
+
+		public override uint GetStringIndex (string @string)
+		{
+			uint index;
+			if (strings.TryGetValue (@string, out index))
+				return index;
+
+			index = (uint) base.position;
+			WriteString (@string);
+			strings.Add (@string, index);
+			return index;
+		}
+
+		protected override void WriteString (string @string)
+		{
+			WriteCompressedUInt32 ((uint) @string.Length * 2 + 1);
+
+			byte special = 0;
+
+			for (int i = 0; i < @string.Length; i++) {
+				var @char = @string [i];
+				WriteUInt16 (@char);
+
+				if (special == 1)
+					continue;
+
+				if (@char < 0x20 || @char > 0x7e) {
+					if (@char > 0x7e
+						|| (@char >= 0x01 && @char <= 0x08)
+						|| (@char >= 0x0e && @char <= 0x1f)
+						|| @char == 0x27
+						|| @char == 0x2d) {
+
+						special = 1;
+					}
+				}
+			}
+
+			WriteByte (special);
+		}
+	}
+
+	sealed class PdbHeapBuffer : HeapBuffer {
+
+		public override bool IsEmpty {
+			get { return false; }
+		}
+
+		public PdbHeapBuffer ()
+			: base (0)
+		{
+		}
+	}
+}
+
+#endif
diff --git a/src/Mono/Cecil/Metadata/CodedIndex.cs b/src/Mono/Cecil/Metadata/CodedIndex.cs
new file mode 100644
index 00000000..2026a8a7
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/CodedIndex.cs
@@ -0,0 +1,29 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Metadata {
+
+	enum CodedIndex {
+		TypeDefOrRef,
+		HasConstant,
+		HasCustomAttribute,
+		HasFieldMarshal,
+		HasDeclSecurity,
+		MemberRefParent,
+		HasSemantics,
+		MethodDefOrRef,
+		MemberForwarded,
+		Implementation,
+		CustomAttributeType,
+		ResolutionScope,
+		TypeOrMethodDef,
+		HasCustomDebugInformation,
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/ElementType.cs b/src/Mono/Cecil/Metadata/ElementType.cs
new file mode 100644
index 00000000..2190160a
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/ElementType.cs
@@ -0,0 +1,55 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Metadata {
+
+	enum ElementType : byte {
+		None = 0x00,
+		Void = 0x01,
+		Boolean = 0x02,
+		Char = 0x03,
+		I1 = 0x04,
+		U1 = 0x05,
+		I2 = 0x06,
+		U2 = 0x07,
+		I4 = 0x08,
+		U4 = 0x09,
+		I8 = 0x0a,
+		U8 = 0x0b,
+		R4 = 0x0c,
+		R8 = 0x0d,
+		String = 0x0e,
+		Ptr = 0x0f,   // Followed by <type> token
+		ByRef = 0x10,   // Followed by <type> token
+		ValueType = 0x11,   // Followed by <type> token
+		Class = 0x12,   // Followed by <type> token
+		Var = 0x13,   // Followed by generic parameter number
+		Array = 0x14,   // <type> <rank> <boundsCount> <bound1>  <loCount> <lo1>
+		GenericInst = 0x15,   // <type> <type-arg-count> <type-1> ... <type-n> */
+		TypedByRef = 0x16,
+		I = 0x18,   // System.IntPtr
+		U = 0x19,   // System.UIntPtr
+		FnPtr = 0x1b,   // Followed by full method signature
+		Object = 0x1c,   // System.Object
+		SzArray = 0x1d,   // Single-dim array with 0 lower bound
+		MVar = 0x1e,   // Followed by generic parameter number
+		CModReqD = 0x1f,   // Required modifier : followed by a TypeDef or TypeRef token
+		CModOpt = 0x20,   // Optional modifier : followed by a TypeDef or TypeRef token
+		Internal = 0x21,   // Implemented within the CLI
+		Modifier = 0x40,   // Or'd with following element types
+		Sentinel = 0x41,   // Sentinel for varargs method signature
+		Pinned = 0x45,   // Denotes a local variable that points at a pinned object
+
+		// special undocumented constants
+		Type = 0x50,
+		Boxed = 0x51,
+		Enum = 0x55
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/GuidHeap.cs b/src/Mono/Cecil/Metadata/GuidHeap.cs
new file mode 100644
index 00000000..76ec9d1d
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/GuidHeap.cs
@@ -0,0 +1,36 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil.Metadata {
+
+	sealed class GuidHeap : Heap {
+
+		public GuidHeap (byte [] data)
+			: base (data)
+		{
+		}
+
+		public Guid Read (uint index)
+		{
+			const int guid_size = 16;
+
+			if (index == 0 || ((index - 1) + guid_size) > data.Length)
+				return new Guid ();
+
+			var buffer = new byte [guid_size];
+
+			Buffer.BlockCopy (this.data, (int) ((index - 1) * guid_size), buffer, 0, guid_size);
+
+			return new Guid (buffer);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/Heap.cs b/src/Mono/Cecil/Metadata/Heap.cs
new file mode 100644
index 00000000..6874d796
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/Heap.cs
@@ -0,0 +1,24 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Metadata {
+
+	abstract class Heap {
+
+		public int IndexSize;
+
+		readonly internal byte [] data;
+
+		protected Heap (byte [] data)
+		{
+			this.data = data;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/MetadataToken.cs b/src/Mono/Cecil/Metadata/MetadataToken.cs
new file mode 100644
index 00000000..a8b712e7
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/MetadataToken.cs
@@ -0,0 +1,94 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public struct MetadataToken : IEquatable<MetadataToken> {
+
+		readonly uint token;
+
+		public uint RID	{
+			get { return token & 0x00ffffff; }
+		}
+
+		public TokenType TokenType {
+			get { return (TokenType) (token & 0xff000000); }
+		}
+
+		public static readonly MetadataToken Zero = new MetadataToken ((uint) 0);
+
+		public MetadataToken (uint token)
+		{
+			this.token = token;
+		}
+
+		public MetadataToken (TokenType type)
+			: this (type, 0)
+		{
+		}
+
+		public MetadataToken (TokenType type, uint rid)
+		{
+			token = (uint) type | rid;
+		}
+
+		public MetadataToken (TokenType type, int rid)
+		{
+			token = (uint) type | (uint) rid;
+		}
+
+		public int ToInt32 ()
+		{
+			return (int) token;
+		}
+
+		public uint ToUInt32 ()
+		{
+			return token;
+		}
+
+		public override int GetHashCode ()
+		{
+			return (int) token;
+		}
+
+		public bool Equals (MetadataToken other)
+		{
+			return other.token == token;
+		}
+
+		public override bool Equals (object obj)
+		{
+			if (obj is MetadataToken) {
+				var other = (MetadataToken) obj;
+				return other.token == token;
+			}
+
+			return false;
+		}
+
+		public static bool operator == (MetadataToken one, MetadataToken other)
+		{
+			return one.token == other.token;
+		}
+
+		public static bool operator != (MetadataToken one, MetadataToken other)
+		{
+			return one.token != other.token;
+		}
+
+		public override string ToString ()
+		{
+			return string.Format ("[{0}:0x{1}]", TokenType, RID.ToString ("x4"));
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/PdbHeap.cs b/src/Mono/Cecil/Metadata/PdbHeap.cs
new file mode 100644
index 00000000..39e275ad
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/PdbHeap.cs
@@ -0,0 +1,34 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using Mono.Cecil.PE;
+
+using RID = System.UInt32;
+
+namespace Mono.Cecil.Metadata {
+
+	sealed class PdbHeap : Heap {
+
+		public byte [] Id;
+		public RID EntryPoint;
+		public long TypeSystemTables;
+		public uint [] TypeSystemTableRows;
+
+		public PdbHeap (byte [] data)
+			: base (data)
+		{
+		}
+
+		public bool HasTable (Table table)
+		{
+			return (TypeSystemTables & (1L << (int) table)) != 0;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/Row.cs b/src/Mono/Cecil/Metadata/Row.cs
new file mode 100644
index 00000000..0c05ebad
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/Row.cs
@@ -0,0 +1,152 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System.Collections.Generic;
+
+namespace Mono.Cecil.Metadata {
+
+	struct Row<T1, T2> {
+		internal T1 Col1;
+		internal T2 Col2;
+
+		public Row (T1 col1, T2 col2)
+		{
+			Col1 = col1;
+			Col2 = col2;
+		}
+	}
+
+	struct Row<T1, T2, T3> {
+		internal T1 Col1;
+		internal T2 Col2;
+		internal T3 Col3;
+
+		public Row (T1 col1, T2 col2, T3 col3)
+		{
+			Col1 = col1;
+			Col2 = col2;
+			Col3 = col3;
+		}
+	}
+
+	struct Row<T1, T2, T3, T4> {
+		internal T1 Col1;
+		internal T2 Col2;
+		internal T3 Col3;
+		internal T4 Col4;
+
+		public Row (T1 col1, T2 col2, T3 col3, T4 col4)
+		{
+			Col1 = col1;
+			Col2 = col2;
+			Col3 = col3;
+			Col4 = col4;
+		}
+	}
+
+	struct Row<T1, T2, T3, T4, T5> {
+		internal T1 Col1;
+		internal T2 Col2;
+		internal T3 Col3;
+		internal T4 Col4;
+		internal T5 Col5;
+
+		public Row (T1 col1, T2 col2, T3 col3, T4 col4, T5 col5)
+		{
+			Col1 = col1;
+			Col2 = col2;
+			Col3 = col3;
+			Col4 = col4;
+			Col5 = col5;
+		}
+	}
+
+	struct Row<T1, T2, T3, T4, T5, T6> {
+		internal T1 Col1;
+		internal T2 Col2;
+		internal T3 Col3;
+		internal T4 Col4;
+		internal T5 Col5;
+		internal T6 Col6;
+
+		public Row (T1 col1, T2 col2, T3 col3, T4 col4, T5 col5, T6 col6)
+		{
+			Col1 = col1;
+			Col2 = col2;
+			Col3 = col3;
+			Col4 = col4;
+			Col5 = col5;
+			Col6 = col6;
+		}
+	}
+
+	struct Row<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
+		internal T1 Col1;
+		internal T2 Col2;
+		internal T3 Col3;
+		internal T4 Col4;
+		internal T5 Col5;
+		internal T6 Col6;
+		internal T7 Col7;
+		internal T8 Col8;
+		internal T9 Col9;
+
+		public Row (T1 col1, T2 col2, T3 col3, T4 col4, T5 col5, T6 col6, T7 col7, T8 col8, T9 col9)
+		{
+			Col1 = col1;
+			Col2 = col2;
+			Col3 = col3;
+			Col4 = col4;
+			Col5 = col5;
+			Col6 = col6;
+			Col7 = col7;
+			Col8 = col8;
+			Col9 = col9;
+		}
+	}
+
+	sealed class RowEqualityComparer : IEqualityComparer<Row<string, string>>, IEqualityComparer<Row<uint, uint>>, IEqualityComparer<Row<uint, uint, uint>> {
+
+		public bool Equals (Row<string, string> x, Row<string, string> y)
+		{
+			return x.Col1 == y.Col1
+				&& x.Col2 == y.Col2;
+		}
+
+		public int GetHashCode (Row<string, string> obj)
+		{
+			string x = obj.Col1, y = obj.Col2;
+			return (x != null ? x.GetHashCode () : 0) ^ (y != null ? y.GetHashCode () : 0);
+		}
+
+		public bool Equals (Row<uint, uint> x, Row<uint, uint> y)
+		{
+			return x.Col1 == y.Col1
+				&& x.Col2 == y.Col2;
+		}
+
+		public int GetHashCode (Row<uint, uint> obj)
+		{
+			return (int) (obj.Col1 ^ obj.Col2);
+		}
+
+		public bool Equals (Row<uint, uint, uint> x, Row<uint, uint, uint> y)
+		{
+			return x.Col1 == y.Col1
+				&& x.Col2 == y.Col2
+				&& x.Col3 == y.Col3;
+		}
+
+		public int GetHashCode (Row<uint, uint, uint> obj)
+		{
+			return (int) (obj.Col1 ^ obj.Col2 ^ obj.Col3);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/StringHeap.cs b/src/Mono/Cecil/Metadata/StringHeap.cs
new file mode 100644
index 00000000..4bde70e2
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/StringHeap.cs
@@ -0,0 +1,60 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Mono.Cecil.Metadata {
+
+	class StringHeap : Heap {
+
+		readonly Dictionary<uint, string> strings = new Dictionary<uint, string> ();
+
+		public StringHeap (byte [] data)
+			: base (data)
+		{
+		}
+
+		public string Read (uint index)
+		{
+			if (index == 0)
+				return string.Empty;
+
+			string @string;
+			if (strings.TryGetValue (index, out @string))
+				return @string;
+
+			if (index > data.Length - 1)
+				return string.Empty;
+
+			@string = ReadStringAt (index);
+			if (@string.Length != 0)
+				strings.Add (index, @string);
+
+			return @string;
+		}
+
+		protected virtual string ReadStringAt (uint index)
+		{
+			int length = 0;
+			int start = (int) index;
+
+			for (int i = start; ; i++) {
+				if (data [i] == 0)
+					break;
+
+				length++;
+			}
+
+			return Encoding.UTF8.GetString (data, start, length);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/TableHeap.cs b/src/Mono/Cecil/Metadata/TableHeap.cs
new file mode 100644
index 00000000..dee655a3
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/TableHeap.cs
@@ -0,0 +1,104 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using Mono.Cecil.PE;
+
+namespace Mono.Cecil.Metadata {
+
+	enum Table : byte {
+		Module = 0x00,
+		TypeRef = 0x01,
+		TypeDef = 0x02,
+		FieldPtr = 0x03,
+		Field = 0x04,
+		MethodPtr = 0x05,
+		Method = 0x06,
+		ParamPtr = 0x07,
+		Param = 0x08,
+		InterfaceImpl = 0x09,
+		MemberRef = 0x0a,
+		Constant = 0x0b,
+		CustomAttribute = 0x0c,
+		FieldMarshal = 0x0d,
+		DeclSecurity = 0x0e,
+		ClassLayout = 0x0f,
+		FieldLayout = 0x10,
+		StandAloneSig = 0x11,
+		EventMap = 0x12,
+		EventPtr = 0x13,
+		Event = 0x14,
+		PropertyMap = 0x15,
+		PropertyPtr = 0x16,
+		Property = 0x17,
+		MethodSemantics = 0x18,
+		MethodImpl = 0x19,
+		ModuleRef = 0x1a,
+		TypeSpec = 0x1b,
+		ImplMap = 0x1c,
+		FieldRVA = 0x1d,
+		EncLog = 0x1e,
+		EncMap = 0x1f,
+		Assembly = 0x20,
+		AssemblyProcessor = 0x21,
+		AssemblyOS = 0x22,
+		AssemblyRef = 0x23,
+		AssemblyRefProcessor = 0x24,
+		AssemblyRefOS = 0x25,
+		File = 0x26,
+		ExportedType = 0x27,
+		ManifestResource = 0x28,
+		NestedClass = 0x29,
+		GenericParam = 0x2a,
+		MethodSpec = 0x2b,
+		GenericParamConstraint = 0x2c,
+
+		Document = 0x30,
+		MethodDebugInformation = 0x31,
+		LocalScope = 0x32,
+		LocalVariable = 0x33,
+		LocalConstant = 0x34,
+		ImportScope = 0x35,
+		StateMachineMethod = 0x36,
+		CustomDebugInformation = 0x37,
+	}
+
+	struct TableInformation {
+		public uint Offset;
+		public uint Length;
+		public uint RowSize;
+
+		public bool IsLarge {
+			get { return Length > ushort.MaxValue; }
+		}
+	}
+
+	sealed class TableHeap : Heap {
+
+		public long Valid;
+		public long Sorted;
+
+		public readonly TableInformation [] Tables = new TableInformation [Mixin.TableCount];
+
+		public TableInformation this [Table table] {
+			get { return Tables [(int) table]; }
+		}
+
+		public TableHeap (byte [] data)
+			: base (data)
+		{
+		}
+
+		public bool HasTable (Table table)
+		{
+			return (Valid & (1L << (int) table)) != 0;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/TokenType.cs b/src/Mono/Cecil/Metadata/TokenType.cs
new file mode 100644
index 00000000..547f6c64
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/TokenType.cs
@@ -0,0 +1,49 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum TokenType : uint {
+		Module = 0x00000000,
+		TypeRef = 0x01000000,
+		TypeDef = 0x02000000,
+		Field = 0x04000000,
+		Method = 0x06000000,
+		Param = 0x08000000,
+		InterfaceImpl = 0x09000000,
+		MemberRef = 0x0a000000,
+		CustomAttribute = 0x0c000000,
+		Permission = 0x0e000000,
+		Signature = 0x11000000,
+		Event = 0x14000000,
+		Property = 0x17000000,
+		ModuleRef = 0x1a000000,
+		TypeSpec = 0x1b000000,
+		Assembly = 0x20000000,
+		AssemblyRef = 0x23000000,
+		File = 0x26000000,
+		ExportedType = 0x27000000,
+		ManifestResource = 0x28000000,
+		GenericParam = 0x2a000000,
+		MethodSpec = 0x2b000000,
+		GenericParamConstraint = 0x2c000000,
+
+		Document = 0x30000000,
+		MethodDebugInformation = 0x31000000,
+		LocalScope = 0x32000000,
+		LocalVariable = 0x33000000,
+		LocalConstant = 0x34000000,
+		ImportScope = 0x35000000,
+		StateMachineMethod = 0x36000000,
+		CustomDebugInformation = 0x37000000,
+
+		String = 0x70000000,
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/UserStringHeap.cs b/src/Mono/Cecil/Metadata/UserStringHeap.cs
new file mode 100644
index 00000000..7b1b42ff
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/UserStringHeap.cs
@@ -0,0 +1,36 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil.Metadata {
+
+	sealed class UserStringHeap : StringHeap {
+
+		public UserStringHeap (byte [] data)
+			: base (data)
+		{
+		}
+
+		protected override string ReadStringAt (uint index)
+		{
+			int start = (int) index;
+
+			uint length = (uint) (data.ReadCompressedUInt32 (ref start) & ~1);
+			if (length < 1)
+				return string.Empty;
+
+			var chars = new char [length / 2];
+
+			for (int i = start, j = 0; i < start + length; i += 2)
+				chars [j++] = (char) (data [i] | (data [i + 1] << 8));
+
+			return new string (chars);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Metadata/Utilities.cs b/src/Mono/Cecil/Metadata/Utilities.cs
new file mode 100644
index 00000000..3a4330da
--- /dev/null
+++ b/src/Mono/Cecil/Metadata/Utilities.cs
@@ -0,0 +1,652 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	static partial class Mixin {
+
+		public const int TableCount = 58;
+		public const int CodedIndexCount = 14;
+
+		public static uint ReadCompressedUInt32 (this byte [] data, ref int position)
+		{
+			uint integer;
+			if ((data [position] & 0x80) == 0) {
+				integer = data [position];
+				position++;
+			} else if ((data [position] & 0x40) == 0) {
+				integer = (uint) (data [position] & ~0x80) << 8;
+				integer |= data [position + 1];
+				position += 2;
+			} else {
+				integer = (uint) (data [position] & ~0xc0) << 24;
+				integer |= (uint) data [position + 1] << 16;
+				integer |= (uint) data [position + 2] << 8;
+				integer |= (uint) data [position + 3];
+				position += 4;
+			}
+			return integer;
+		}
+
+		public static MetadataToken GetMetadataToken (this CodedIndex self, uint data)
+		{
+			uint rid;
+			TokenType token_type;
+			switch (self) {
+			case CodedIndex.TypeDefOrRef:
+				rid = data >> 2;
+				switch (data & 3) {
+				case 0:
+					token_type = TokenType.TypeDef; goto ret;
+				case 1:
+					token_type = TokenType.TypeRef; goto ret;
+				case 2:
+					token_type = TokenType.TypeSpec; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasConstant:
+				rid = data >> 2;
+				switch (data & 3) {
+				case 0:
+					token_type = TokenType.Field; goto ret;
+				case 1:
+					token_type = TokenType.Param; goto ret;
+				case 2:
+					token_type = TokenType.Property; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasCustomAttribute:
+				rid = data >> 5;
+				switch (data & 31) {
+				case 0:
+					token_type = TokenType.Method; goto ret;
+				case 1:
+					token_type = TokenType.Field; goto ret;
+				case 2:
+					token_type = TokenType.TypeRef; goto ret;
+				case 3:
+					token_type = TokenType.TypeDef; goto ret;
+				case 4:
+					token_type = TokenType.Param; goto ret;
+				case 5:
+					token_type = TokenType.InterfaceImpl; goto ret;
+				case 6:
+					token_type = TokenType.MemberRef; goto ret;
+				case 7:
+					token_type = TokenType.Module; goto ret;
+				case 8:
+					token_type = TokenType.Permission; goto ret;
+				case 9:
+					token_type = TokenType.Property; goto ret;
+				case 10:
+					token_type = TokenType.Event; goto ret;
+				case 11:
+					token_type = TokenType.Signature; goto ret;
+				case 12:
+					token_type = TokenType.ModuleRef; goto ret;
+				case 13:
+					token_type = TokenType.TypeSpec; goto ret;
+				case 14:
+					token_type = TokenType.Assembly; goto ret;
+				case 15:
+					token_type = TokenType.AssemblyRef; goto ret;
+				case 16:
+					token_type = TokenType.File; goto ret;
+				case 17:
+					token_type = TokenType.ExportedType; goto ret;
+				case 18:
+					token_type = TokenType.ManifestResource; goto ret;
+				case 19:
+					token_type = TokenType.GenericParam; goto ret;
+				case 20:
+					token_type = TokenType.GenericParamConstraint; goto ret;
+				case 21:
+					token_type = TokenType.MethodSpec; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasFieldMarshal:
+				rid = data >> 1;
+				switch (data & 1) {
+				case 0:
+					token_type = TokenType.Field; goto ret;
+				case 1:
+					token_type = TokenType.Param; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasDeclSecurity:
+				rid = data >> 2;
+				switch (data & 3) {
+				case 0:
+					token_type = TokenType.TypeDef; goto ret;
+				case 1:
+					token_type = TokenType.Method; goto ret;
+				case 2:
+					token_type = TokenType.Assembly; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.MemberRefParent:
+				rid = data >> 3;
+				switch (data & 7) {
+				case 0:
+					token_type = TokenType.TypeDef; goto ret;
+				case 1:
+					token_type = TokenType.TypeRef; goto ret;
+				case 2:
+					token_type = TokenType.ModuleRef; goto ret;
+				case 3:
+					token_type = TokenType.Method; goto ret;
+				case 4:
+					token_type = TokenType.TypeSpec; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasSemantics:
+				rid = data >> 1;
+				switch (data & 1) {
+				case 0:
+					token_type = TokenType.Event; goto ret;
+				case 1:
+					token_type = TokenType.Property; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.MethodDefOrRef:
+				rid = data >> 1;
+				switch (data & 1) {
+				case 0:
+					token_type = TokenType.Method; goto ret;
+				case 1:
+					token_type = TokenType.MemberRef; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.MemberForwarded:
+				rid = data >> 1;
+				switch (data & 1) {
+				case 0:
+					token_type = TokenType.Field; goto ret;
+				case 1:
+					token_type = TokenType.Method; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.Implementation:
+				rid = data >> 2;
+				switch (data & 3) {
+				case 0:
+					token_type = TokenType.File; goto ret;
+				case 1:
+					token_type = TokenType.AssemblyRef; goto ret;
+				case 2:
+					token_type = TokenType.ExportedType; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.CustomAttributeType:
+				rid = data >> 3;
+				switch (data & 7) {
+				case 2:
+					token_type = TokenType.Method; goto ret;
+				case 3:
+					token_type = TokenType.MemberRef; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.ResolutionScope:
+				rid = data >> 2;
+				switch (data & 3) {
+				case 0:
+					token_type = TokenType.Module; goto ret;
+				case 1:
+					token_type = TokenType.ModuleRef; goto ret;
+				case 2:
+					token_type = TokenType.AssemblyRef; goto ret;
+				case 3:
+					token_type = TokenType.TypeRef; goto ret;
+				default:
+					goto exit;
+				}
+			case CodedIndex.TypeOrMethodDef:
+				rid = data >> 1;
+				switch (data & 1) {
+				case 0:
+					token_type = TokenType.TypeDef; goto ret;
+				case 1:
+					token_type = TokenType.Method; goto ret;
+				default: goto exit;
+				}
+			case CodedIndex.HasCustomDebugInformation:
+				rid = data >> 5;
+				switch (data & 31) {
+				case 0:
+					token_type = TokenType.Method; goto ret;
+				case 1:
+					token_type = TokenType.Field; goto ret;
+				case 2:
+					token_type = TokenType.TypeRef; goto ret;
+				case 3:
+					token_type = TokenType.TypeDef; goto ret;
+				case 4:
+					token_type = TokenType.Param; goto ret;
+				case 5:
+					token_type = TokenType.InterfaceImpl; goto ret;
+				case 6:
+					token_type = TokenType.MemberRef; goto ret;
+				case 7:
+					token_type = TokenType.Module; goto ret;
+				case 8:
+					token_type = TokenType.Permission; goto ret;
+				case 9:
+					token_type = TokenType.Property; goto ret;
+				case 10:
+					token_type = TokenType.Event; goto ret;
+				case 11:
+					token_type = TokenType.Signature; goto ret;
+				case 12:
+					token_type = TokenType.ModuleRef; goto ret;
+				case 13:
+					token_type = TokenType.TypeSpec; goto ret;
+				case 14:
+					token_type = TokenType.Assembly; goto ret;
+				case 15:
+					token_type = TokenType.AssemblyRef; goto ret;
+				case 16:
+					token_type = TokenType.File; goto ret;
+				case 17:
+					token_type = TokenType.ExportedType; goto ret;
+				case 18:
+					token_type = TokenType.ManifestResource; goto ret;
+				case 19:
+					token_type = TokenType.GenericParam; goto ret;
+				case 20:
+					token_type = TokenType.GenericParamConstraint; goto ret;
+				case 21:
+					token_type = TokenType.MethodSpec; goto ret;
+				case 22:
+					token_type = TokenType.Document; goto ret;
+				case 23:
+					token_type = TokenType.LocalScope; goto ret;
+				case 24:
+					token_type = TokenType.LocalVariable; goto ret;
+				case 25:
+					token_type = TokenType.LocalConstant; goto ret;
+				case 26:
+					token_type = TokenType.ImportScope; goto ret;
+				default:
+					goto exit;
+				}
+			default:
+				goto exit;
+			}
+		ret:
+			return new MetadataToken (token_type, rid);
+		exit:
+			return MetadataToken.Zero;
+		}
+
+#if !READ_ONLY
+		public static uint CompressMetadataToken (this CodedIndex self, MetadataToken token)
+		{
+			uint ret = 0;
+			if (token.RID == 0)
+				return ret;
+			switch (self) {
+			case CodedIndex.TypeDefOrRef:
+				ret = token.RID << 2;
+				switch (token.TokenType) {
+				case TokenType.TypeDef:
+					return ret | 0;
+				case TokenType.TypeRef:
+					return ret | 1;
+				case TokenType.TypeSpec:
+					return ret | 2;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasConstant:
+				ret = token.RID << 2;
+				switch (token.TokenType) {
+				case TokenType.Field:
+					return ret | 0;
+				case TokenType.Param:
+					return ret | 1;
+				case TokenType.Property:
+					return ret | 2;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasCustomAttribute:
+				ret = token.RID << 5;
+				switch (token.TokenType) {
+				case TokenType.Method:
+					return ret | 0;
+				case TokenType.Field:
+					return ret | 1;
+				case TokenType.TypeRef:
+					return ret | 2;
+				case TokenType.TypeDef:
+					return ret | 3;
+				case TokenType.Param:
+					return ret | 4;
+				case TokenType.InterfaceImpl:
+					return ret | 5;
+				case TokenType.MemberRef:
+					return ret | 6;
+				case TokenType.Module:
+					return ret | 7;
+				case TokenType.Permission:
+					return ret | 8;
+				case TokenType.Property:
+					return ret | 9;
+				case TokenType.Event:
+					return ret | 10;
+				case TokenType.Signature:
+					return ret | 11;
+				case TokenType.ModuleRef:
+					return ret | 12;
+				case TokenType.TypeSpec:
+					return ret | 13;
+				case TokenType.Assembly:
+					return ret | 14;
+				case TokenType.AssemblyRef:
+					return ret | 15;
+				case TokenType.File:
+					return ret | 16;
+				case TokenType.ExportedType:
+					return ret | 17;
+				case TokenType.ManifestResource:
+					return ret | 18;
+				case TokenType.GenericParam:
+					return ret | 19;
+				case TokenType.GenericParamConstraint:
+					return ret | 20;
+				case TokenType.MethodSpec:
+					return ret | 21;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasFieldMarshal:
+				ret = token.RID << 1;
+				switch (token.TokenType) {
+				case TokenType.Field:
+					return ret | 0;
+				case TokenType.Param:
+					return ret | 1;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasDeclSecurity:
+				ret = token.RID << 2;
+				switch (token.TokenType) {
+				case TokenType.TypeDef:
+					return ret | 0;
+				case TokenType.Method:
+					return ret | 1;
+				case TokenType.Assembly:
+					return ret | 2;
+				default:
+					goto exit;
+				}
+			case CodedIndex.MemberRefParent:
+				ret = token.RID << 3;
+				switch (token.TokenType) {
+				case TokenType.TypeDef:
+					return ret | 0;
+				case TokenType.TypeRef:
+					return ret | 1;
+				case TokenType.ModuleRef:
+					return ret | 2;
+				case TokenType.Method:
+					return ret | 3;
+				case TokenType.TypeSpec:
+					return ret | 4;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasSemantics:
+				ret = token.RID << 1;
+				switch (token.TokenType) {
+				case TokenType.Event:
+					return ret | 0;
+				case TokenType.Property:
+					return ret | 1;
+				default:
+					goto exit;
+				}
+			case CodedIndex.MethodDefOrRef:
+				ret = token.RID << 1;
+				switch (token.TokenType) {
+				case TokenType.Method:
+					return ret | 0;
+				case TokenType.MemberRef:
+					return ret | 1;
+				default:
+					goto exit;
+				}
+			case CodedIndex.MemberForwarded:
+				ret = token.RID << 1;
+				switch (token.TokenType) {
+				case TokenType.Field:
+					return ret | 0;
+				case TokenType.Method:
+					return ret | 1;
+				default:
+					goto exit;
+				}
+			case CodedIndex.Implementation:
+				ret = token.RID << 2;
+				switch (token.TokenType) {
+				case TokenType.File:
+					return ret | 0;
+				case TokenType.AssemblyRef:
+					return ret | 1;
+				case TokenType.ExportedType:
+					return ret | 2;
+				default:
+					goto exit;
+				}
+			case CodedIndex.CustomAttributeType:
+				ret = token.RID << 3;
+				switch (token.TokenType) {
+				case TokenType.Method:
+					return ret | 2;
+				case TokenType.MemberRef:
+					return ret | 3;
+				default:
+					goto exit;
+				}
+			case CodedIndex.ResolutionScope:
+				ret = token.RID << 2;
+				switch (token.TokenType) {
+				case TokenType.Module:
+					return ret | 0;
+				case TokenType.ModuleRef:
+					return ret | 1;
+				case TokenType.AssemblyRef:
+					return ret | 2;
+				case TokenType.TypeRef:
+					return ret | 3;
+				default:
+					goto exit;
+				}
+			case CodedIndex.TypeOrMethodDef:
+				ret = token.RID << 1;
+				switch (token.TokenType) {
+				case TokenType.TypeDef:
+					return ret | 0;
+				case TokenType.Method:
+					return ret | 1;
+				default:
+					goto exit;
+				}
+			case CodedIndex.HasCustomDebugInformation:
+				ret = token.RID << 5;
+				switch (token.TokenType) {
+				case TokenType.Method:
+					return ret | 0;
+				case TokenType.Field:
+					return ret | 1;
+				case TokenType.TypeRef:
+					return ret | 2;
+				case TokenType.TypeDef:
+					return ret | 3;
+				case TokenType.Param:
+					return ret | 4;
+				case TokenType.InterfaceImpl:
+					return ret | 5;
+				case TokenType.MemberRef:
+					return ret | 6;
+				case TokenType.Module:
+					return ret | 7;
+				case TokenType.Permission:
+					return ret | 8;
+				case TokenType.Property:
+					return ret | 9;
+				case TokenType.Event:
+					return ret | 10;
+				case TokenType.Signature:
+					return ret | 11;
+				case TokenType.ModuleRef:
+					return ret | 12;
+				case TokenType.TypeSpec:
+					return ret | 13;
+				case TokenType.Assembly:
+					return ret | 14;
+				case TokenType.AssemblyRef:
+					return ret | 15;
+				case TokenType.File:
+					return ret | 16;
+				case TokenType.ExportedType:
+					return ret | 17;
+				case TokenType.ManifestResource:
+					return ret | 18;
+				case TokenType.GenericParam:
+					return ret | 19;
+				case TokenType.GenericParamConstraint:
+					return ret | 20;
+				case TokenType.MethodSpec:
+					return ret | 21;
+				case TokenType.Document:
+					return ret | 22;
+				case TokenType.LocalScope:
+					return ret | 23;
+				case TokenType.LocalVariable:
+					return ret | 24;
+				case TokenType.LocalConstant:
+					return ret | 25;
+				case TokenType.ImportScope:
+					return ret | 26;
+				default:
+					goto exit;
+				}
+			default:
+				goto exit;
+			}
+		exit:
+			throw new ArgumentException ();
+		}
+#endif
+
+		public static int GetSize (this CodedIndex self, Func<Table, int> counter)
+		{
+			int bits;
+			Table [] tables;
+
+			switch (self) {
+			case CodedIndex.TypeDefOrRef:
+				bits = 2;
+				tables = new [] { Table.TypeDef, Table.TypeRef, Table.TypeSpec };
+				break;
+			case CodedIndex.HasConstant:
+				bits = 2;
+				tables = new [] { Table.Field, Table.Param, Table.Property };
+				break;
+			case CodedIndex.HasCustomAttribute:
+				bits = 5;
+				tables = new [] {
+					Table.Method, Table.Field, Table.TypeRef, Table.TypeDef, Table.Param, Table.InterfaceImpl, Table.MemberRef,
+					Table.Module, Table.DeclSecurity, Table.Property, Table.Event, Table.StandAloneSig, Table.ModuleRef,
+					Table.TypeSpec, Table.Assembly, Table.AssemblyRef, Table.File, Table.ExportedType,
+					Table.ManifestResource, Table.GenericParam, Table.GenericParamConstraint, Table.MethodSpec,
+				};
+				break;
+			case CodedIndex.HasFieldMarshal:
+				bits = 1;
+				tables = new [] { Table.Field, Table.Param };
+				break;
+			case CodedIndex.HasDeclSecurity:
+				bits = 2;
+				tables = new [] { Table.TypeDef, Table.Method, Table.Assembly };
+				break;
+			case CodedIndex.MemberRefParent:
+				bits = 3;
+				tables = new [] { Table.TypeDef, Table.TypeRef, Table.ModuleRef, Table.Method, Table.TypeSpec };
+				break;
+			case CodedIndex.HasSemantics:
+				bits = 1;
+				tables = new [] { Table.Event, Table.Property };
+				break;
+			case CodedIndex.MethodDefOrRef:
+				bits = 1;
+				tables = new [] { Table.Method, Table.MemberRef };
+				break;
+			case CodedIndex.MemberForwarded:
+				bits = 1;
+				tables = new [] { Table.Field, Table.Method };
+				break;
+			case CodedIndex.Implementation:
+				bits = 2;
+				tables = new [] { Table.File, Table.AssemblyRef, Table.ExportedType };
+				break;
+			case CodedIndex.CustomAttributeType:
+				bits = 3;
+				tables = new [] { Table.Method, Table.MemberRef };
+				break;
+			case CodedIndex.ResolutionScope:
+				bits = 2;
+				tables = new [] { Table.Module, Table.ModuleRef, Table.AssemblyRef, Table.TypeRef };
+				break;
+			case CodedIndex.TypeOrMethodDef:
+				bits = 1;
+				tables = new [] { Table.TypeDef, Table.Method };
+				break;
+			case CodedIndex.HasCustomDebugInformation:
+				bits = 5;
+				tables = new[] {
+					Table.Method, Table.Field, Table.TypeRef, Table.TypeDef, Table.Param, Table.InterfaceImpl, Table.MemberRef,
+					Table.Module, Table.DeclSecurity, Table.Property, Table.Event, Table.StandAloneSig, Table.ModuleRef,
+					Table.TypeSpec, Table.Assembly, Table.AssemblyRef, Table.File, Table.ExportedType,
+					Table.ManifestResource, Table.GenericParam, Table.GenericParamConstraint, Table.MethodSpec,
+					Table.Document, Table.LocalScope, Table.LocalVariable, Table.LocalConstant, Table.ImportScope,
+				};
+				break;
+			default:
+				throw new ArgumentException ();
+			}
+
+			int max = 0;
+
+			for (int i = 0; i < tables.Length; i++) {
+				max = System.Math.Max (counter (tables [i]), max);
+			}
+
+			return max < (1 << (16 - bits)) ? 2 : 4;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MetadataResolver.cs b/src/Mono/Cecil/MetadataResolver.cs
new file mode 100644
index 00000000..630ec8a7
--- /dev/null
+++ b/src/Mono/Cecil/MetadataResolver.cs
@@ -0,0 +1,391 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public interface IAssemblyResolver : IDisposable {
+		AssemblyDefinition Resolve (AssemblyNameReference name);
+		AssemblyDefinition Resolve (AssemblyNameReference name, ReaderParameters parameters);
+	}
+
+	public interface IMetadataResolver {
+		TypeDefinition Resolve (TypeReference type);
+		FieldDefinition Resolve (FieldReference field);
+		MethodDefinition Resolve (MethodReference method);
+	}
+
+#if !NET_CORE
+	[Serializable]
+#endif
+	public sealed class ResolutionException : Exception {
+
+		readonly MemberReference member;
+
+		public MemberReference Member {
+			get { return member; }
+		}
+
+		public IMetadataScope Scope {
+			get {
+				var type = member as TypeReference;
+				if (type != null)
+					return type.Scope;
+
+				var declaring_type = member.DeclaringType;
+				if (declaring_type != null)
+					return declaring_type.Scope;
+
+				throw new NotSupportedException ();
+			}
+		}
+
+		public ResolutionException (MemberReference member)
+			: base ("Failed to resolve " + member.FullName)
+		{
+			if (member == null)
+				throw new ArgumentNullException ("member");
+
+			this.member = member;
+		}
+
+		public ResolutionException (MemberReference member, Exception innerException)
+			: base ("Failed to resolve " + member.FullName, innerException)
+		{
+			if (member == null)
+				throw new ArgumentNullException ("member");
+
+			this.member = member;
+		}
+
+#if !NET_CORE
+		ResolutionException (
+			System.Runtime.Serialization.SerializationInfo info,
+			System.Runtime.Serialization.StreamingContext context)
+			: base (info, context)
+		{
+		}
+#endif
+	}
+
+	public class MetadataResolver : IMetadataResolver {
+
+		readonly IAssemblyResolver assembly_resolver;
+
+		public IAssemblyResolver AssemblyResolver {
+			get { return assembly_resolver; }
+		}
+
+		public MetadataResolver (IAssemblyResolver assemblyResolver)
+		{
+			if (assemblyResolver == null)
+				throw new ArgumentNullException ("assemblyResolver");
+
+			assembly_resolver = assemblyResolver;
+		}
+
+		public virtual TypeDefinition Resolve (TypeReference type)
+		{
+			Mixin.CheckType (type);
+
+			type = type.GetElementType ();
+
+			var scope = type.Scope;
+
+			if (scope == null)
+				return null;
+
+			switch (scope.MetadataScopeType) {
+			case MetadataScopeType.AssemblyNameReference:
+				var assembly = assembly_resolver.Resolve ((AssemblyNameReference) scope);
+				if (assembly == null)
+					return null;
+
+				return GetType (assembly.MainModule, type);
+			case MetadataScopeType.ModuleDefinition:
+				return GetType ((ModuleDefinition) scope, type);
+			case MetadataScopeType.ModuleReference:
+				var modules = type.Module.Assembly.Modules;
+				var module_ref = (ModuleReference) scope;
+				for (int i = 0; i < modules.Count; i++) {
+					var netmodule = modules [i];
+					if (netmodule.Name == module_ref.Name)
+						return GetType (netmodule, type);
+				}
+				break;
+			}
+
+			throw new NotSupportedException ();
+		}
+
+		static TypeDefinition GetType (ModuleDefinition module, TypeReference reference)
+		{
+			var type = GetTypeDefinition (module, reference);
+			if (type != null)
+				return type;
+
+			if (!module.HasExportedTypes)
+				return null;
+
+			var exported_types = module.ExportedTypes;
+
+			for (int i = 0; i < exported_types.Count; i++) {
+				var exported_type = exported_types [i];
+				if (exported_type.Name != reference.Name)
+					continue;
+
+				if (exported_type.Namespace != reference.Namespace)
+					continue;
+
+				return exported_type.Resolve ();
+			}
+
+			return null;
+		}
+
+		static TypeDefinition GetTypeDefinition (ModuleDefinition module, TypeReference type)
+		{
+			if (!type.IsNested)
+				return module.GetType (type.Namespace, type.Name);
+
+			var declaring_type = type.DeclaringType.Resolve ();
+			if (declaring_type == null)
+				return null;
+
+			return declaring_type.GetNestedType (type.TypeFullName ());
+		}
+
+		public virtual FieldDefinition Resolve (FieldReference field)
+		{
+			Mixin.CheckField (field);
+
+			var type = Resolve (field.DeclaringType);
+			if (type == null)
+				return null;
+
+			if (!type.HasFields)
+				return null;
+
+			return GetField (type, field);
+		}
+
+		FieldDefinition GetField (TypeDefinition type, FieldReference reference)
+		{
+			while (type != null) {
+				var field = GetField (type.Fields, reference);
+				if (field != null)
+					return field;
+
+				if (type.BaseType == null)
+					return null;
+
+				type = Resolve (type.BaseType);
+			}
+
+			return null;
+		}
+
+		static FieldDefinition GetField (Collection<FieldDefinition> fields, FieldReference reference)
+		{
+			for (int i = 0; i < fields.Count; i++) {
+				var field = fields [i];
+
+				if (field.Name != reference.Name)
+					continue;
+
+				if (!AreSame (field.FieldType, reference.FieldType))
+					continue;
+
+				return field;
+			}
+
+			return null;
+		}
+
+		public virtual MethodDefinition Resolve (MethodReference method)
+		{
+			Mixin.CheckMethod (method);
+
+			var type = Resolve (method.DeclaringType);
+			if (type == null)
+				return null;
+
+			method = method.GetElementMethod ();
+
+			if (!type.HasMethods)
+				return null;
+
+			return GetMethod (type, method);
+		}
+
+		MethodDefinition GetMethod (TypeDefinition type, MethodReference reference)
+		{
+			while (type != null) {
+				var method = GetMethod (type.Methods, reference);
+				if (method != null)
+					return method;
+
+				if (type.BaseType == null)
+					return null;
+
+				type = Resolve (type.BaseType);
+			}
+
+			return null;
+		}
+
+		public static MethodDefinition GetMethod (Collection<MethodDefinition> methods, MethodReference reference)
+		{
+			for (int i = 0; i < methods.Count; i++) {
+				var method = methods [i];
+
+				if (method.Name != reference.Name)
+					continue;
+
+				if (method.HasGenericParameters != reference.HasGenericParameters)
+					continue;
+
+				if (method.HasGenericParameters && method.GenericParameters.Count != reference.GenericParameters.Count)
+					continue;
+
+				if (!AreSame (method.ReturnType, reference.ReturnType))
+					continue;
+
+				if (method.IsVarArg () != reference.IsVarArg ())
+					continue;
+
+				if (method.IsVarArg () && IsVarArgCallTo (method, reference))
+					return method;
+
+				if (method.HasParameters != reference.HasParameters)
+					continue;
+
+				if (!method.HasParameters && !reference.HasParameters)
+					return method;
+
+				if (!AreSame (method.Parameters, reference.Parameters))
+					continue;
+
+				return method;
+			}
+
+			return null;
+		}
+
+		static bool AreSame (Collection<ParameterDefinition> a, Collection<ParameterDefinition> b)
+		{
+			var count = a.Count;
+
+			if (count != b.Count)
+				return false;
+
+			if (count == 0)
+				return true;
+
+			for (int i = 0; i < count; i++)
+				if (!AreSame (a [i].ParameterType, b [i].ParameterType))
+					return false;
+
+			return true;
+		}
+
+		static bool IsVarArgCallTo (MethodDefinition method, MethodReference reference)
+		{
+			if (method.Parameters.Count >= reference.Parameters.Count)
+				return false;
+
+			if (reference.GetSentinelPosition () != method.Parameters.Count)
+				return false;
+
+			for (int i = 0; i < method.Parameters.Count; i++)
+				if (!AreSame (method.Parameters [i].ParameterType, reference.Parameters [i].ParameterType))
+					return false;
+
+			return true;
+		}
+
+		static bool AreSame (TypeSpecification a, TypeSpecification b)
+		{
+			if (!AreSame (a.ElementType, b.ElementType))
+				return false;
+
+			if (a.IsGenericInstance)
+				return AreSame ((GenericInstanceType) a, (GenericInstanceType) b);
+
+			if (a.IsRequiredModifier || a.IsOptionalModifier)
+				return AreSame ((IModifierType) a, (IModifierType) b);
+
+			if (a.IsArray)
+				return AreSame ((ArrayType) a, (ArrayType) b);
+
+			return true;
+		}
+
+		static bool AreSame (ArrayType a, ArrayType b)
+		{
+			if (a.Rank != b.Rank)
+				return false;
+
+			// TODO: dimensions
+
+			return true;
+		}
+
+		static bool AreSame (IModifierType a, IModifierType b)
+		{
+			return AreSame (a.ModifierType, b.ModifierType);
+		}
+
+		static bool AreSame (GenericInstanceType a, GenericInstanceType b)
+		{
+			if (a.GenericArguments.Count != b.GenericArguments.Count)
+				return false;
+
+			for (int i = 0; i < a.GenericArguments.Count; i++)
+				if (!AreSame (a.GenericArguments [i], b.GenericArguments [i]))
+					return false;
+
+			return true;
+		}
+
+		static bool AreSame (GenericParameter a, GenericParameter b)
+		{
+			return a.Position == b.Position;
+		}
+
+		static bool AreSame (TypeReference a, TypeReference b)
+		{
+			if (ReferenceEquals (a, b))
+				return true;
+
+			if (a == null || b == null)
+				return false;
+
+			if (a.etype != b.etype)
+				return false;
+
+			if (a.IsGenericParameter)
+				return AreSame ((GenericParameter) a, (GenericParameter) b);
+
+			if (a.IsTypeSpecification ())
+				return AreSame ((TypeSpecification) a, (TypeSpecification) b);
+
+			if (a.Name != b.Name || a.Namespace != b.Namespace)
+				return false;
+
+			//TODO: check scope
+
+			return AreSame (a.DeclaringType, b.DeclaringType);
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MetadataSystem.cs b/src/Mono/Cecil/MetadataSystem.cs
new file mode 100644
index 00000000..6a2dd345
--- /dev/null
+++ b/src/Mono/Cecil/MetadataSystem.cs
@@ -0,0 +1,429 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+
+using Mono.Cecil.Cil;
+using Mono.Cecil.Metadata;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	struct Range {
+		public uint Start;
+		public uint Length;
+
+		public Range (uint index, uint length)
+		{
+			this.Start = index;
+			this.Length = length;
+		}
+	}
+
+	sealed class MetadataSystem {
+
+		internal AssemblyNameReference [] AssemblyReferences;
+		internal ModuleReference [] ModuleReferences;
+
+		internal TypeDefinition [] Types;
+		internal TypeReference [] TypeReferences;
+
+		internal FieldDefinition [] Fields;
+		internal MethodDefinition [] Methods;
+		internal MemberReference [] MemberReferences;
+
+		internal Dictionary<uint, Collection<uint>> NestedTypes;
+		internal Dictionary<uint, uint> ReverseNestedTypes;
+		internal Dictionary<uint, Collection<Row<uint, MetadataToken>>> Interfaces;
+		internal Dictionary<uint, Row<ushort, uint>> ClassLayouts;
+		internal Dictionary<uint, uint> FieldLayouts;
+		internal Dictionary<uint, uint> FieldRVAs;
+		internal Dictionary<MetadataToken, uint> FieldMarshals;
+		internal Dictionary<MetadataToken, Row<ElementType, uint>> Constants;
+		internal Dictionary<uint, Collection<MetadataToken>> Overrides;
+		internal Dictionary<MetadataToken, Range []> CustomAttributes;
+		internal Dictionary<MetadataToken, Range []> SecurityDeclarations;
+		internal Dictionary<uint, Range> Events;
+		internal Dictionary<uint, Range> Properties;
+		internal Dictionary<uint, Row<MethodSemanticsAttributes, MetadataToken>> Semantics;
+		internal Dictionary<uint, Row<PInvokeAttributes, uint, uint>> PInvokes;
+		internal Dictionary<MetadataToken, Range []> GenericParameters;
+		internal Dictionary<uint, Collection<MetadataToken>> GenericConstraints;
+
+		internal Document [] Documents;
+		internal Dictionary<uint, Collection<Row<uint, Range, Range, uint, uint, uint>>> LocalScopes;
+		internal ImportDebugInformation [] ImportScopes;
+		internal Dictionary<uint, uint> StateMachineMethods;
+		internal Dictionary<MetadataToken, Row<Guid, uint, uint> []> CustomDebugInformations;
+
+		static Dictionary<string, Row<ElementType, bool>> primitive_value_types;
+
+		static void InitializePrimitives ()
+		{
+			primitive_value_types = new Dictionary<string, Row<ElementType, bool>> (18, StringComparer.Ordinal) {
+				{ "Void", new Row<ElementType, bool> (ElementType.Void, false) },
+				{ "Boolean", new Row<ElementType, bool> (ElementType.Boolean, true) },
+				{ "Char", new Row<ElementType, bool> (ElementType.Char, true) },
+				{ "SByte", new Row<ElementType, bool> (ElementType.I1, true) },
+				{ "Byte", new Row<ElementType, bool> (ElementType.U1, true) },
+				{ "Int16", new Row<ElementType, bool> (ElementType.I2, true) },
+				{ "UInt16", new Row<ElementType, bool> (ElementType.U2, true) },
+				{ "Int32", new Row<ElementType, bool> (ElementType.I4, true) },
+				{ "UInt32", new Row<ElementType, bool> (ElementType.U4, true) },
+				{ "Int64", new Row<ElementType, bool> (ElementType.I8, true) },
+				{ "UInt64", new Row<ElementType, bool> (ElementType.U8, true) },
+				{ "Single", new Row<ElementType, bool> (ElementType.R4, true) },
+				{ "Double", new Row<ElementType, bool> (ElementType.R8, true) },
+				{ "String", new Row<ElementType, bool> (ElementType.String, false) },
+				{ "TypedReference", new Row<ElementType, bool> (ElementType.TypedByRef, false) },
+				{ "IntPtr", new Row<ElementType, bool> (ElementType.I, true) },
+				{ "UIntPtr", new Row<ElementType, bool> (ElementType.U, true) },
+				{ "Object", new Row<ElementType, bool> (ElementType.Object, false) },
+			};
+		}
+
+		public static void TryProcessPrimitiveTypeReference (TypeReference type)
+		{
+			if (type.Namespace != "System")
+				return;
+
+			var scope = type.scope;
+			if (scope == null || scope.MetadataScopeType != MetadataScopeType.AssemblyNameReference)
+				return;
+
+			Row<ElementType, bool> primitive_data;
+			if (!TryGetPrimitiveData (type, out primitive_data))
+				return;
+
+			type.etype = primitive_data.Col1;
+			type.IsValueType = primitive_data.Col2;
+		}
+
+		public static bool TryGetPrimitiveElementType (TypeDefinition type, out ElementType etype)
+		{
+			etype = ElementType.None;
+
+			if (type.Namespace != "System")
+				return false;
+
+			Row<ElementType, bool> primitive_data;
+			if (TryGetPrimitiveData (type, out primitive_data)) {
+				etype = primitive_data.Col1;
+				return true;
+			}
+
+			return false;
+		}
+
+		static bool TryGetPrimitiveData (TypeReference type, out Row<ElementType, bool> primitive_data)
+		{
+			if (primitive_value_types == null)
+				InitializePrimitives ();
+
+			return primitive_value_types.TryGetValue (type.Name, out primitive_data);
+		}
+
+		public void Clear ()
+		{
+			if (NestedTypes != null) NestedTypes = new Dictionary<uint, Collection<uint>> (capacity: 0);
+			if (ReverseNestedTypes != null) ReverseNestedTypes = new Dictionary<uint, uint> (capacity: 0);
+			if (Interfaces != null) Interfaces = new Dictionary<uint, Collection<Row<uint, MetadataToken>>> (capacity: 0);
+			if (ClassLayouts != null) ClassLayouts = new Dictionary<uint, Row<ushort, uint>> (capacity: 0);
+			if (FieldLayouts != null) FieldLayouts = new Dictionary<uint, uint> (capacity: 0);
+			if (FieldRVAs != null) FieldRVAs = new Dictionary<uint, uint> (capacity: 0);
+			if (FieldMarshals != null) FieldMarshals = new Dictionary<MetadataToken, uint> (capacity: 0);
+			if (Constants != null) Constants = new Dictionary<MetadataToken, Row<ElementType, uint>> (capacity: 0);
+			if (Overrides != null) Overrides = new Dictionary<uint, Collection<MetadataToken>> (capacity: 0);
+			if (CustomAttributes != null) CustomAttributes = new Dictionary<MetadataToken, Range []> (capacity: 0);
+			if (SecurityDeclarations != null) SecurityDeclarations = new Dictionary<MetadataToken, Range []> (capacity: 0);
+			if (Events != null) Events = new Dictionary<uint, Range> (capacity: 0);
+			if (Properties != null) Properties = new Dictionary<uint, Range> (capacity: 0);
+			if (Semantics != null) Semantics = new Dictionary<uint, Row<MethodSemanticsAttributes, MetadataToken>> (capacity: 0);
+			if (PInvokes != null) PInvokes = new Dictionary<uint, Row<PInvokeAttributes, uint, uint>> (capacity: 0);
+			if (GenericParameters != null) GenericParameters = new Dictionary<MetadataToken, Range []> (capacity: 0);
+			if (GenericConstraints != null) GenericConstraints = new Dictionary<uint, Collection<MetadataToken>> (capacity: 0);
+
+			Documents = Empty<Document>.Array;
+			ImportScopes = Empty<ImportDebugInformation>.Array;
+			if (LocalScopes != null) LocalScopes = new Dictionary<uint, Collection<Row<uint, Range, Range, uint, uint, uint>>> (capacity: 0);
+			if (StateMachineMethods != null) StateMachineMethods = new Dictionary<uint, uint> (capacity: 0);
+		}
+
+		public AssemblyNameReference GetAssemblyNameReference (uint rid)
+		{
+			if (rid < 1 || rid > AssemblyReferences.Length)
+				return null;
+
+			return AssemblyReferences [rid - 1];
+		}
+
+		public TypeDefinition GetTypeDefinition (uint rid)
+		{
+			if (rid < 1 || rid > Types.Length)
+				return null;
+
+			return Types [rid - 1];
+		}
+
+		public void AddTypeDefinition (TypeDefinition type)
+		{
+			Types [type.token.RID - 1] = type;
+		}
+
+		public TypeReference GetTypeReference (uint rid)
+		{
+			if (rid < 1 || rid > TypeReferences.Length)
+				return null;
+
+			return TypeReferences [rid - 1];
+		}
+
+		public void AddTypeReference (TypeReference type)
+		{
+			TypeReferences [type.token.RID - 1] = type;
+		}
+
+		public FieldDefinition GetFieldDefinition (uint rid)
+		{
+			if (rid < 1 || rid > Fields.Length)
+				return null;
+
+			return Fields [rid - 1];
+		}
+
+		public void AddFieldDefinition (FieldDefinition field)
+		{
+			Fields [field.token.RID - 1] = field;
+		}
+
+		public MethodDefinition GetMethodDefinition (uint rid)
+		{
+			if (rid < 1 || rid > Methods.Length)
+				return null;
+
+			return Methods [rid - 1];
+		}
+
+		public void AddMethodDefinition (MethodDefinition method)
+		{
+			Methods [method.token.RID - 1] = method;
+		}
+
+		public MemberReference GetMemberReference (uint rid)
+		{
+			if (rid < 1 || rid > MemberReferences.Length)
+				return null;
+
+			return MemberReferences [rid - 1];
+		}
+
+		public void AddMemberReference (MemberReference member)
+		{
+			MemberReferences [member.token.RID - 1] = member;
+		}
+
+		public bool TryGetNestedTypeMapping (TypeDefinition type, out Collection<uint> mapping)
+		{
+			return NestedTypes.TryGetValue (type.token.RID, out mapping);
+		}
+
+		public void SetNestedTypeMapping (uint type_rid, Collection<uint> mapping)
+		{
+			NestedTypes [type_rid] = mapping;
+		}
+
+		public void RemoveNestedTypeMapping (TypeDefinition type)
+		{
+			NestedTypes.Remove (type.token.RID);
+		}
+
+		public bool TryGetReverseNestedTypeMapping (TypeDefinition type, out uint declaring)
+		{
+			return ReverseNestedTypes.TryGetValue (type.token.RID, out declaring);
+		}
+
+		public void SetReverseNestedTypeMapping (uint nested, uint declaring)
+		{
+			ReverseNestedTypes [nested] = declaring;
+		}
+
+		public void RemoveReverseNestedTypeMapping (TypeDefinition type)
+		{
+			ReverseNestedTypes.Remove (type.token.RID);
+		}
+
+		public bool TryGetInterfaceMapping (TypeDefinition type, out Collection<Row<uint, MetadataToken>> mapping)
+		{
+			return Interfaces.TryGetValue (type.token.RID, out mapping);
+		}
+
+		public void SetInterfaceMapping (uint type_rid, Collection<Row<uint, MetadataToken>> mapping)
+		{
+			Interfaces [type_rid] = mapping;
+		}
+
+		public void RemoveInterfaceMapping (TypeDefinition type)
+		{
+			Interfaces.Remove (type.token.RID);
+		}
+
+		public void AddPropertiesRange (uint type_rid, Range range)
+		{
+			Properties.Add (type_rid, range);
+		}
+
+		public bool TryGetPropertiesRange (TypeDefinition type, out Range range)
+		{
+			return Properties.TryGetValue (type.token.RID, out range);
+		}
+
+		public void RemovePropertiesRange (TypeDefinition type)
+		{
+			Properties.Remove (type.token.RID);
+		}
+
+		public void AddEventsRange (uint type_rid, Range range)
+		{
+			Events.Add (type_rid, range);
+		}
+
+		public bool TryGetEventsRange (TypeDefinition type, out Range range)
+		{
+			return Events.TryGetValue (type.token.RID, out range);
+		}
+
+		public void RemoveEventsRange (TypeDefinition type)
+		{
+			Events.Remove (type.token.RID);
+		}
+
+		public bool TryGetGenericParameterRanges (IGenericParameterProvider owner, out Range [] ranges)
+		{
+			return GenericParameters.TryGetValue (owner.MetadataToken, out ranges);
+		}
+
+		public void RemoveGenericParameterRange (IGenericParameterProvider owner)
+		{
+			GenericParameters.Remove (owner.MetadataToken);
+		}
+
+		public bool TryGetCustomAttributeRanges (ICustomAttributeProvider owner, out Range [] ranges)
+		{
+			return CustomAttributes.TryGetValue (owner.MetadataToken, out ranges);
+		}
+
+		public void RemoveCustomAttributeRange (ICustomAttributeProvider owner)
+		{
+			CustomAttributes.Remove (owner.MetadataToken);
+		}
+
+		public bool TryGetSecurityDeclarationRanges (ISecurityDeclarationProvider owner, out Range [] ranges)
+		{
+			return SecurityDeclarations.TryGetValue (owner.MetadataToken, out ranges);
+		}
+
+		public void RemoveSecurityDeclarationRange (ISecurityDeclarationProvider owner)
+		{
+			SecurityDeclarations.Remove (owner.MetadataToken);
+		}
+
+		public bool TryGetGenericConstraintMapping (GenericParameter generic_parameter, out Collection<MetadataToken> mapping)
+		{
+			return GenericConstraints.TryGetValue (generic_parameter.token.RID, out mapping);
+		}
+
+		public void SetGenericConstraintMapping (uint gp_rid, Collection<MetadataToken> mapping)
+		{
+			GenericConstraints [gp_rid] = mapping;
+		}
+
+		public void RemoveGenericConstraintMapping (GenericParameter generic_parameter)
+		{
+			GenericConstraints.Remove (generic_parameter.token.RID);
+		}
+
+		public bool TryGetOverrideMapping (MethodDefinition method, out Collection<MetadataToken> mapping)
+		{
+			return Overrides.TryGetValue (method.token.RID, out mapping);
+		}
+
+		public void SetOverrideMapping (uint rid, Collection<MetadataToken> mapping)
+		{
+			Overrides [rid] = mapping;
+		}
+
+		public void RemoveOverrideMapping (MethodDefinition method)
+		{
+			Overrides.Remove (method.token.RID);
+		}
+
+		public Document GetDocument (uint rid)
+		{
+			if (rid < 1 || rid > Documents.Length)
+				return null;
+
+			return Documents [rid - 1];
+		}
+
+		public bool TryGetLocalScopes (MethodDefinition method, out Collection<Row<uint, Range, Range, uint, uint, uint>> scopes)
+		{
+			return LocalScopes.TryGetValue (method.MetadataToken.RID, out scopes);
+		}
+
+		public void SetLocalScopes (uint method_rid, Collection<Row<uint, Range, Range, uint, uint, uint>> records)
+		{
+			LocalScopes [method_rid] = records;
+		}
+
+		public ImportDebugInformation GetImportScope (uint rid)
+		{
+			if (rid < 1 || rid > ImportScopes.Length)
+				return null;
+
+			return ImportScopes [rid - 1];
+		}
+
+		public bool TryGetStateMachineKickOffMethod (MethodDefinition method, out uint rid)
+		{
+			return StateMachineMethods.TryGetValue (method.MetadataToken.RID, out rid);
+		}
+
+		public TypeDefinition GetFieldDeclaringType (uint field_rid)
+		{
+			return BinaryRangeSearch (Types, field_rid, true);
+		}
+
+		public TypeDefinition GetMethodDeclaringType (uint method_rid)
+		{
+			return BinaryRangeSearch (Types, method_rid, false);
+		}
+
+		static TypeDefinition BinaryRangeSearch (TypeDefinition [] types, uint rid, bool field)
+		{
+			int min = 0;
+			int max = types.Length - 1;
+			while (min <= max) {
+				int mid = min + ((max - min) / 2);
+				var type = types [mid];
+				var range = field ? type.fields_range : type.methods_range;
+
+				if (rid < range.Start)
+					max = mid - 1;
+				else if (rid >= range.Start + range.Length)
+					min = mid + 1;
+				else
+					return type;
+			}
+
+			return null;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MethodAttributes.cs b/src/Mono/Cecil/MethodAttributes.cs
new file mode 100644
index 00000000..1bd7d128
--- /dev/null
+++ b/src/Mono/Cecil/MethodAttributes.cs
@@ -0,0 +1,48 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum MethodAttributes : ushort {
+		MemberAccessMask	= 0x0007,
+		CompilerControlled	= 0x0000,	// Member not referenceable
+		Private				= 0x0001,	// Accessible only by the parent type
+		FamANDAssem			= 0x0002,	// Accessible by sub-types only in this Assembly
+		Assembly				= 0x0003,	// Accessibly by anyone in the Assembly
+		Family				= 0x0004,	// Accessible only by type and sub-types
+		FamORAssem			= 0x0005,	// Accessibly by sub-types anywhere, plus anyone in assembly
+		Public				= 0x0006,	// Accessibly by anyone who has visibility to this scope
+
+		Static				= 0x0010,	// Defined on type, else per instance
+		Final				= 0x0020,	// Method may not be overridden
+		Virtual				= 0x0040,	// Method is virtual
+		HideBySig			= 0x0080,	// Method hides by name+sig, else just by name
+
+		VtableLayoutMask	= 0x0100,	// Use this mask to retrieve vtable attributes
+		ReuseSlot			= 0x0000,	// Method reuses existing slot in vtable
+		NewSlot				= 0x0100,	// Method always gets a new slot in the vtable
+
+		CheckAccessOnOverride = 0x0200,   // Method can only be overriden if also accessible
+		Abstract			= 0x0400,	// Method does not provide an implementation
+		SpecialName			= 0x0800,	// Method is special
+
+		// Interop Attributes
+		PInvokeImpl			= 0x2000,	// Implementation is forwarded through PInvoke
+		UnmanagedExport		= 0x0008,	// Reserved: shall be zero for conforming implementations
+
+		// Additional flags
+		RTSpecialName		= 0x1000,	// CLI provides 'special' behavior, depending upon the name of the method
+		HasSecurity			= 0x4000,	// Method has security associate with it
+		RequireSecObject	= 0x8000	 // Method calls another method containing security code
+	}
+}
diff --git a/src/Mono/Cecil/MethodCallingConvention.cs b/src/Mono/Cecil/MethodCallingConvention.cs
new file mode 100644
index 00000000..f9c0e0c9
--- /dev/null
+++ b/src/Mono/Cecil/MethodCallingConvention.cs
@@ -0,0 +1,22 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum MethodCallingConvention : byte {
+		Default		= 0x0,
+		C			= 0x1,
+		StdCall		= 0x2,
+		ThisCall	= 0x3,
+		FastCall	= 0x4,
+		VarArg		= 0x5,
+		Generic		= 0x10,
+	}
+}
diff --git a/src/Mono/Cecil/MethodDefinition.cs b/src/Mono/Cecil/MethodDefinition.cs
new file mode 100644
index 00000000..76ce612d
--- /dev/null
+++ b/src/Mono/Cecil/MethodDefinition.cs
@@ -0,0 +1,545 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using Mono.Cecil.Cil;
+using Mono.Collections.Generic;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil {
+
+	public sealed class MethodDefinition : MethodReference, IMemberDefinition, ISecurityDeclarationProvider, ICustomDebugInformationProvider {
+
+		ushort attributes;
+		ushort impl_attributes;
+		internal volatile bool sem_attrs_ready;
+		internal MethodSemanticsAttributes sem_attrs;
+		Collection<CustomAttribute> custom_attributes;
+		Collection<SecurityDeclaration> security_declarations;
+
+		internal RVA rva;
+		internal PInvokeInfo pinvoke;
+		Collection<MethodReference> overrides;
+
+		internal MethodBody body;
+		internal MethodDebugInformation debug_info;
+		internal Collection<CustomDebugInformation> custom_infos;
+
+		public override string Name {
+			get { return base.Name; }
+			set {
+				if (IsWindowsRuntimeProjection && value != base.Name)
+					throw new InvalidOperationException ();
+
+				base.Name = value;
+			}
+		}
+
+		public MethodAttributes Attributes {
+			get { return (MethodAttributes) attributes; }
+			set {
+				if (IsWindowsRuntimeProjection && (ushort) value != attributes)
+					throw new InvalidOperationException ();
+
+				attributes = (ushort) value;
+			}
+		}
+
+		public MethodImplAttributes ImplAttributes {
+			get { return (MethodImplAttributes) impl_attributes; }
+			set {
+				if (IsWindowsRuntimeProjection && (ushort) value != impl_attributes)
+					throw new InvalidOperationException ();
+
+				impl_attributes = (ushort) value;
+			}
+		}
+
+		public MethodSemanticsAttributes SemanticsAttributes {
+			get {
+				if (sem_attrs_ready)
+					return sem_attrs;
+
+				if (HasImage) {
+					ReadSemantics ();
+					return sem_attrs;
+				}
+
+				sem_attrs = MethodSemanticsAttributes.None;
+				sem_attrs_ready = true;
+				return sem_attrs;
+			}
+			set { sem_attrs = value; }
+		}
+
+		internal new MethodDefinitionProjection WindowsRuntimeProjection {
+			get { return (MethodDefinitionProjection) projection; }
+			set { projection = value; }
+		}
+
+		internal void ReadSemantics ()
+		{
+			if (sem_attrs_ready)
+				return;
+
+			var module = this.Module;
+			if (module == null)
+				return;
+
+			if (!module.HasImage)
+				return;
+
+			module.Read (this, (method, reader) => reader.ReadAllSemantics (method));
+		}
+
+		public bool HasSecurityDeclarations {
+			get {
+				if (security_declarations != null)
+					return security_declarations.Count > 0;
+
+				return this.GetHasSecurityDeclarations (Module);
+			}
+		}
+
+		public Collection<SecurityDeclaration> SecurityDeclarations {
+			get { return security_declarations ?? (this.GetSecurityDeclarations (ref security_declarations, Module)); }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, Module)); }
+		}
+
+		public int RVA {
+			get { return (int) rva; }
+		}
+
+		public bool HasBody {
+			get {
+				return (attributes & (ushort) MethodAttributes.Abstract) == 0 &&
+					(attributes & (ushort) MethodAttributes.PInvokeImpl) == 0 &&
+					(impl_attributes & (ushort) MethodImplAttributes.InternalCall) == 0 &&
+					(impl_attributes & (ushort) MethodImplAttributes.Native) == 0 &&
+					(impl_attributes & (ushort) MethodImplAttributes.Unmanaged) == 0 &&
+					(impl_attributes & (ushort) MethodImplAttributes.Runtime) == 0;
+			}
+		}
+
+		public MethodBody Body {
+			get {
+				var local = this.body;
+				if (local != null)
+					return local;
+
+				if (!HasBody)
+					return null;
+
+				if (HasImage && rva != 0)
+					return Module.Read (ref body, this, (method, reader) => reader.ReadMethodBody (method));
+
+				return body = new MethodBody (this);
+			}
+			set {
+				var module = this.Module;
+				if (module == null) {
+					body = value;
+					return;
+				}
+
+				// we reset Body to null in ILSpy to save memory; so we need that operation to be thread-safe
+				lock (module.SyncRoot) {
+					body = value;
+					if (value == null)
+						this.debug_info = null;
+				}
+			}
+		}
+
+		public MethodDebugInformation DebugInformation {
+			get {
+				Mixin.Read (Body);
+
+				if (debug_info != null)
+					return debug_info;
+
+				return debug_info ?? (debug_info = new MethodDebugInformation (this));
+			}
+			set {
+				debug_info = value;
+			}
+		}
+
+		public bool HasPInvokeInfo {
+			get {
+				if (pinvoke != null)
+					return true;
+
+				return IsPInvokeImpl;
+			}
+		}
+
+		public PInvokeInfo PInvokeInfo {
+			get {
+				if (pinvoke != null)
+					return pinvoke;
+
+				if (HasImage && IsPInvokeImpl)
+					return Module.Read (ref pinvoke, this, (method, reader) => reader.ReadPInvokeInfo (method));
+
+				return null;
+			}
+			set {
+				IsPInvokeImpl = true;
+				pinvoke = value;
+			}
+		}
+
+		public bool HasOverrides {
+			get {
+				if (overrides != null)
+					return overrides.Count > 0;
+
+				return HasImage && Module.Read (this, (method, reader) => reader.HasOverrides (method));
+			}
+		}
+
+		public Collection<MethodReference> Overrides {
+			get {
+				if (overrides != null)
+					return overrides;
+
+				if (HasImage)
+					return Module.Read (ref overrides, this, (method, reader) => reader.ReadOverrides (method));
+
+				return overrides = new Collection<MethodReference> ();
+			}
+		}
+
+		public override bool HasGenericParameters {
+			get {
+				if (generic_parameters != null)
+					return generic_parameters.Count > 0;
+
+				return this.GetHasGenericParameters (Module);
+			}
+		}
+
+		public override Collection<GenericParameter> GenericParameters {
+			get { return generic_parameters ?? (this.GetGenericParameters (ref generic_parameters, Module)); }
+		}
+
+		public bool HasCustomDebugInformations {
+			get {
+				Mixin.Read (Body);
+
+				return !custom_infos.IsNullOrEmpty ();
+			}
+		}
+
+		public Collection<CustomDebugInformation> CustomDebugInformations {
+			get {
+				Mixin.Read (Body);
+
+				return custom_infos ?? (custom_infos = new Collection<CustomDebugInformation> ());
+			}
+		}
+
+		#region MethodAttributes
+
+		public bool IsCompilerControlled {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.CompilerControlled); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.CompilerControlled, value); }
+		}
+
+		public bool IsPrivate {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Private); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Private, value); }
+		}
+
+		public bool IsFamilyAndAssembly {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.FamANDAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.FamANDAssem, value); }
+		}
+
+		public bool IsAssembly {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Assembly); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Assembly, value); }
+		}
+
+		public bool IsFamily {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Family); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Family, value); }
+		}
+
+		public bool IsFamilyOrAssembly {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.FamORAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.FamORAssem, value); }
+		}
+
+		public bool IsPublic {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Public); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.MemberAccessMask, (ushort) MethodAttributes.Public, value); }
+		}
+
+		public bool IsStatic {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.Static); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.Static, value); }
+		}
+
+		public bool IsFinal {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.Final); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.Final, value); }
+		}
+
+		public bool IsVirtual {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.Virtual); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.Virtual, value); }
+		}
+
+		public bool IsHideBySig {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.HideBySig); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.HideBySig, value); }
+		}
+
+		public bool IsReuseSlot {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.VtableLayoutMask, (ushort) MethodAttributes.ReuseSlot); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.VtableLayoutMask, (ushort) MethodAttributes.ReuseSlot, value); }
+		}
+
+		public bool IsNewSlot {
+			get { return attributes.GetMaskedAttributes ((ushort) MethodAttributes.VtableLayoutMask, (ushort) MethodAttributes.NewSlot); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) MethodAttributes.VtableLayoutMask, (ushort) MethodAttributes.NewSlot, value); }
+		}
+
+		public bool IsCheckAccessOnOverride {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.CheckAccessOnOverride); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.CheckAccessOnOverride, value); }
+		}
+
+		public bool IsAbstract {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.Abstract); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.Abstract, value); }
+		}
+
+		public bool IsSpecialName {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.SpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.SpecialName, value); }
+		}
+
+		public bool IsPInvokeImpl {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.PInvokeImpl); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.PInvokeImpl, value); }
+		}
+
+		public bool IsUnmanagedExport {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.UnmanagedExport); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.UnmanagedExport, value); }
+		}
+
+		public bool IsRuntimeSpecialName {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.RTSpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.RTSpecialName, value); }
+		}
+
+		public bool HasSecurity {
+			get { return attributes.GetAttributes ((ushort) MethodAttributes.HasSecurity); }
+			set { attributes = attributes.SetAttributes ((ushort) MethodAttributes.HasSecurity, value); }
+		}
+
+		#endregion
+
+		#region MethodImplAttributes
+
+		public bool IsIL {
+			get { return impl_attributes.GetMaskedAttributes ((ushort) MethodImplAttributes.CodeTypeMask, (ushort) MethodImplAttributes.IL); }
+			set { impl_attributes = impl_attributes.SetMaskedAttributes ((ushort) MethodImplAttributes.CodeTypeMask, (ushort) MethodImplAttributes.IL, value); }
+		}
+
+		public bool IsNative {
+			get { return impl_attributes.GetMaskedAttributes ((ushort) MethodImplAttributes.CodeTypeMask, (ushort) MethodImplAttributes.Native); }
+			set { impl_attributes = impl_attributes.SetMaskedAttributes ((ushort) MethodImplAttributes.CodeTypeMask, (ushort) MethodImplAttributes.Native, value); }
+		}
+
+		public bool IsRuntime {
+			get { return impl_attributes.GetMaskedAttributes ((ushort) MethodImplAttributes.CodeTypeMask, (ushort) MethodImplAttributes.Runtime); }
+			set { impl_attributes = impl_attributes.SetMaskedAttributes ((ushort) MethodImplAttributes.CodeTypeMask, (ushort) MethodImplAttributes.Runtime, value); }
+		}
+
+		public bool IsUnmanaged {
+			get { return impl_attributes.GetMaskedAttributes ((ushort) MethodImplAttributes.ManagedMask, (ushort) MethodImplAttributes.Unmanaged); }
+			set { impl_attributes = impl_attributes.SetMaskedAttributes ((ushort) MethodImplAttributes.ManagedMask, (ushort) MethodImplAttributes.Unmanaged, value); }
+		}
+
+		public bool IsManaged {
+			get { return impl_attributes.GetMaskedAttributes ((ushort) MethodImplAttributes.ManagedMask, (ushort) MethodImplAttributes.Managed); }
+			set { impl_attributes = impl_attributes.SetMaskedAttributes ((ushort) MethodImplAttributes.ManagedMask, (ushort) MethodImplAttributes.Managed, value); }
+		}
+
+		public bool IsForwardRef {
+			get { return impl_attributes.GetAttributes ((ushort) MethodImplAttributes.ForwardRef); }
+			set { impl_attributes = impl_attributes.SetAttributes ((ushort) MethodImplAttributes.ForwardRef, value); }
+		}
+
+		public bool IsPreserveSig {
+			get { return impl_attributes.GetAttributes ((ushort) MethodImplAttributes.PreserveSig); }
+			set { impl_attributes = impl_attributes.SetAttributes ((ushort) MethodImplAttributes.PreserveSig, value); }
+		}
+
+		public bool IsInternalCall {
+			get { return impl_attributes.GetAttributes ((ushort) MethodImplAttributes.InternalCall); }
+			set { impl_attributes = impl_attributes.SetAttributes ((ushort) MethodImplAttributes.InternalCall, value); }
+		}
+
+		public bool IsSynchronized {
+			get { return impl_attributes.GetAttributes ((ushort) MethodImplAttributes.Synchronized); }
+			set { impl_attributes = impl_attributes.SetAttributes ((ushort) MethodImplAttributes.Synchronized, value); }
+		}
+
+		public bool NoInlining {
+			get { return impl_attributes.GetAttributes ((ushort) MethodImplAttributes.NoInlining); }
+			set { impl_attributes = impl_attributes.SetAttributes ((ushort) MethodImplAttributes.NoInlining, value); }
+		}
+
+		public bool NoOptimization {
+			get { return impl_attributes.GetAttributes ((ushort) MethodImplAttributes.NoOptimization); }
+			set { impl_attributes = impl_attributes.SetAttributes ((ushort) MethodImplAttributes.NoOptimization, value); }
+		}
+
+		public bool AggressiveInlining {
+			get { return impl_attributes.GetAttributes ((ushort) MethodImplAttributes.AggressiveInlining); }
+			set { impl_attributes = impl_attributes.SetAttributes ((ushort) MethodImplAttributes.AggressiveInlining, value); }
+		}
+
+		#endregion
+
+		#region MethodSemanticsAttributes
+
+		public bool IsSetter {
+			get { return this.GetSemantics (MethodSemanticsAttributes.Setter); }
+			set { this.SetSemantics (MethodSemanticsAttributes.Setter, value); }
+		}
+
+		public bool IsGetter {
+			get { return this.GetSemantics (MethodSemanticsAttributes.Getter); }
+			set { this.SetSemantics (MethodSemanticsAttributes.Getter, value); }
+		}
+
+		public bool IsOther {
+			get { return this.GetSemantics (MethodSemanticsAttributes.Other); }
+			set { this.SetSemantics (MethodSemanticsAttributes.Other, value); }
+		}
+
+		public bool IsAddOn {
+			get { return this.GetSemantics (MethodSemanticsAttributes.AddOn); }
+			set { this.SetSemantics (MethodSemanticsAttributes.AddOn, value); }
+		}
+
+		public bool IsRemoveOn {
+			get { return this.GetSemantics (MethodSemanticsAttributes.RemoveOn); }
+			set { this.SetSemantics (MethodSemanticsAttributes.RemoveOn, value); }
+		}
+
+		public bool IsFire {
+			get { return this.GetSemantics (MethodSemanticsAttributes.Fire); }
+			set { this.SetSemantics (MethodSemanticsAttributes.Fire, value); }
+		}
+
+		#endregion
+
+		public new TypeDefinition DeclaringType {
+			get { return (TypeDefinition) base.DeclaringType; }
+			set { base.DeclaringType = value; }
+		}
+
+		public bool IsConstructor {
+			get {
+				return this.IsRuntimeSpecialName
+					&& this.IsSpecialName
+					&& (this.Name == ".cctor" || this.Name == ".ctor");
+			}
+		}
+
+		public override bool IsDefinition {
+			get { return true; }
+		}
+
+		internal MethodDefinition ()
+		{
+			this.token = new MetadataToken (TokenType.Method);
+		}
+
+		public MethodDefinition (string name, MethodAttributes attributes, TypeReference returnType)
+			: base (name, returnType)
+		{
+			this.attributes = (ushort) attributes;
+			this.HasThis = !this.IsStatic;
+			this.token = new MetadataToken (TokenType.Method);
+		}
+
+		public override MethodDefinition Resolve ()
+		{
+			return this;
+		}
+	}
+
+	static partial class Mixin {
+
+		public static ParameterDefinition GetParameter (this MethodBody self, int index)
+		{
+			var method = self.method;
+
+			if (method.HasThis) {
+				if (index == 0)
+					return self.ThisParameter;
+
+				index--;
+			}
+
+			var parameters = method.Parameters;
+
+			if (index < 0 || index >= parameters.size)
+				return null;
+
+			return parameters [index];
+		}
+
+		public static VariableDefinition GetVariable (this MethodBody self, int index)
+		{
+			var variables = self.Variables;
+
+			if (index < 0 || index >= variables.size)
+				return null;
+
+			return variables [index];
+		}
+
+		public static bool GetSemantics (this MethodDefinition self, MethodSemanticsAttributes semantics)
+		{
+			return (self.SemanticsAttributes & semantics) != 0;
+		}
+
+		public static void SetSemantics (this MethodDefinition self, MethodSemanticsAttributes semantics, bool value)
+		{
+			if (value)
+				self.SemanticsAttributes |= semantics;
+			else
+				self.SemanticsAttributes &= ~semantics;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MethodImplAttributes.cs b/src/Mono/Cecil/MethodImplAttributes.cs
new file mode 100644
index 00000000..2f1f0183
--- /dev/null
+++ b/src/Mono/Cecil/MethodImplAttributes.cs
@@ -0,0 +1,36 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum MethodImplAttributes : ushort {
+		CodeTypeMask		= 0x0003,
+		IL					= 0x0000,	// Method impl is CIL
+		Native				= 0x0001,	// Method impl is native
+		OPTIL				= 0x0002,	// Reserved: shall be zero in conforming implementations
+		Runtime				= 0x0003,	// Method impl is provided by the runtime
+
+		ManagedMask			= 0x0004,	// Flags specifying whether the code is managed or unmanaged
+		Unmanaged			= 0x0004,	// Method impl is unmanaged, otherwise managed
+		Managed				= 0x0000,	// Method impl is managed
+
+		// Implementation info and interop
+		ForwardRef			= 0x0010,	// Indicates method is defined; used primarily in merge scenarios
+		PreserveSig			= 0x0080,	// Reserved: conforming implementations may ignore
+		InternalCall		= 0x1000,	// Reserved: shall be zero in conforming implementations
+		Synchronized		= 0x0020,	// Method is single threaded through the body
+		NoOptimization		= 0x0040,	// Method is not optimized by the JIT.
+		NoInlining			= 0x0008,	// Method may not be inlined
+		AggressiveInlining  = 0x0100,   // Method should be inlined, if possible.
+	}
+}
diff --git a/src/Mono/Cecil/MethodReference.cs b/src/Mono/Cecil/MethodReference.cs
new file mode 100644
index 00000000..bd5fb77b
--- /dev/null
+++ b/src/Mono/Cecil/MethodReference.cs
@@ -0,0 +1,202 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public class MethodReference : MemberReference, IMethodSignature, IGenericParameterProvider, IGenericContext {
+
+		internal ParameterDefinitionCollection parameters;
+		MethodReturnType return_type;
+
+		bool has_this;
+		bool explicit_this;
+		MethodCallingConvention calling_convention;
+		internal Collection<GenericParameter> generic_parameters;
+
+		public virtual bool HasThis {
+			get { return has_this; }
+			set { has_this = value; }
+		}
+
+		public virtual bool ExplicitThis {
+			get { return explicit_this; }
+			set { explicit_this = value; }
+		}
+
+		public virtual MethodCallingConvention CallingConvention {
+			get { return calling_convention; }
+			set { calling_convention = value; }
+		}
+
+		public virtual bool HasParameters {
+			get { return !parameters.IsNullOrEmpty (); }
+		}
+
+		public virtual Collection<ParameterDefinition> Parameters {
+			get {
+				if (parameters == null)
+					parameters = new ParameterDefinitionCollection (this);
+
+				return parameters;
+			}
+		}
+
+		IGenericParameterProvider IGenericContext.Type {
+			get {
+				var declaring_type = this.DeclaringType;
+				var instance = declaring_type as GenericInstanceType;
+				if (instance != null)
+					return instance.ElementType;
+
+				return declaring_type;
+			}
+		}
+
+		IGenericParameterProvider IGenericContext.Method {
+			get { return this; }
+		}
+
+		GenericParameterType IGenericParameterProvider.GenericParameterType {
+			get { return GenericParameterType.Method; }
+		}
+
+		public virtual bool HasGenericParameters {
+			get { return !generic_parameters.IsNullOrEmpty (); }
+		}
+
+		public virtual Collection<GenericParameter> GenericParameters {
+			get {
+				if (generic_parameters != null)
+					return generic_parameters;
+
+				return generic_parameters = new GenericParameterCollection (this);
+			}
+		}
+
+		public TypeReference ReturnType {
+			get {
+				var return_type = MethodReturnType;
+				return return_type != null ? return_type.ReturnType : null;
+			}
+			set {
+				var return_type = MethodReturnType;
+				if (return_type != null)
+					return_type.ReturnType = value;
+			}
+		}
+
+		public virtual MethodReturnType MethodReturnType {
+			get { return return_type; }
+			set { return_type = value; }
+		}
+
+		public override string FullName {
+			get {
+				var builder = new StringBuilder ();
+				builder.Append (ReturnType.FullName)
+					.Append (" ")
+					.Append (MemberFullName ());
+				this.MethodSignatureFullName (builder);
+				return builder.ToString ();
+			}
+		}
+
+		public virtual bool IsGenericInstance {
+			get { return false; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get {
+				if (this.ReturnType.ContainsGenericParameter || base.ContainsGenericParameter)
+					return true;
+
+				if (!HasParameters)
+					return false;
+
+				var parameters = this.Parameters;
+
+				for (int i = 0; i < parameters.Count; i++)
+					if (parameters [i].ParameterType.ContainsGenericParameter)
+						return true;
+
+				return false;
+			}
+		}
+
+		internal MethodReference ()
+		{
+			this.return_type = new MethodReturnType (this);
+			this.token = new MetadataToken (TokenType.MemberRef);
+		}
+
+		public MethodReference (string name, TypeReference returnType)
+			: base (name)
+		{
+			Mixin.CheckType (returnType, Mixin.Argument.returnType);
+
+			this.return_type = new MethodReturnType (this);
+			this.return_type.ReturnType = returnType;
+			this.token = new MetadataToken (TokenType.MemberRef);
+		}
+
+		public MethodReference (string name, TypeReference returnType, TypeReference declaringType)
+			: this (name, returnType)
+		{
+			Mixin.CheckType (declaringType, Mixin.Argument.declaringType);
+
+			this.DeclaringType = declaringType;
+		}
+
+		public virtual MethodReference GetElementMethod ()
+		{
+			return this;
+		}
+
+		protected override IMemberDefinition ResolveDefinition ()
+		{
+			return this.Resolve ();
+		}
+
+		public new virtual MethodDefinition Resolve ()
+		{
+			var module = this.Module;
+			if (module == null)
+				throw new NotSupportedException ();
+
+			return module.Resolve (this);
+		}
+	}
+
+	static partial class Mixin {
+
+		public static bool IsVarArg (this IMethodSignature self)
+		{
+			return self.CallingConvention == MethodCallingConvention.VarArg;
+		}
+
+		public static int GetSentinelPosition (this IMethodSignature self)
+		{
+			if (!self.HasParameters)
+				return -1;
+
+			var parameters = self.Parameters;
+			for (int i = 0; i < parameters.Count; i++)
+				if (parameters [i].ParameterType.IsSentinel)
+					return i;
+
+			return -1;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MethodReturnType.cs b/src/Mono/Cecil/MethodReturnType.cs
new file mode 100644
index 00000000..71a78de1
--- /dev/null
+++ b/src/Mono/Cecil/MethodReturnType.cs
@@ -0,0 +1,98 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System.Threading;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class MethodReturnType : IConstantProvider, ICustomAttributeProvider, IMarshalInfoProvider {
+
+		internal IMethodSignature method;
+		internal ParameterDefinition parameter;
+		TypeReference return_type;
+
+		public IMethodSignature Method {
+			get { return method; }
+		}
+
+		public TypeReference ReturnType {
+			get { return return_type; }
+			set { return_type = value; }
+		}
+
+		internal ParameterDefinition Parameter {
+			get {
+				if (parameter == null)
+					Interlocked.CompareExchange (ref parameter, new ParameterDefinition (return_type, method), null);
+
+				return parameter;
+			}
+		}
+
+		public MetadataToken MetadataToken {
+			get { return Parameter.MetadataToken; }
+			set { Parameter.MetadataToken = value; }
+		}
+
+		public ParameterAttributes Attributes {
+			get { return Parameter.Attributes; }
+			set { Parameter.Attributes = value; }
+		}
+
+		public string Name {
+			get { return Parameter.Name; }
+			set { Parameter.Name = value; }
+		}
+
+		public bool HasCustomAttributes {
+			get { return parameter != null && parameter.HasCustomAttributes; }
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return Parameter.CustomAttributes; }
+		}
+
+		public bool HasDefault {
+			get { return parameter != null && parameter.HasDefault; }
+			set { Parameter.HasDefault = value; }
+		}
+
+		public bool HasConstant {
+			get { return parameter != null && parameter.HasConstant; }
+			set { Parameter.HasConstant = value; }
+		}
+
+		public object Constant {
+			get { return Parameter.Constant; }
+			set { Parameter.Constant = value; }
+		}
+
+		public bool HasFieldMarshal {
+			get { return parameter != null && parameter.HasFieldMarshal; }
+			set { Parameter.HasFieldMarshal = value; }
+		}
+
+		public bool HasMarshalInfo {
+			get { return parameter != null && parameter.HasMarshalInfo; }
+		}
+
+		public MarshalInfo MarshalInfo {
+			get { return Parameter.MarshalInfo; }
+			set { Parameter.MarshalInfo = value; }
+		}
+
+		public MethodReturnType (IMethodSignature method)
+		{
+			this.method = method;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/MethodSemanticsAttributes.cs b/src/Mono/Cecil/MethodSemanticsAttributes.cs
new file mode 100644
index 00000000..274dfd04
--- /dev/null
+++ b/src/Mono/Cecil/MethodSemanticsAttributes.cs
@@ -0,0 +1,25 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum MethodSemanticsAttributes : ushort {
+		None		= 0x0000,
+		Setter		= 0x0001,	// Setter for property
+		Getter		= 0x0002,	// Getter for property
+		Other		= 0x0004,	// Other method for property or event
+		AddOn		= 0x0008,	// AddOn method for event
+		RemoveOn	= 0x0010,	// RemoveOn method for event
+		Fire		= 0x0020	 // Fire method for event
+	}
+}
diff --git a/src/Mono/Cecil/MethodSpecification.cs b/src/Mono/Cecil/MethodSpecification.cs
new file mode 100644
index 00000000..040be6ed
--- /dev/null
+++ b/src/Mono/Cecil/MethodSpecification.cs
@@ -0,0 +1,84 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public abstract class MethodSpecification : MethodReference {
+
+		readonly MethodReference method;
+
+		public MethodReference ElementMethod {
+			get { return method; }
+		}
+
+		public override string Name {
+			get { return method.Name; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override MethodCallingConvention CallingConvention {
+			get { return method.CallingConvention; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool HasThis {
+			get { return method.HasThis; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool ExplicitThis {
+			get { return method.ExplicitThis; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override MethodReturnType MethodReturnType {
+			get { return method.MethodReturnType; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override TypeReference DeclaringType {
+			get { return method.DeclaringType; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override ModuleDefinition Module {
+			get { return method.Module; }
+		}
+
+		public override bool HasParameters {
+			get { return method.HasParameters; }
+		}
+
+		public override Collection<ParameterDefinition> Parameters {
+			get { return method.Parameters; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return method.ContainsGenericParameter; }
+		}
+
+		internal MethodSpecification (MethodReference method)
+		{
+			Mixin.CheckMethod (method);
+
+			this.method = method;
+			this.token = new MetadataToken (TokenType.MethodSpec);
+		}
+
+		public sealed override MethodReference GetElementMethod ()
+		{
+			return method.GetElementMethod ();
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Modifiers.cs b/src/Mono/Cecil/Modifiers.cs
new file mode 100644
index 00000000..9c50f0e4
--- /dev/null
+++ b/src/Mono/Cecil/Modifiers.cs
@@ -0,0 +1,112 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public interface IModifierType {
+		TypeReference ModifierType { get; }
+		TypeReference ElementType { get; }
+	}
+
+	public sealed class OptionalModifierType : TypeSpecification, IModifierType {
+
+		TypeReference modifier_type;
+
+		public TypeReference ModifierType {
+			get { return modifier_type; }
+			set { modifier_type = value; }
+		}
+
+		public override string Name {
+			get { return base.Name + Suffix; }
+		}
+
+		public override string FullName {
+			get { return base.FullName + Suffix; }
+		}
+
+		string Suffix {
+			get { return " modopt(" + modifier_type + ")"; }
+		}
+
+		public override bool IsValueType {
+			get { return false; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool IsOptionalModifier {
+			get { return true; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return modifier_type.ContainsGenericParameter || base.ContainsGenericParameter; }
+		}
+
+		public OptionalModifierType (TypeReference modifierType, TypeReference type)
+			: base (type)
+		{
+			if (modifierType == null)
+				throw new ArgumentNullException (Mixin.Argument.modifierType.ToString ());
+			Mixin.CheckType (type);
+			this.modifier_type = modifierType;
+			this.etype = MD.ElementType.CModOpt;
+		}
+	}
+
+	public sealed class RequiredModifierType : TypeSpecification, IModifierType {
+
+		TypeReference modifier_type;
+
+		public TypeReference ModifierType {
+			get { return modifier_type; }
+			set { modifier_type = value; }
+		}
+
+		public override string Name {
+			get { return base.Name + Suffix; }
+		}
+
+		public override string FullName {
+			get { return base.FullName + Suffix; }
+		}
+
+		string Suffix {
+			get { return " modreq(" + modifier_type + ")"; }
+		}
+
+		public override bool IsValueType {
+			get { return false; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool IsRequiredModifier {
+			get { return true; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return modifier_type.ContainsGenericParameter || base.ContainsGenericParameter; }
+		}
+
+		public RequiredModifierType (TypeReference modifierType, TypeReference type)
+			: base (type)
+		{
+			if (modifierType == null)
+				throw new ArgumentNullException (Mixin.Argument.modifierType.ToString ());
+			Mixin.CheckType (type);
+			this.modifier_type = modifierType;
+			this.etype = MD.ElementType.CModReqD;
+		}
+
+	}
+}
diff --git a/src/Mono/Cecil/ModuleDefinition.cs b/src/Mono/Cecil/ModuleDefinition.cs
new file mode 100644
index 00000000..4bee2f83
--- /dev/null
+++ b/src/Mono/Cecil/ModuleDefinition.cs
@@ -0,0 +1,1373 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using SR = System.Reflection;
+
+using Mono.Cecil.Cil;
+using Mono.Cecil.Metadata;
+using Mono.Cecil.PE;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public enum ReadingMode {
+		Immediate = 1,
+		Deferred = 2,
+	}
+
+	public sealed class ReaderParameters {
+
+		ReadingMode reading_mode;
+		internal IAssemblyResolver assembly_resolver;
+		internal IMetadataResolver metadata_resolver;
+#if !READ_ONLY
+		internal IMetadataImporterProvider metadata_importer_provider;
+		internal IReflectionImporterProvider reflection_importer_provider;
+#endif
+		Stream symbol_stream;
+		ISymbolReaderProvider symbol_reader_provider;
+		bool read_symbols;
+		bool throw_symbols_mismatch;
+		bool projections;
+		bool in_memory;
+		bool read_write;
+
+		public ReadingMode ReadingMode {
+			get { return reading_mode; }
+			set { reading_mode = value; }
+		}
+
+		public bool InMemory {
+			get { return in_memory; }
+			set { in_memory = value; }
+		}
+
+		public IAssemblyResolver AssemblyResolver {
+			get { return assembly_resolver; }
+			set { assembly_resolver = value; }
+		}
+
+		public IMetadataResolver MetadataResolver {
+			get { return metadata_resolver; }
+			set { metadata_resolver = value; }
+		}
+
+#if !READ_ONLY
+		public IMetadataImporterProvider MetadataImporterProvider {
+			get { return metadata_importer_provider; }
+			set { metadata_importer_provider = value; }
+		}
+
+		public IReflectionImporterProvider ReflectionImporterProvider {
+			get { return reflection_importer_provider; }
+			set { reflection_importer_provider = value; }
+		}
+#endif
+
+		public Stream SymbolStream {
+			get { return symbol_stream; }
+			set { symbol_stream = value; }
+		}
+
+		public ISymbolReaderProvider SymbolReaderProvider {
+			get { return symbol_reader_provider; }
+			set { symbol_reader_provider = value; }
+		}
+
+		public bool ReadSymbols {
+			get { return read_symbols; }
+			set { read_symbols = value; }
+		}
+
+		public bool ThrowIfSymbolsAreNotMatching {
+			get { return throw_symbols_mismatch; }
+			set { throw_symbols_mismatch = value; }
+		}
+
+		public bool ReadWrite {
+			get { return read_write; }
+			set { read_write = value; }
+		}
+
+		public bool ApplyWindowsRuntimeProjections {
+			get { return projections; }
+			set { projections = value; }
+		}
+
+		public ReaderParameters ()
+			: this (ReadingMode.Deferred)
+		{
+		}
+
+		public ReaderParameters (ReadingMode readingMode)
+		{
+			this.reading_mode = readingMode;
+			this.throw_symbols_mismatch = true;
+		}
+	}
+
+#if !READ_ONLY
+
+	public sealed class ModuleParameters {
+
+		ModuleKind kind;
+		TargetRuntime runtime;
+		uint? timestamp;
+		TargetArchitecture architecture;
+		IAssemblyResolver assembly_resolver;
+		IMetadataResolver metadata_resolver;
+#if !READ_ONLY
+		IMetadataImporterProvider metadata_importer_provider;
+		IReflectionImporterProvider reflection_importer_provider;
+#endif
+
+		public ModuleKind Kind {
+			get { return kind; }
+			set { kind = value; }
+		}
+
+		public TargetRuntime Runtime {
+			get { return runtime; }
+			set { runtime = value; }
+		}
+
+		public uint? Timestamp {
+			get { return timestamp; }
+			set { timestamp = value; }
+		}
+
+		public TargetArchitecture Architecture {
+			get { return architecture; }
+			set { architecture = value; }
+		}
+
+		public IAssemblyResolver AssemblyResolver {
+			get { return assembly_resolver; }
+			set { assembly_resolver = value; }
+		}
+
+		public IMetadataResolver MetadataResolver {
+			get { return metadata_resolver; }
+			set { metadata_resolver = value; }
+		}
+
+#if !READ_ONLY
+		public IMetadataImporterProvider MetadataImporterProvider {
+			get { return metadata_importer_provider; }
+			set { metadata_importer_provider = value; }
+		}
+
+		public IReflectionImporterProvider ReflectionImporterProvider {
+			get { return reflection_importer_provider; }
+			set { reflection_importer_provider = value; }
+		}
+#endif
+
+		public ModuleParameters ()
+		{
+			this.kind = ModuleKind.Dll;
+			this.Runtime = GetCurrentRuntime ();
+			this.architecture = TargetArchitecture.I386;
+		}
+
+		static TargetRuntime GetCurrentRuntime ()
+		{
+#if !NET_CORE
+			return typeof (object).Assembly.ImageRuntimeVersion.ParseRuntime ();
+#else
+			var corlib_name = AssemblyNameReference.Parse (typeof (object).Assembly ().FullName);
+			var corlib_version = corlib_name.Version;
+
+			switch (corlib_version.Major) {
+			case 1:
+				return corlib_version.Minor == 0
+					? TargetRuntime.Net_1_0
+					: TargetRuntime.Net_1_1;
+			case 2:
+				return TargetRuntime.Net_2_0;
+			case 4:
+				return TargetRuntime.Net_4_0;
+			default:
+				throw new NotSupportedException ();
+			}
+#endif
+		}
+	}
+
+	public sealed class WriterParameters {
+
+		uint? timestamp;
+		Stream symbol_stream;
+		ISymbolWriterProvider symbol_writer_provider;
+		bool write_symbols;
+#if !NET_CORE
+		SR.StrongNameKeyPair key_pair;
+#endif
+
+		public uint? Timestamp {
+			get { return timestamp; }
+			set { timestamp = value; }
+		}
+
+		public Stream SymbolStream {
+			get { return symbol_stream; }
+			set { symbol_stream = value; }
+		}
+
+		public ISymbolWriterProvider SymbolWriterProvider {
+			get { return symbol_writer_provider; }
+			set { symbol_writer_provider = value; }
+		}
+
+		public bool WriteSymbols {
+			get { return write_symbols; }
+			set { write_symbols = value; }
+		}
+
+#if !NET_CORE
+		public SR.StrongNameKeyPair StrongNameKeyPair {
+			get { return key_pair; }
+			set { key_pair = value; }
+		}
+#endif
+	}
+
+#endif
+
+	public sealed class ModuleDefinition : ModuleReference, ICustomAttributeProvider, ICustomDebugInformationProvider, IDisposable {
+
+		internal Image Image;
+		internal MetadataSystem MetadataSystem;
+		internal ReadingMode ReadingMode;
+		internal ISymbolReaderProvider SymbolReaderProvider;
+
+		internal ISymbolReader symbol_reader;
+		internal Disposable<IAssemblyResolver> assembly_resolver;
+		internal IMetadataResolver metadata_resolver;
+		internal TypeSystem type_system;
+		internal readonly MetadataReader reader;
+		readonly string file_name;
+
+		internal string runtime_version;
+		internal ModuleKind kind;
+		WindowsRuntimeProjections projections;
+		MetadataKind metadata_kind;
+		TargetRuntime runtime;
+		TargetArchitecture architecture;
+		ModuleAttributes attributes;
+		ModuleCharacteristics characteristics;
+		Guid mvid;
+
+		internal ushort linker_version = 8;
+		internal ushort subsystem_major = 4;
+		internal ushort subsystem_minor = 0;
+		internal uint timestamp;
+
+		internal AssemblyDefinition assembly;
+		MethodDefinition entry_point;
+
+#if !READ_ONLY
+		internal IReflectionImporter reflection_importer;
+		internal IMetadataImporter metadata_importer;
+#endif
+		Collection<CustomAttribute> custom_attributes;
+		Collection<AssemblyNameReference> references;
+		Collection<ModuleReference> modules;
+		Collection<Resource> resources;
+		Collection<ExportedType> exported_types;
+		TypeDefinitionCollection types;
+
+		internal Collection<CustomDebugInformation> custom_infos;
+
+#if !READ_ONLY
+		internal MetadataBuilder metadata_builder;
+#endif
+
+		public bool IsMain {
+			get { return kind != ModuleKind.NetModule; }
+		}
+
+		public ModuleKind Kind {
+			get { return kind; }
+			set { kind = value; }
+		}
+
+		public MetadataKind MetadataKind {
+			get { return metadata_kind; }
+			set { metadata_kind = value; }
+		}
+
+		internal WindowsRuntimeProjections Projections {
+			get {
+				if (projections == null)
+					Interlocked.CompareExchange (ref projections, new WindowsRuntimeProjections (this), null);
+
+				return projections;
+			}
+		}
+
+		public TargetRuntime Runtime {
+			get { return runtime; }
+			set {
+				runtime = value;
+				runtime_version = runtime.RuntimeVersionString ();
+			}
+		}
+
+		public string RuntimeVersion {
+			get { return runtime_version; }
+			set {
+				runtime_version = value;
+				runtime = runtime_version.ParseRuntime ();
+			}
+		}
+
+		public TargetArchitecture Architecture {
+			get { return architecture; }
+			set { architecture = value; }
+		}
+
+		public ModuleAttributes Attributes {
+			get { return attributes; }
+			set { attributes = value; }
+		}
+
+		public ModuleCharacteristics Characteristics {
+			get { return characteristics; }
+			set { characteristics = value; }
+		}
+
+		[Obsolete ("Use FileName")]
+		public string FullyQualifiedName {
+			get { return file_name; }
+		}
+
+		public string FileName {
+			get { return file_name; }
+		}
+
+		public Guid Mvid {
+			get { return mvid; }
+			set { mvid = value; }
+		}
+
+		internal bool HasImage {
+			get { return Image != null; }
+		}
+
+		public bool HasSymbols {
+			get { return symbol_reader != null; }
+		}
+
+		public ISymbolReader SymbolReader {
+			get { return symbol_reader; }
+		}
+
+		public override MetadataScopeType MetadataScopeType {
+			get { return MetadataScopeType.ModuleDefinition; }
+		}
+
+		public AssemblyDefinition Assembly {
+			get { return assembly; }
+		}
+
+#if !READ_ONLY
+		internal IReflectionImporter ReflectionImporter {
+			get {
+				if (reflection_importer == null)
+					Interlocked.CompareExchange (ref reflection_importer, new DefaultReflectionImporter (this), null);
+
+				return reflection_importer;
+			}
+		}
+
+		internal IMetadataImporter MetadataImporter {
+			get {
+				if (metadata_importer == null)
+					Interlocked.CompareExchange (ref metadata_importer, new DefaultMetadataImporter (this), null);
+
+				return metadata_importer;
+			}
+		}
+#endif
+
+		public IAssemblyResolver AssemblyResolver {
+			get {
+				if (assembly_resolver.value == null) {
+					lock (module_lock) {
+						assembly_resolver = Disposable.Owned (new DefaultAssemblyResolver () as IAssemblyResolver);
+					}
+				}
+
+				return assembly_resolver.value;
+			}
+		}
+
+		public IMetadataResolver MetadataResolver {
+			get {
+				if (metadata_resolver == null)
+					Interlocked.CompareExchange (ref metadata_resolver, new MetadataResolver (this.AssemblyResolver), null);
+
+				return metadata_resolver;
+			}
+		}
+
+		public TypeSystem TypeSystem {
+			get {
+				if (type_system == null)
+					Interlocked.CompareExchange (ref type_system, TypeSystem.CreateTypeSystem (this), null);
+
+				return type_system;
+			}
+		}
+
+		public bool HasAssemblyReferences {
+			get {
+				if (references != null)
+					return references.Count > 0;
+
+				return HasImage && Image.HasTable (Table.AssemblyRef);
+			}
+		}
+
+		public Collection<AssemblyNameReference> AssemblyReferences {
+			get {
+				if (references != null)
+					return references;
+
+				if (HasImage)
+					return Read (ref references, this, (_, reader) => reader.ReadAssemblyReferences ());
+
+				return references = new Collection<AssemblyNameReference> ();
+			}
+		}
+
+		public bool HasModuleReferences {
+			get {
+				if (modules != null)
+					return modules.Count > 0;
+
+				return HasImage && Image.HasTable (Table.ModuleRef);
+			}
+		}
+
+		public Collection<ModuleReference> ModuleReferences {
+			get {
+				if (modules != null)
+					return modules;
+
+				if (HasImage)
+					return Read (ref modules, this, (_, reader) => reader.ReadModuleReferences ());
+
+				return modules = new Collection<ModuleReference> ();
+			}
+		}
+
+		public bool HasResources {
+			get {
+				if (resources != null)
+					return resources.Count > 0;
+
+				if (HasImage)
+					return Image.HasTable (Table.ManifestResource) || Read (this, (_, reader) => reader.HasFileResource ());
+
+				return false;
+			}
+		}
+
+		public Collection<Resource> Resources {
+			get {
+				if (resources != null)
+					return resources;
+
+				if (HasImage)
+					return Read (ref resources, this, (_, reader) => reader.ReadResources ());
+
+				return resources = new Collection<Resource> ();
+			}
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (this);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, this)); }
+		}
+
+		public bool HasTypes {
+			get {
+				if (types != null)
+					return types.Count > 0;
+
+				return HasImage && Image.HasTable (Table.TypeDef);
+			}
+		}
+
+		public Collection<TypeDefinition> Types {
+			get {
+				if (types != null)
+					return types;
+
+				if (HasImage)
+					return Read (ref types, this, (_, reader) => reader.ReadTypes ());
+
+				return types = new TypeDefinitionCollection (this);
+			}
+		}
+
+		public bool HasExportedTypes {
+			get {
+				if (exported_types != null)
+					return exported_types.Count > 0;
+
+				return HasImage && Image.HasTable (Table.ExportedType);
+			}
+		}
+
+		public Collection<ExportedType> ExportedTypes {
+			get {
+				if (exported_types != null)
+					return exported_types;
+
+				if (HasImage)
+					return Read (ref exported_types, this, (_, reader) => reader.ReadExportedTypes ());
+
+				return exported_types = new Collection<ExportedType> ();
+			}
+		}
+
+		public MethodDefinition EntryPoint {
+			get {
+				if (entry_point != null)
+					return entry_point;
+
+				if (HasImage)
+					return Read (ref entry_point, this, (_, reader) => reader.ReadEntryPoint ());
+
+				return entry_point = null;
+			}
+			set { entry_point = value; }
+		}
+
+		public bool HasCustomDebugInformations {
+			get {
+				return custom_infos != null && custom_infos.Count > 0;
+			}
+		}
+
+		public Collection<CustomDebugInformation> CustomDebugInformations {
+			get {
+				return custom_infos ?? (custom_infos = new Collection<CustomDebugInformation> ());
+			}
+		}
+
+		internal ModuleDefinition ()
+		{
+			this.MetadataSystem = new MetadataSystem ();
+			this.token = new MetadataToken (TokenType.Module, 1);
+		}
+
+		internal ModuleDefinition (Image image)
+			: this ()
+		{
+			this.Image = image;
+			this.kind = image.Kind;
+			this.RuntimeVersion = image.RuntimeVersion;
+			this.architecture = image.Architecture;
+			this.attributes = image.Attributes;
+			this.characteristics = image.Characteristics;
+			this.linker_version = image.LinkerVersion;
+			this.subsystem_major = image.SubSystemMajor;
+			this.subsystem_minor = image.SubSystemMinor;
+			this.file_name = image.FileName;
+			this.timestamp = image.Timestamp;
+
+			this.reader = new MetadataReader (this);
+		}
+
+		public void Dispose ()
+		{
+			if (Image != null)
+				Image.Dispose ();
+
+			if (symbol_reader != null)
+				symbol_reader.Dispose ();
+
+			if (assembly_resolver.value != null)
+				assembly_resolver.Dispose ();
+		}
+
+		public bool HasTypeReference (string fullName)
+		{
+			return HasTypeReference (string.Empty, fullName);
+		}
+
+		public bool HasTypeReference (string scope, string fullName)
+		{
+			Mixin.CheckFullName (fullName);
+
+			if (!HasImage)
+				return false;
+
+			return GetTypeReference (scope, fullName) != null;
+		}
+
+		public bool TryGetTypeReference (string fullName, out TypeReference type)
+		{
+			return TryGetTypeReference (string.Empty, fullName, out type);
+		}
+
+		public bool TryGetTypeReference (string scope, string fullName, out TypeReference type)
+		{
+			Mixin.CheckFullName (fullName);
+
+			if (!HasImage) {
+				type = null;
+				return false;
+			}
+
+			return (type = GetTypeReference (scope, fullName)) != null;
+		}
+
+		TypeReference GetTypeReference (string scope, string fullname)
+		{
+			return Read (new Row<string, string> (scope, fullname), (row, reader) => reader.GetTypeReference (row.Col1, row.Col2));
+		}
+
+		public IEnumerable<TypeReference> GetTypeReferences ()
+		{
+			if (!HasImage)
+				return Empty<TypeReference>.Array;
+
+			return Read (this, (_, reader) => reader.GetTypeReferences ());
+		}
+
+		public IEnumerable<MemberReference> GetMemberReferences ()
+		{
+			if (!HasImage)
+				return Empty<MemberReference>.Array;
+
+			return Read (this, (_, reader) => reader.GetMemberReferences ());
+		}
+
+		public IEnumerable<CustomAttribute> GetCustomAttributes ()
+		{
+			if (!HasImage)
+				return Empty<CustomAttribute>.Array;
+
+			return Read (this, (_, reader) => reader.GetCustomAttributes ());
+		}
+
+		public TypeReference GetType (string fullName, bool runtimeName)
+		{
+			return runtimeName
+				? TypeParser.ParseType (this, fullName, typeDefinitionOnly: true)
+				: GetType (fullName);
+		}
+
+		public TypeDefinition GetType (string fullName)
+		{
+			Mixin.CheckFullName (fullName);
+
+			var position = fullName.IndexOf ('/');
+			if (position > 0)
+				return GetNestedType (fullName);
+
+			return ((TypeDefinitionCollection) this.Types).GetType (fullName);
+		}
+
+		public TypeDefinition GetType (string @namespace, string name)
+		{
+			Mixin.CheckName (name);
+
+			return ((TypeDefinitionCollection) this.Types).GetType (@namespace ?? string.Empty, name);
+		}
+
+		public IEnumerable<TypeDefinition> GetTypes ()
+		{
+			return GetTypes (Types);
+		}
+
+		static IEnumerable<TypeDefinition> GetTypes (Collection<TypeDefinition> types)
+		{
+			for (int i = 0; i < types.Count; i++) {
+				var type = types [i];
+
+				yield return type;
+
+				if (!type.HasNestedTypes)
+					continue;
+
+				foreach (var nested in GetTypes (type.NestedTypes))
+					yield return nested;
+			}
+		}
+
+		TypeDefinition GetNestedType (string fullname)
+		{
+			var names = fullname.Split ('/');
+			var type = GetType (names [0]);
+
+			if (type == null)
+				return null;
+
+			for (int i = 1; i < names.Length; i++) {
+				var nested_type = type.GetNestedType (names [i]);
+				if (nested_type == null)
+					return null;
+
+				type = nested_type;
+			}
+
+			return type;
+		}
+
+		internal FieldDefinition Resolve (FieldReference field)
+		{
+			return MetadataResolver.Resolve (field);
+		}
+
+		internal MethodDefinition Resolve (MethodReference method)
+		{
+			return MetadataResolver.Resolve (method);
+		}
+
+		internal TypeDefinition Resolve (TypeReference type)
+		{
+			return MetadataResolver.Resolve (type);
+		}
+
+#if !READ_ONLY
+
+		static void CheckContext (IGenericParameterProvider context, ModuleDefinition module)
+		{
+			if (context == null)
+				return;
+
+			if (context.Module != module)
+				throw new ArgumentException ();
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public TypeReference Import (Type type)
+		{
+			return ImportReference (type, null);
+		}
+
+		public TypeReference ImportReference (Type type)
+		{
+			return ImportReference (type, null);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public TypeReference Import (Type type, IGenericParameterProvider context)
+		{
+			return ImportReference (type, context);
+		}
+
+		public TypeReference ImportReference (Type type, IGenericParameterProvider context)
+		{
+			Mixin.CheckType (type);
+			CheckContext (context, this);
+
+			return ReflectionImporter.ImportReference (type, context);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public FieldReference Import (SR.FieldInfo field)
+		{
+			return ImportReference (field, null);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public FieldReference Import (SR.FieldInfo field, IGenericParameterProvider context)
+		{
+			return ImportReference (field, context);
+		}
+
+		public FieldReference ImportReference (SR.FieldInfo field)
+		{
+			return ImportReference (field, null);
+		}
+
+		public FieldReference ImportReference (SR.FieldInfo field, IGenericParameterProvider context)
+		{
+			Mixin.CheckField (field);
+			CheckContext (context, this);
+
+			return ReflectionImporter.ImportReference (field, context);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public MethodReference Import (SR.MethodBase method)
+		{
+			return ImportReference (method, null);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public MethodReference Import (SR.MethodBase method, IGenericParameterProvider context)
+		{
+			return ImportReference (method, context);
+		}
+
+		public MethodReference ImportReference (SR.MethodBase method)
+		{
+			return ImportReference (method, null);
+		}
+
+		public MethodReference ImportReference (SR.MethodBase method, IGenericParameterProvider context)
+		{
+			Mixin.CheckMethod (method);
+			CheckContext (context, this);
+
+			return ReflectionImporter.ImportReference (method, context);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public TypeReference Import (TypeReference type)
+		{
+			return ImportReference (type, null);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public TypeReference Import (TypeReference type, IGenericParameterProvider context)
+		{
+			return ImportReference (type, context);
+		}
+
+		public TypeReference ImportReference (TypeReference type)
+		{
+			return ImportReference (type, null);
+		}
+
+		public TypeReference ImportReference (TypeReference type, IGenericParameterProvider context)
+		{
+			Mixin.CheckType (type);
+
+			if (type.Module == this)
+				return type;
+
+			CheckContext (context, this);
+
+			return MetadataImporter.ImportReference (type, context);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public FieldReference Import (FieldReference field)
+		{
+			return ImportReference (field, null);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public FieldReference Import (FieldReference field, IGenericParameterProvider context)
+		{
+			return ImportReference (field, context);
+		}
+
+		public FieldReference ImportReference (FieldReference field)
+		{
+			return ImportReference (field, null);
+		}
+
+		public FieldReference ImportReference (FieldReference field, IGenericParameterProvider context)
+		{
+			Mixin.CheckField (field);
+
+			if (field.Module == this)
+				return field;
+
+			CheckContext (context, this);
+
+			return MetadataImporter.ImportReference (field, context);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public MethodReference Import (MethodReference method)
+		{
+			return ImportReference (method, null);
+		}
+
+		[Obsolete ("Use ImportReference", error: false)]
+		public MethodReference Import (MethodReference method, IGenericParameterProvider context)
+		{
+			return ImportReference (method, context);
+		}
+
+		public MethodReference ImportReference (MethodReference method)
+		{
+			return ImportReference (method, null);
+		}
+
+		public MethodReference ImportReference (MethodReference method, IGenericParameterProvider context)
+		{
+			Mixin.CheckMethod (method);
+
+			if (method.Module == this)
+				return method;
+
+			CheckContext (context, this);
+
+			return MetadataImporter.ImportReference (method, context);
+		}
+
+#endif
+
+		public IMetadataTokenProvider LookupToken (int token)
+		{
+			return LookupToken (new MetadataToken ((uint) token));
+		}
+
+		public IMetadataTokenProvider LookupToken (MetadataToken token)
+		{
+			return Read (token, (t, reader) => reader.LookupToken (t));
+		}
+
+		readonly object module_lock = new object();
+
+		internal object SyncRoot {
+			get { return module_lock; }
+		}
+
+		internal void Read<TItem> (TItem item, Action<TItem, MetadataReader> read)
+		{
+			lock (module_lock) {
+				var position = reader.position;
+				var context = reader.context;
+
+				read (item, reader);
+
+				reader.position = position;
+				reader.context = context;
+			}
+		}
+
+		internal TRet Read<TItem, TRet> (TItem item, Func<TItem, MetadataReader, TRet> read)
+		{
+			lock (module_lock) {
+				var position = reader.position;
+				var context = reader.context;
+
+				var ret = read (item, reader);
+
+				reader.position = position;
+				reader.context = context;
+
+				return ret;
+			}
+		}
+
+		internal TRet Read<TItem, TRet> (ref TRet variable, TItem item, Func<TItem, MetadataReader, TRet> read) where TRet : class
+		{
+			lock (module_lock) {
+				if (variable != null)
+					return variable;
+
+				var position = reader.position;
+				var context = reader.context;
+
+				var ret = read (item, reader);
+
+				reader.position = position;
+				reader.context = context;
+
+				return variable = ret;
+			}
+		}
+
+		public bool HasDebugHeader {
+			get { return Image != null && Image.DebugHeader != null; }
+		}
+
+		public ImageDebugHeader GetDebugHeader ()
+		{
+			return Image.DebugHeader ?? new ImageDebugHeader ();
+		}
+
+#if !READ_ONLY
+
+		public static ModuleDefinition CreateModule (string name, ModuleKind kind)
+		{
+			return CreateModule (name, new ModuleParameters { Kind = kind });
+		}
+
+		public static ModuleDefinition CreateModule (string name, ModuleParameters parameters)
+		{
+			Mixin.CheckName (name);
+			Mixin.CheckParameters (parameters);
+
+			var module = new ModuleDefinition {
+				Name = name,
+				kind = parameters.Kind,
+				timestamp = parameters.Timestamp ?? Mixin.GetTimestamp (),
+				Runtime = parameters.Runtime,
+				architecture = parameters.Architecture,
+				mvid = Guid.NewGuid (),
+				Attributes = ModuleAttributes.ILOnly,
+				Characteristics = (ModuleCharacteristics) 0x8540,
+			};
+
+			if (parameters.AssemblyResolver != null)
+				module.assembly_resolver = Disposable.NotOwned (parameters.AssemblyResolver);
+
+			if (parameters.MetadataResolver != null)
+				module.metadata_resolver = parameters.MetadataResolver;
+
+#if !READ_ONLY
+			if (parameters.MetadataImporterProvider != null)
+				module.metadata_importer = parameters.MetadataImporterProvider.GetMetadataImporter (module);
+			if (parameters.ReflectionImporterProvider != null)
+				module.reflection_importer = parameters.ReflectionImporterProvider.GetReflectionImporter (module);
+#endif
+
+			if (parameters.Kind != ModuleKind.NetModule) {
+				var assembly = new AssemblyDefinition ();
+				module.assembly = assembly;
+				module.assembly.Name = CreateAssemblyName (name);
+				assembly.main_module = module;
+			}
+
+			module.Types.Add (new TypeDefinition (string.Empty, "<Module>", TypeAttributes.NotPublic));
+
+			return module;
+		}
+
+		static AssemblyNameDefinition CreateAssemblyName (string name)
+		{
+			if (name.EndsWith (".dll") || name.EndsWith (".exe"))
+				name = name.Substring (0, name.Length - 4);
+
+			return new AssemblyNameDefinition (name, Mixin.ZeroVersion);
+		}
+
+#endif
+
+		public void ReadSymbols ()
+		{
+			if (string.IsNullOrEmpty (file_name))
+				throw new InvalidOperationException ();
+
+			var provider = new DefaultSymbolReaderProvider (throwIfNoSymbol: true);
+			ReadSymbols (provider.GetSymbolReader (this, file_name), throwIfSymbolsAreNotMaching: true);
+		}
+
+		public void ReadSymbols (ISymbolReader reader)
+		{
+			ReadSymbols(reader, throwIfSymbolsAreNotMaching: true);
+		}
+
+		public void ReadSymbols (ISymbolReader reader, bool throwIfSymbolsAreNotMaching)
+		{
+			if (reader == null)
+				throw new ArgumentNullException ("reader");
+
+			symbol_reader = reader;
+
+			if (!symbol_reader.ProcessDebugHeader (GetDebugHeader ())) {
+				symbol_reader = null;
+
+				if (throwIfSymbolsAreNotMaching)
+					throw new SymbolsNotMatchingException ("Symbols were found but are not matching the assembly");
+
+				return;
+			}
+
+			if (HasImage && ReadingMode == ReadingMode.Immediate) {
+				var immediate_reader = new ImmediateModuleReader (Image);
+				immediate_reader.ReadSymbols (this);
+			}
+		}
+
+		public static ModuleDefinition ReadModule (string fileName)
+		{
+			return ReadModule (fileName, new ReaderParameters (ReadingMode.Deferred));
+		}
+
+		public static ModuleDefinition ReadModule (string fileName, ReaderParameters parameters)
+		{
+			var stream = GetFileStream (fileName, FileMode.Open, parameters.ReadWrite ? FileAccess.ReadWrite : FileAccess.Read, FileShare.Read);
+
+			if (parameters.InMemory) {
+				var memory = new MemoryStream (stream.CanSeek ? (int) stream.Length : 0);
+				using (stream)
+					stream.CopyTo (memory);
+
+				memory.Position = 0;
+				stream = memory;
+			}
+
+			try {
+				return ReadModule (Disposable.Owned (stream), fileName, parameters);
+			} catch (Exception) {
+				stream.Dispose ();
+				throw;
+			}
+		}
+
+		static Stream GetFileStream (string fileName, FileMode mode, FileAccess access, FileShare share)
+		{
+			Mixin.CheckFileName (fileName);
+
+			return new FileStream (fileName, mode, access, share);
+		}
+
+		public static ModuleDefinition ReadModule (Stream stream)
+		{
+			return ReadModule (stream, new ReaderParameters (ReadingMode.Deferred));
+		}
+
+		public static ModuleDefinition ReadModule (Stream stream, ReaderParameters parameters)
+		{
+			Mixin.CheckStream (stream);
+			Mixin.CheckReadSeek (stream);
+
+			return ReadModule (Disposable.NotOwned (stream), stream.GetFileName (), parameters);
+		}
+
+		static ModuleDefinition ReadModule (Disposable<Stream> stream, string fileName, ReaderParameters parameters)
+		{
+			Mixin.CheckParameters (parameters);
+
+			return ModuleReader.CreateModule (
+				ImageReader.ReadImage (stream, fileName),
+				parameters);
+		}
+
+#if !READ_ONLY
+
+		public void Write (string fileName)
+		{
+			Write (fileName, new WriterParameters ());
+		}
+
+		public void Write (string fileName, WriterParameters parameters)
+		{
+			Mixin.CheckParameters (parameters);
+			var file = GetFileStream (fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
+			ModuleWriter.WriteModule (this, Disposable.Owned (file), parameters);
+		}
+
+		public void Write ()
+		{
+			Write (new WriterParameters ());
+		}
+
+		public void Write (WriterParameters parameters)
+		{
+			if (!HasImage)
+				throw new InvalidOperationException ();
+
+			Write (Image.Stream.value, parameters);
+		}
+
+		public void Write (Stream stream)
+		{
+			Write (stream, new WriterParameters ());
+		}
+
+		public void Write (Stream stream, WriterParameters parameters)
+		{
+			Mixin.CheckStream (stream);
+			Mixin.CheckWriteSeek (stream);
+			Mixin.CheckParameters (parameters);
+
+			ModuleWriter.WriteModule (this, Disposable.NotOwned (stream), parameters);
+		}
+
+#endif
+
+	}
+
+	static partial class Mixin {
+
+		public enum Argument {
+			name,
+			fileName,
+			fullName,
+			stream,
+			type,
+			method,
+			field,
+			parameters,
+			module,
+			modifierType,
+			eventType,
+			fieldType,
+			declaringType,
+			returnType,
+			propertyType,
+			interfaceType,
+		}
+
+		public static void CheckName (object name)
+		{
+			if (name == null)
+				throw new ArgumentNullException (Argument.name.ToString ());
+		}
+
+		public static void CheckName (string name)
+		{
+			if (string.IsNullOrEmpty (name))
+				throw new ArgumentNullOrEmptyException (Argument.name.ToString ());
+		}
+
+		public static void CheckFileName (string fileName)
+		{
+			if (string.IsNullOrEmpty (fileName))
+				throw new ArgumentNullOrEmptyException (Argument.fileName.ToString ());
+		}
+
+		public static void CheckFullName (string fullName)
+		{
+			if (string.IsNullOrEmpty (fullName))
+				throw new ArgumentNullOrEmptyException (Argument.fullName.ToString ());
+		}
+
+		public static void CheckStream (object stream)
+		{
+			if (stream == null)
+				throw new ArgumentNullException (Argument.stream.ToString ());
+		}
+
+		public static void CheckWriteSeek (Stream stream)
+		{
+			if (!stream.CanWrite || !stream.CanSeek)
+				throw new ArgumentException ("Stream must be writable and seekable.");
+		}
+
+		public static void CheckReadSeek (Stream stream)
+		{
+			if (!stream.CanRead || !stream.CanSeek)
+				throw new ArgumentException ("Stream must be readable and seekable.");
+		}
+
+		public static void CheckType (object type)
+		{
+			if (type == null)
+				throw new ArgumentNullException (Argument.type.ToString ());
+		}
+
+		public static void CheckType (object type, Argument argument)
+		{
+			if (type == null)
+				throw new ArgumentNullException (argument.ToString ());
+		}
+
+		public static void CheckField (object field)
+		{
+			if (field == null)
+				throw new ArgumentNullException (Argument.field.ToString ());
+		}
+
+		public static void CheckMethod (object method)
+		{
+			if (method == null)
+				throw new ArgumentNullException (Argument.method.ToString ());
+		}
+
+		public static void CheckParameters (object parameters)
+		{
+			if (parameters == null)
+				throw new ArgumentNullException (Argument.parameters.ToString ());
+		}
+
+		public static uint GetTimestamp ()
+		{
+			return (uint) DateTime.UtcNow.Subtract (new DateTime (1970, 1, 1)).TotalSeconds;
+		}
+
+		public static bool HasImage (this ModuleDefinition self)
+		{
+			return self != null && self.HasImage;
+		}
+
+		public static string GetFileName (this Stream self)
+		{
+			var file_stream = self as FileStream;
+			if (file_stream == null)
+				return string.Empty;
+
+			return Path.GetFullPath (file_stream.Name);
+		}
+
+#if !NET_4_0
+		public static void CopyTo (this Stream self, Stream target)
+		{
+			var buffer = new byte [1024 * 8];
+			int read;
+			while ((read = self.Read (buffer, 0, buffer.Length)) > 0)
+				target.Write (buffer, 0, read);
+		}
+#endif
+
+		public static TargetRuntime ParseRuntime (this string self)
+		{
+			if (string.IsNullOrEmpty (self))
+				return TargetRuntime.Net_4_0;
+
+			switch (self [1]) {
+			case '1':
+				return self [3] == '0'
+					? TargetRuntime.Net_1_0
+					: TargetRuntime.Net_1_1;
+			case '2':
+				return TargetRuntime.Net_2_0;
+			case '4':
+			default:
+				return TargetRuntime.Net_4_0;
+			}
+		}
+
+		public static string RuntimeVersionString (this TargetRuntime runtime)
+		{
+			switch (runtime) {
+			case TargetRuntime.Net_1_0:
+				return "v1.0.3705";
+			case TargetRuntime.Net_1_1:
+				return "v1.1.4322";
+			case TargetRuntime.Net_2_0:
+				return "v2.0.50727";
+			case TargetRuntime.Net_4_0:
+			default:
+				return "v4.0.30319";
+			}
+		}
+
+		public static bool IsWindowsMetadata (this ModuleDefinition module)
+		{
+			return module.MetadataKind != MetadataKind.Ecma335;
+		}
+
+		public static byte [] ReadAll (this Stream self)
+		{
+			int read;
+			var memory = new MemoryStream ((int) self.Length);
+			var buffer = new byte [1024];
+
+			while ((read = self.Read (buffer, 0, buffer.Length)) != 0)
+				memory.Write (buffer, 0, read);
+
+			return memory.ToArray ();
+		}
+
+		public static void Read (object o)
+		{
+		}
+	}
+}
diff --git a/src/Mono/Cecil/ModuleKind.cs b/src/Mono/Cecil/ModuleKind.cs
new file mode 100644
index 00000000..2cd084db
--- /dev/null
+++ b/src/Mono/Cecil/ModuleKind.cs
@@ -0,0 +1,55 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public enum ModuleKind {
+		Dll,
+		Console,
+		Windows,
+		NetModule,
+	}
+
+	public enum MetadataKind {
+		Ecma335,
+		WindowsMetadata,
+		ManagedWindowsMetadata,
+	}
+
+	public enum TargetArchitecture {
+		I386 = 0x014c,
+		AMD64 = 0x8664,
+		IA64 = 0x0200,
+		ARM = 0x01c0,
+		ARMv7 = 0x01c4,
+		ARM64 = 0xaa64,
+	}
+
+	[Flags]
+	public enum ModuleAttributes {
+		ILOnly = 1,
+		Required32Bit = 2,
+		ILLibrary = 4,
+		StrongNameSigned = 8,
+		Preferred32Bit = 0x00020000,
+	}
+
+	[Flags]
+	public enum ModuleCharacteristics {
+		HighEntropyVA = 0x0020,
+		DynamicBase = 0x0040,
+		NoSEH = 0x0400,
+		NXCompat = 0x0100,
+		AppContainer = 0x1000,
+		TerminalServerAware = 0x8000,
+	}
+}
diff --git a/src/Mono/Cecil/ModuleReference.cs b/src/Mono/Cecil/ModuleReference.cs
new file mode 100644
index 00000000..43c618f4
--- /dev/null
+++ b/src/Mono/Cecil/ModuleReference.cs
@@ -0,0 +1,49 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public class ModuleReference : IMetadataScope {
+
+		string name;
+
+		internal MetadataToken token;
+
+		public string Name {
+			get { return name; }
+			set { name = value; }
+		}
+
+		public virtual MetadataScopeType MetadataScopeType {
+			get { return MetadataScopeType.ModuleReference; }
+		}
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		internal ModuleReference ()
+		{
+			this.token = new MetadataToken (TokenType.ModuleRef);
+		}
+
+		public ModuleReference (string name)
+			: this ()
+		{
+			this.name = name;
+		}
+
+		public override string ToString ()
+		{
+			return name;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/NativeType.cs b/src/Mono/Cecil/NativeType.cs
new file mode 100644
index 00000000..02174db6
--- /dev/null
+++ b/src/Mono/Cecil/NativeType.cs
@@ -0,0 +1,55 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum NativeType {
+		None = 0x66,
+
+		Boolean = 0x02,
+		I1 = 0x03,
+		U1 = 0x04,
+		I2 = 0x05,
+		U2 = 0x06,
+		I4 = 0x07,
+		U4 = 0x08,
+		I8 = 0x09,
+		U8 = 0x0a,
+		R4 = 0x0b,
+		R8 = 0x0c,
+		LPStr = 0x14,
+		Int = 0x1f,
+		UInt = 0x20,
+		Func = 0x26,
+		Array = 0x2a,
+
+		// Msft specific
+		Currency = 0x0f,
+		BStr = 0x13,
+		LPWStr = 0x15,
+		LPTStr = 0x16,
+		FixedSysString = 0x17,
+		IUnknown = 0x19,
+		IDispatch = 0x1a,
+		Struct = 0x1b,
+		IntF = 0x1c,
+		SafeArray = 0x1d,
+		FixedArray = 0x1e,
+		ByValStr = 0x22,
+		ANSIBStr = 0x23,
+		TBStr = 0x24,
+		VariantBool = 0x25,
+		ASAny = 0x28,
+		LPStruct = 0x2b,
+		CustomMarshaler = 0x2c,
+		Error = 0x2d,
+		Max = 0x50
+	}
+}
diff --git a/src/Mono/Cecil/PE/BinaryStreamReader.cs b/src/Mono/Cecil/PE/BinaryStreamReader.cs
new file mode 100644
index 00000000..812adbc5
--- /dev/null
+++ b/src/Mono/Cecil/PE/BinaryStreamReader.cs
@@ -0,0 +1,54 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.IO;
+
+namespace Mono.Cecil.PE {
+
+	class BinaryStreamReader : BinaryReader {
+
+		public int Position {
+			get { return (int) BaseStream.Position; }
+			set { BaseStream.Position = value; }
+		}
+
+		public int Length {
+			get { return (int) BaseStream.Length; }
+		}
+
+		public BinaryStreamReader (Stream stream)
+			: base (stream)
+		{
+		}
+
+		public void Advance (int bytes)
+		{
+			BaseStream.Seek (bytes, SeekOrigin.Current);
+		}
+
+		public void MoveTo (uint position)
+		{
+			BaseStream.Seek (position, SeekOrigin.Begin);
+		}
+
+		public void Align (int align)
+		{
+			align--;
+			var position = Position;
+			Advance (((position + align) & ~align) - position);
+		}
+
+		public DataDirectory ReadDataDirectory ()
+		{
+			return new DataDirectory (ReadUInt32 (), ReadUInt32 ());
+		}
+	}
+}
diff --git a/src/Mono/Cecil/PE/BinaryStreamWriter.cs b/src/Mono/Cecil/PE/BinaryStreamWriter.cs
new file mode 100644
index 00000000..b741f684
--- /dev/null
+++ b/src/Mono/Cecil/PE/BinaryStreamWriter.cs
@@ -0,0 +1,93 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.IO;
+
+#if !READ_ONLY
+
+namespace Mono.Cecil.PE {
+
+	class BinaryStreamWriter : BinaryWriter {
+
+		public int Position {
+			get { return (int) BaseStream.Position; }
+			set { BaseStream.Position = value; }
+		}
+
+		public BinaryStreamWriter (Stream stream)
+			: base (stream)
+		{
+		}
+
+		public void WriteByte (byte value)
+		{
+			Write (value);
+		}
+
+		public void WriteUInt16 (ushort value)
+		{
+			Write (value);
+		}
+
+		public void WriteInt16 (short value)
+		{
+			Write (value);
+		}
+
+		public void WriteUInt32 (uint value)
+		{
+			Write (value);
+		}
+
+		public void WriteInt32 (int value)
+		{
+			Write (value);
+		}
+
+		public void WriteUInt64 (ulong value)
+		{
+			Write (value);
+		}
+
+		public void WriteBytes (byte [] bytes)
+		{
+			Write (bytes);
+		}
+
+		public void WriteDataDirectory (DataDirectory directory)
+		{
+			Write (directory.VirtualAddress);
+			Write (directory.Size);
+		}
+
+		public void WriteBuffer (ByteBuffer buffer)
+		{
+			Write (buffer.buffer, 0, buffer.length);
+		}
+
+		protected void Advance (int bytes)
+		{
+			BaseStream.Seek (bytes, SeekOrigin.Current);
+		}
+
+		public void Align (int align)
+		{
+			align--;
+			var position = Position;
+			var bytes = ((position + align) & ~align) - position;
+
+			for (int i = 0; i < bytes; i++)
+				WriteByte (0);
+		}
+	}
+}
+
+#endif
diff --git a/src/Mono/Cecil/PE/ByteBuffer.cs b/src/Mono/Cecil/PE/ByteBuffer.cs
new file mode 100644
index 00000000..8aee04ba
--- /dev/null
+++ b/src/Mono/Cecil/PE/ByteBuffer.cs
@@ -0,0 +1,341 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil.PE {
+
+	class ByteBuffer {
+
+		internal byte [] buffer;
+		internal int length;
+		internal int position;
+
+		public ByteBuffer ()
+		{
+			this.buffer = Empty<byte>.Array;
+		}
+
+		public ByteBuffer (int length)
+		{
+			this.buffer = new byte [length];
+		}
+
+		public ByteBuffer (byte [] buffer)
+		{
+			this.buffer = buffer ?? Empty<byte>.Array;
+			this.length = this.buffer.Length;
+		}
+
+		public void Advance (int length)
+		{
+			position += length;
+		}
+
+		public byte ReadByte ()
+		{
+			return buffer [position++];
+		}
+
+		public sbyte ReadSByte ()
+		{
+			return (sbyte) ReadByte ();
+		}
+
+		public byte [] ReadBytes (int length)
+		{
+			var bytes = new byte [length];
+			Buffer.BlockCopy (buffer, position, bytes, 0, length);
+			position += length;
+			return bytes;
+		}
+
+		public ushort ReadUInt16 ()
+		{
+			ushort value = (ushort) (buffer [position]
+				| (buffer [position + 1] << 8));
+			position += 2;
+			return value;
+		}
+
+		public short ReadInt16 ()
+		{
+			return (short) ReadUInt16 ();
+		}
+
+		public uint ReadUInt32 ()
+		{
+			uint value = (uint) (buffer [position]
+				| (buffer [position + 1] << 8)
+				| (buffer [position + 2] << 16)
+				| (buffer [position + 3] << 24));
+			position += 4;
+			return value;
+		}
+
+		public int ReadInt32 ()
+		{
+			return (int) ReadUInt32 ();
+		}
+
+		public ulong ReadUInt64 ()
+		{
+			uint low = ReadUInt32 ();
+			uint high = ReadUInt32 ();
+
+			return (((ulong) high) << 32) | low;
+		}
+
+		public long ReadInt64 ()
+		{
+			return (long) ReadUInt64 ();
+		}
+
+		public uint ReadCompressedUInt32 ()
+		{
+			byte first = ReadByte ();
+			if ((first & 0x80) == 0)
+				return first;
+
+			if ((first & 0x40) == 0)
+				return ((uint) (first & ~0x80) << 8)
+					| ReadByte ();
+
+			return ((uint) (first & ~0xc0) << 24)
+				| (uint) ReadByte () << 16
+				| (uint) ReadByte () << 8
+				| ReadByte ();
+		}
+
+		public int ReadCompressedInt32 ()
+		{
+			var b = buffer [position];
+			var u = (int) ReadCompressedUInt32 ();
+			var v = u >> 1;
+			if ((u & 1) == 0)
+				return v;
+
+			switch (b & 0xc0)
+			{
+				case 0:
+				case 0x40:
+					return v - 0x40;
+				case 0x80:
+					return v - 0x2000;
+				default:
+					return v - 0x10000000;
+			}
+		}
+
+		public float ReadSingle ()
+		{
+			if (!BitConverter.IsLittleEndian) {
+				var bytes = ReadBytes (4);
+				Array.Reverse (bytes);
+				return BitConverter.ToSingle (bytes, 0);
+			}
+
+			float value = BitConverter.ToSingle (buffer, position);
+			position += 4;
+			return value;
+		}
+
+		public double ReadDouble ()
+		{
+			if (!BitConverter.IsLittleEndian) {
+				var bytes = ReadBytes (8);
+				Array.Reverse (bytes);
+				return BitConverter.ToDouble (bytes, 0);
+			}
+
+			double value = BitConverter.ToDouble (buffer, position);
+			position += 8;
+			return value;
+		}
+
+#if !READ_ONLY
+
+		public void WriteByte (byte value)
+		{
+			if (position == buffer.Length)
+				Grow (1);
+
+			buffer [position++] = value;
+
+			if (position > length)
+				length = position;
+		}
+
+		public void WriteSByte (sbyte value)
+		{
+			WriteByte ((byte) value);
+		}
+
+		public void WriteUInt16 (ushort value)
+		{
+			if (position + 2 > buffer.Length)
+				Grow (2);
+
+			buffer [position++] = (byte) value;
+			buffer [position++] = (byte) (value >> 8);
+
+			if (position > length)
+				length = position;
+		}
+
+		public void WriteInt16 (short value)
+		{
+			WriteUInt16 ((ushort) value);
+		}
+
+		public void WriteUInt32 (uint value)
+		{
+			if (position + 4 > buffer.Length)
+				Grow (4);
+
+			buffer [position++] = (byte) value;
+			buffer [position++] = (byte) (value >> 8);
+			buffer [position++] = (byte) (value >> 16);
+			buffer [position++] = (byte) (value >> 24);
+
+			if (position > length)
+				length = position;
+		}
+
+		public void WriteInt32 (int value)
+		{
+			WriteUInt32 ((uint) value);
+		}
+
+		public void WriteUInt64 (ulong value)
+		{
+			if (position + 8 > buffer.Length)
+				Grow (8);
+
+			buffer [position++] = (byte) value;
+			buffer [position++] = (byte) (value >> 8);
+			buffer [position++] = (byte) (value >> 16);
+			buffer [position++] = (byte) (value >> 24);
+			buffer [position++] = (byte) (value >> 32);
+			buffer [position++] = (byte) (value >> 40);
+			buffer [position++] = (byte) (value >> 48);
+			buffer [position++] = (byte) (value >> 56);
+
+			if (position > length)
+				length = position;
+		}
+
+		public void WriteInt64 (long value)
+		{
+			WriteUInt64 ((ulong) value);
+		}
+
+		public void WriteCompressedUInt32 (uint value)
+		{
+			if (value < 0x80)
+				WriteByte ((byte) value);
+			else if (value < 0x4000) {
+				WriteByte ((byte) (0x80 | (value >> 8)));
+				WriteByte ((byte) (value & 0xff));
+			} else {
+				WriteByte ((byte) ((value >> 24) | 0xc0));
+				WriteByte ((byte) ((value >> 16) & 0xff));
+				WriteByte ((byte) ((value >> 8) & 0xff));
+				WriteByte ((byte) (value & 0xff));
+			}
+		}
+
+		public void WriteCompressedInt32 (int value)
+		{
+			if (value >= 0) {
+				WriteCompressedUInt32 ((uint) (value << 1));
+				return;
+			}
+
+			if (value > -0x40)
+				value = 0x40 + value;
+			else if (value >= -0x2000)
+				value = 0x2000 + value;
+			else if (value >= -0x20000000)
+				value = 0x20000000 + value;
+
+			WriteCompressedUInt32 ((uint) ((value << 1) | 1));
+		}
+
+		public void WriteBytes (byte [] bytes)
+		{
+			var length = bytes.Length;
+			if (position + length > buffer.Length)
+				Grow (length);
+
+			Buffer.BlockCopy (bytes, 0, buffer, position, length);
+			position += length;
+
+			if (position > this.length)
+				this.length = position;
+		}
+
+		public void WriteBytes (int length)
+		{
+			if (position + length > buffer.Length)
+				Grow (length);
+
+			position += length;
+
+			if (position > this.length)
+				this.length = position;
+		}
+
+		public void WriteBytes (ByteBuffer buffer)
+		{
+			if (position + buffer.length > this.buffer.Length)
+				Grow (buffer.length);
+
+			Buffer.BlockCopy (buffer.buffer, 0, this.buffer, position, buffer.length);
+			position += buffer.length;
+
+			if (position > this.length)
+				this.length = position;
+		}
+
+		public void WriteSingle (float value)
+		{
+			var bytes = BitConverter.GetBytes (value);
+
+			if (!BitConverter.IsLittleEndian)
+				Array.Reverse (bytes);
+
+			WriteBytes (bytes);
+		}
+
+		public void WriteDouble (double value)
+		{
+			var bytes = BitConverter.GetBytes (value);
+
+			if (!BitConverter.IsLittleEndian)
+				Array.Reverse (bytes);
+
+			WriteBytes (bytes);
+		}
+
+		void Grow (int desired)
+		{
+			var current = this.buffer;
+			var current_length = current.Length;
+
+			var buffer = new byte [System.Math.Max (current_length + desired, current_length * 2)];
+			Buffer.BlockCopy (current, 0, buffer, 0, current_length);
+			this.buffer = buffer;
+		}
+
+#endif
+
+	}
+}
diff --git a/src/Mono/Cecil/PE/ByteBufferEqualityComparer.cs b/src/Mono/Cecil/PE/ByteBufferEqualityComparer.cs
new file mode 100644
index 00000000..8b7cb238
--- /dev/null
+++ b/src/Mono/Cecil/PE/ByteBufferEqualityComparer.cs
@@ -0,0 +1,48 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+
+namespace Mono.Cecil.PE {
+
+	sealed class ByteBufferEqualityComparer : IEqualityComparer<ByteBuffer> {
+
+		public bool Equals (ByteBuffer x, ByteBuffer y)
+		{
+			if (x.length != y.length)
+				return false;
+
+			var x_buffer = x.buffer;
+			var y_buffer = y.buffer;
+
+			for (int i = 0; i < x.length; i++)
+				if (x_buffer [i] != y_buffer [i])
+					return false;
+
+			return true;
+		}
+
+		public int GetHashCode (ByteBuffer buffer)
+		{
+			// See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+			const int fnv_offset_bias = unchecked((int)2166136261);
+			const int fnv_prime = 16777619;
+
+			var hash_code = fnv_offset_bias;
+			var bytes = buffer.buffer;
+
+			for (int i = 0; i < buffer.length; i++)
+				hash_code = unchecked ((hash_code ^ bytes [i]) * fnv_prime);
+
+			return hash_code;
+ 		}
+	}
+}
diff --git a/src/Mono/Cecil/PE/DataDirectory.cs b/src/Mono/Cecil/PE/DataDirectory.cs
new file mode 100644
index 00000000..4922dd2f
--- /dev/null
+++ b/src/Mono/Cecil/PE/DataDirectory.cs
@@ -0,0 +1,32 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil.PE {
+
+	struct DataDirectory {
+
+		public readonly RVA VirtualAddress;
+		public readonly uint Size;
+
+		public bool IsZero {
+			get { return VirtualAddress == 0 && Size == 0; }
+		}
+
+		public DataDirectory (RVA rva, uint size)
+		{
+			this.VirtualAddress = rva;
+			this.Size = size;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/PE/Image.cs b/src/Mono/Cecil/PE/Image.cs
new file mode 100644
index 00000000..10920618
--- /dev/null
+++ b/src/Mono/Cecil/PE/Image.cs
@@ -0,0 +1,170 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.IO;
+
+using Mono.Cecil.Cil;
+using Mono.Cecil.Metadata;
+using Mono.Collections.Generic;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil.PE {
+
+	sealed class Image : IDisposable {
+
+		public Disposable<Stream> Stream;
+		public string FileName;
+
+		public ModuleKind Kind;
+		public string RuntimeVersion;
+		public TargetArchitecture Architecture;
+		public ModuleCharacteristics Characteristics;
+		public ushort LinkerVersion;
+		public ushort SubSystemMajor;
+		public ushort SubSystemMinor;
+
+		public ImageDebugHeader DebugHeader;
+
+		public Section [] Sections;
+
+		public Section MetadataSection;
+
+		public uint EntryPointToken;
+		public uint Timestamp;
+		public ModuleAttributes Attributes;
+
+		public DataDirectory Win32Resources;
+		public DataDirectory Debug;
+		public DataDirectory Resources;
+		public DataDirectory StrongName;
+
+		public StringHeap StringHeap;
+		public BlobHeap BlobHeap;
+		public UserStringHeap UserStringHeap;
+		public GuidHeap GuidHeap;
+		public TableHeap TableHeap;
+		public PdbHeap PdbHeap;
+
+		readonly int [] coded_index_sizes = new int [14];
+
+		readonly Func<Table, int> counter;
+
+		public Image ()
+		{
+			counter = GetTableLength;
+		}
+
+		public bool HasTable (Table table)
+		{
+			return GetTableLength (table) > 0;
+		}
+
+		public int GetTableLength (Table table)
+		{
+			return (int) TableHeap [table].Length;
+		}
+
+		public int GetTableIndexSize (Table table)
+		{
+			return GetTableLength (table) < 65536 ? 2 : 4;
+		}
+
+		public int GetCodedIndexSize (CodedIndex coded_index)
+		{
+			var index = (int) coded_index;
+			var size = coded_index_sizes [index];
+			if (size != 0)
+				return size;
+
+			return coded_index_sizes [index] = coded_index.GetSize (counter);
+		}
+
+		public uint ResolveVirtualAddress (RVA rva)
+		{
+			var section = GetSectionAtVirtualAddress (rva);
+			if (section == null)
+				throw new ArgumentOutOfRangeException ();
+
+			return ResolveVirtualAddressInSection (rva, section);
+		}
+
+		public uint ResolveVirtualAddressInSection (RVA rva, Section section)
+		{
+			return rva + section.PointerToRawData - section.VirtualAddress;
+		}
+
+		public Section GetSection (string name)
+		{
+			var sections = this.Sections;
+			for (int i = 0; i < sections.Length; i++) {
+				var section = sections [i];
+				if (section.Name == name)
+					return section;
+			}
+
+			return null;
+		}
+
+		public Section GetSectionAtVirtualAddress (RVA rva)
+		{
+			var sections = this.Sections;
+			for (int i = 0; i < sections.Length; i++) {
+				var section = sections [i];
+				if (rva >= section.VirtualAddress && rva < section.VirtualAddress + section.SizeOfRawData)
+					return section;
+			}
+
+			return null;
+		}
+
+		BinaryStreamReader GetReaderAt (RVA rva)
+		{
+			var section = GetSectionAtVirtualAddress (rva);
+			if (section == null)
+				return null;
+
+			var reader = new BinaryStreamReader (Stream.value);
+			reader.MoveTo (ResolveVirtualAddressInSection (rva, section));
+			return reader;
+		}
+
+		public TRet GetReaderAt<TItem, TRet> (RVA rva, TItem item, Func<TItem, BinaryStreamReader, TRet> read) where TRet : class
+		{
+			var position = Stream.value.Position;
+			try {
+				var reader = GetReaderAt (rva);
+				if (reader == null)
+					return null;
+
+				return read (item, reader);
+			} finally {
+				Stream.value.Position = position;
+			}
+		}
+
+		public bool HasDebugTables ()
+		{
+			return HasTable (Table.Document)
+				|| HasTable (Table.MethodDebugInformation)
+				|| HasTable (Table.LocalScope)
+				|| HasTable (Table.LocalVariable)
+				|| HasTable (Table.LocalConstant)
+				|| HasTable (Table.StateMachineMethod)
+				|| HasTable (Table.CustomDebugInformation);
+		}
+
+		public void Dispose ()
+		{
+			Stream.Dispose ();
+		}
+	}
+}
diff --git a/src/Mono/Cecil/PE/ImageReader.cs b/src/Mono/Cecil/PE/ImageReader.cs
new file mode 100644
index 00000000..e1bcd4c7
--- /dev/null
+++ b/src/Mono/Cecil/PE/ImageReader.cs
@@ -0,0 +1,793 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.IO;
+
+using Mono.Cecil.Cil;
+using Mono.Cecil.Metadata;
+using Mono.Collections.Generic;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil.PE {
+
+	sealed class ImageReader : BinaryStreamReader {
+
+		readonly Image image;
+
+		DataDirectory cli;
+		DataDirectory metadata;
+
+		uint table_heap_offset;
+
+		public ImageReader (Disposable<Stream> stream, string file_name)
+			: base (stream.value)
+		{
+			image = new Image ();
+			image.Stream = stream;
+			image.FileName = file_name;
+		}
+
+		void MoveTo (DataDirectory directory)
+		{
+			BaseStream.Position = image.ResolveVirtualAddress (directory.VirtualAddress);
+		}
+
+		void ReadImage ()
+		{
+			if (BaseStream.Length < 128)
+				throw new BadImageFormatException ();
+
+			// - DOSHeader
+
+			// PE					2
+			// Start				58
+			// Lfanew				4
+			// End					64
+
+			if (ReadUInt16 () != 0x5a4d)
+				throw new BadImageFormatException ();
+
+			Advance (58);
+
+			MoveTo (ReadUInt32 ());
+
+			if (ReadUInt32 () != 0x00004550)
+				throw new BadImageFormatException ();
+
+			// - PEFileHeader
+
+			// Machine				2
+			image.Architecture = ReadArchitecture ();
+
+			// NumberOfSections		2
+			ushort sections = ReadUInt16 ();
+
+			// TimeDateStamp		4
+			image.Timestamp = ReadUInt32 ();
+			// PointerToSymbolTable	4
+			// NumberOfSymbols		4
+			// OptionalHeaderSize	2
+			Advance (10);
+
+			// Characteristics		2
+			ushort characteristics = ReadUInt16 ();
+
+			ushort subsystem, dll_characteristics;
+			ReadOptionalHeaders (out subsystem, out dll_characteristics);
+			ReadSections (sections);
+			ReadCLIHeader ();
+			ReadMetadata ();
+			ReadDebugHeader ();
+
+			image.Kind = GetModuleKind (characteristics, subsystem);
+			image.Characteristics = (ModuleCharacteristics) dll_characteristics;
+		}
+
+		TargetArchitecture ReadArchitecture ()
+		{
+			return (TargetArchitecture) ReadUInt16 ();
+		}
+
+		static ModuleKind GetModuleKind (ushort characteristics, ushort subsystem)
+		{
+			if ((characteristics & 0x2000) != 0) // ImageCharacteristics.Dll
+				return ModuleKind.Dll;
+
+			if (subsystem == 0x2 || subsystem == 0x9) // SubSystem.WindowsGui || SubSystem.WindowsCeGui
+				return ModuleKind.Windows;
+
+			return ModuleKind.Console;
+		}
+
+		void ReadOptionalHeaders (out ushort subsystem, out ushort dll_characteristics)
+		{
+			// - PEOptionalHeader
+			//   - StandardFieldsHeader
+
+			// Magic				2
+			bool pe64 = ReadUInt16 () == 0x20b;
+
+			//						pe32 || pe64
+
+			image.LinkerVersion = ReadUInt16 ();
+			// CodeSize				4
+			// InitializedDataSize	4
+			// UninitializedDataSize4
+			// EntryPointRVA		4
+			// BaseOfCode			4
+			// BaseOfData			4 || 0
+
+			//   - NTSpecificFieldsHeader
+
+			// ImageBase			4 || 8
+			// SectionAlignment		4
+			// FileAlignement		4
+			// OSMajor				2
+			// OSMinor				2
+			// UserMajor			2
+			// UserMinor			2
+			// SubSysMajor			2
+			// SubSysMinor			2
+			Advance(44);
+
+			image.SubSystemMajor = ReadUInt16 ();
+			image.SubSystemMinor = ReadUInt16 ();
+
+			// Reserved				4
+			// ImageSize			4
+			// HeaderSize			4
+			// FileChecksum			4
+			Advance (16);
+
+			// SubSystem			2
+			subsystem = ReadUInt16 ();
+
+			// DLLFlags				2
+			dll_characteristics = ReadUInt16 ();
+			// StackReserveSize		4 || 8
+			// StackCommitSize		4 || 8
+			// HeapReserveSize		4 || 8
+			// HeapCommitSize		4 || 8
+			// LoaderFlags			4
+			// NumberOfDataDir		4
+
+			//   - DataDirectoriesHeader
+
+			// ExportTable			8
+			// ImportTable			8
+
+			Advance (pe64 ? 56 : 40);
+
+			// ResourceTable		8
+
+			image.Win32Resources = ReadDataDirectory ();
+
+			// ExceptionTable		8
+			// CertificateTable		8
+			// BaseRelocationTable	8
+
+			Advance (24);
+
+			// Debug				8
+			image.Debug = ReadDataDirectory ();
+
+			// Copyright			8
+			// GlobalPtr			8
+			// TLSTable				8
+			// LoadConfigTable		8
+			// BoundImport			8
+			// IAT					8
+			// DelayImportDescriptor8
+			Advance (56);
+
+			// CLIHeader			8
+			cli = ReadDataDirectory ();
+
+			if (cli.IsZero)
+				throw new BadImageFormatException ();
+
+			// Reserved				8
+			Advance (8);
+		}
+
+		string ReadAlignedString (int length)
+		{
+			int read = 0;
+			var buffer = new char [length];
+			while (read < length) {
+				var current = ReadByte ();
+				if (current == 0)
+					break;
+
+				buffer [read++] = (char) current;
+			}
+
+			Advance (-1 + ((read + 4) & ~3) - read);
+
+			return new string (buffer, 0, read);
+		}
+
+		string ReadZeroTerminatedString (int length)
+		{
+			int read = 0;
+			var buffer = new char [length];
+			var bytes = ReadBytes (length);
+			while (read < length) {
+				var current = bytes [read];
+				if (current == 0)
+					break;
+
+				buffer [read++] = (char) current;
+			}
+
+			return new string (buffer, 0, read);
+		}
+
+		void ReadSections (ushort count)
+		{
+			var sections = new Section [count];
+
+			for (int i = 0; i < count; i++) {
+				var section = new Section ();
+
+				// Name
+				section.Name = ReadZeroTerminatedString (8);
+
+				// VirtualSize		4
+				Advance (4);
+
+				// VirtualAddress	4
+				section.VirtualAddress = ReadUInt32 ();
+				// SizeOfRawData	4
+				section.SizeOfRawData = ReadUInt32 ();
+				// PointerToRawData	4
+				section.PointerToRawData = ReadUInt32 ();
+
+				// PointerToRelocations		4
+				// PointerToLineNumbers		4
+				// NumberOfRelocations		2
+				// NumberOfLineNumbers		2
+				// Characteristics			4
+				Advance (16);
+
+				sections [i] = section;
+			}
+
+			image.Sections = sections;
+		}
+
+		void ReadCLIHeader ()
+		{
+			MoveTo (cli);
+
+			// - CLIHeader
+
+			// Cb						4
+			// MajorRuntimeVersion		2
+			// MinorRuntimeVersion		2
+			Advance (8);
+
+			// Metadata					8
+			metadata = ReadDataDirectory ();
+			// Flags					4
+			image.Attributes = (ModuleAttributes) ReadUInt32 ();
+			// EntryPointToken			4
+			image.EntryPointToken = ReadUInt32 ();
+			// Resources				8
+			image.Resources = ReadDataDirectory ();
+			// StrongNameSignature		8
+			image.StrongName = ReadDataDirectory ();
+			// CodeManagerTable			8
+			// VTableFixups				8
+			// ExportAddressTableJumps	8
+			// ManagedNativeHeader		8
+		}
+
+		void ReadMetadata ()
+		{
+			MoveTo (metadata);
+
+			if (ReadUInt32 () != 0x424a5342)
+				throw new BadImageFormatException ();
+
+			// MajorVersion			2
+			// MinorVersion			2
+			// Reserved				4
+			Advance (8);
+
+			image.RuntimeVersion = ReadZeroTerminatedString (ReadInt32 ());
+
+			// Flags		2
+			Advance (2);
+
+			var streams = ReadUInt16 ();
+
+			var section = image.GetSectionAtVirtualAddress (metadata.VirtualAddress);
+			if (section == null)
+				throw new BadImageFormatException ();
+
+			image.MetadataSection = section;
+
+			for (int i = 0; i < streams; i++)
+				ReadMetadataStream (section);
+
+			if (image.PdbHeap != null)
+				ReadPdbHeap ();
+
+			if (image.TableHeap != null)
+				ReadTableHeap ();
+		}
+
+		void ReadDebugHeader ()
+		{
+			if (image.Debug.IsZero) {
+				image.DebugHeader = new ImageDebugHeader (Empty<ImageDebugHeaderEntry>.Array);
+				return;
+			}
+
+			MoveTo (image.Debug);
+
+			var entries = new ImageDebugHeaderEntry [(int) image.Debug.Size / ImageDebugDirectory.Size];
+
+			for (int i = 0; i < entries.Length; i++) {
+				var directory = new ImageDebugDirectory {
+					Characteristics = ReadInt32 (),
+					TimeDateStamp = ReadInt32 (),
+					MajorVersion = ReadInt16 (),
+					MinorVersion = ReadInt16 (),
+					Type = (ImageDebugType) ReadInt32 (),
+					SizeOfData = ReadInt32 (),
+					AddressOfRawData = ReadInt32 (),
+					PointerToRawData = ReadInt32 (),
+				};
+
+				if (directory.AddressOfRawData == 0) {
+					entries [i] = new ImageDebugHeaderEntry (directory, Empty<byte>.Array);
+					continue;
+				}
+
+				var position = Position;
+				try {
+					MoveTo ((uint) directory.PointerToRawData);
+					var data = ReadBytes (directory.SizeOfData);
+					entries [i] = new ImageDebugHeaderEntry (directory, data);
+				} finally {
+					Position = position;
+				}
+			}
+
+			image.DebugHeader = new ImageDebugHeader (entries);
+		}
+
+		void ReadMetadataStream (Section section)
+		{
+			// Offset		4
+			uint offset = metadata.VirtualAddress - section.VirtualAddress + ReadUInt32 (); // relative to the section start
+
+			// Size			4
+			uint size = ReadUInt32 ();
+
+			var data = ReadHeapData (offset, size);
+
+			var name = ReadAlignedString (16);
+			switch (name) {
+			case "#~":
+			case "#-":
+				image.TableHeap = new TableHeap (data);
+				table_heap_offset = offset;
+				break;
+			case "#Strings":
+				image.StringHeap = new StringHeap (data);
+				break;
+			case "#Blob":
+				image.BlobHeap = new BlobHeap (data);
+				break;
+			case "#GUID":
+				image.GuidHeap = new GuidHeap (data);
+				break;
+			case "#US":
+				image.UserStringHeap = new UserStringHeap (data);
+				break;
+			case "#Pdb":
+				image.PdbHeap = new PdbHeap (data);
+				break;
+			}
+		}
+
+		byte [] ReadHeapData (uint offset, uint size)
+		{
+			var position = BaseStream.Position;
+			MoveTo (offset + image.MetadataSection.PointerToRawData);
+			var data = ReadBytes ((int) size);
+			BaseStream.Position = position;
+
+			return data;
+		}
+
+		void ReadTableHeap ()
+		{
+			var heap = image.TableHeap;
+
+			MoveTo (table_heap_offset + image.MetadataSection.PointerToRawData);
+
+			// Reserved			4
+			// MajorVersion		1
+			// MinorVersion		1
+			Advance (6);
+
+			// HeapSizes		1
+			var sizes = ReadByte ();
+
+			// Reserved2		1
+			Advance (1);
+
+			// Valid			8
+			heap.Valid = ReadInt64 ();
+
+			// Sorted			8
+			heap.Sorted = ReadInt64 ();
+
+			if (image.PdbHeap != null) {
+				for (int i = 0; i < Mixin.TableCount; i++) {
+					if (!image.PdbHeap.HasTable ((Table) i))
+						continue;
+
+					heap.Tables [i].Length = image.PdbHeap.TypeSystemTableRows [i];
+				}
+			}
+
+			for (int i = 0; i < Mixin.TableCount; i++) {
+				if (!heap.HasTable ((Table) i))
+					continue;
+
+				heap.Tables [i].Length = ReadUInt32 ();
+			}
+
+			SetIndexSize (image.StringHeap, sizes, 0x1);
+			SetIndexSize (image.GuidHeap, sizes, 0x2);
+			SetIndexSize (image.BlobHeap, sizes, 0x4);
+
+			ComputeTableInformations ();
+		}
+
+		static void SetIndexSize (Heap heap, uint sizes, byte flag)
+		{
+			if (heap == null)
+				return;
+
+			heap.IndexSize = (sizes & flag) > 0 ? 4 : 2;
+		}
+
+		int GetTableIndexSize (Table table)
+		{
+			return image.GetTableIndexSize (table);
+		}
+
+		int GetCodedIndexSize (CodedIndex index)
+		{
+			return image.GetCodedIndexSize (index);
+		}
+
+		void ComputeTableInformations ()
+		{
+			uint offset = (uint) BaseStream.Position - table_heap_offset - image.MetadataSection.PointerToRawData; // header
+
+			int stridx_size = image.StringHeap.IndexSize;
+			int guididx_size = image.GuidHeap != null ? image.GuidHeap.IndexSize : 2;
+			int blobidx_size = image.BlobHeap != null ? image.BlobHeap.IndexSize : 2;
+
+			var heap = image.TableHeap;
+			var tables = heap.Tables;
+
+			for (int i = 0; i < Mixin.TableCount; i++) {
+				var table = (Table) i;
+				if (!heap.HasTable (table))
+					continue;
+
+				int size;
+				switch (table) {
+				case Table.Module:
+					size = 2	// Generation
+						+ stridx_size	// Name
+						+ (guididx_size * 3);	// Mvid, EncId, EncBaseId
+					break;
+				case Table.TypeRef:
+					size = GetCodedIndexSize (CodedIndex.ResolutionScope)	// ResolutionScope
+						+ (stridx_size * 2);	// Name, Namespace
+					break;
+				case Table.TypeDef:
+					size = 4	// Flags
+						+ (stridx_size * 2)	// Name, Namespace
+						+ GetCodedIndexSize (CodedIndex.TypeDefOrRef)	// BaseType
+						+ GetTableIndexSize (Table.Field)	// FieldList
+						+ GetTableIndexSize (Table.Method);	// MethodList
+					break;
+				case Table.FieldPtr:
+					size = GetTableIndexSize (Table.Field);	// Field
+					break;
+				case Table.Field:
+					size = 2	// Flags
+						+ stridx_size	// Name
+						+ blobidx_size;	// Signature
+					break;
+				case Table.MethodPtr:
+					size = GetTableIndexSize (Table.Method);	// Method
+					break;
+				case Table.Method:
+					size = 8	// Rva 4, ImplFlags 2, Flags 2
+						+ stridx_size	// Name
+						+ blobidx_size	// Signature
+						+ GetTableIndexSize (Table.Param); // ParamList
+					break;
+				case Table.ParamPtr:
+					size = GetTableIndexSize (Table.Param); // Param
+					break;
+				case Table.Param:
+					size = 4	// Flags 2, Sequence 2
+						+ stridx_size;	// Name
+					break;
+				case Table.InterfaceImpl:
+					size = GetTableIndexSize (Table.TypeDef)	// Class
+						+ GetCodedIndexSize (CodedIndex.TypeDefOrRef);	// Interface
+					break;
+				case Table.MemberRef:
+					size = GetCodedIndexSize (CodedIndex.MemberRefParent)	// Class
+						+ stridx_size	// Name
+						+ blobidx_size;	// Signature
+					break;
+				case Table.Constant:
+					size = 2	// Type
+						+ GetCodedIndexSize (CodedIndex.HasConstant)	// Parent
+						+ blobidx_size;	// Value
+					break;
+				case Table.CustomAttribute:
+					size = GetCodedIndexSize (CodedIndex.HasCustomAttribute)	// Parent
+						+ GetCodedIndexSize (CodedIndex.CustomAttributeType)	// Type
+						+ blobidx_size;	// Value
+					break;
+				case Table.FieldMarshal:
+					size = GetCodedIndexSize (CodedIndex.HasFieldMarshal)	// Parent
+						+ blobidx_size;	// NativeType
+					break;
+				case Table.DeclSecurity:
+					size = 2	// Action
+						+ GetCodedIndexSize (CodedIndex.HasDeclSecurity)	// Parent
+						+ blobidx_size;	// PermissionSet
+					break;
+				case Table.ClassLayout:
+					size = 6	// PackingSize 2, ClassSize 4
+						+ GetTableIndexSize (Table.TypeDef);	// Parent
+					break;
+				case Table.FieldLayout:
+					size = 4	// Offset
+						+ GetTableIndexSize (Table.Field);	// Field
+					break;
+				case Table.StandAloneSig:
+					size = blobidx_size;	// Signature
+					break;
+				case Table.EventMap:
+					size = GetTableIndexSize (Table.TypeDef)	// Parent
+						+ GetTableIndexSize (Table.Event);	// EventList
+					break;
+				case Table.EventPtr:
+					size = GetTableIndexSize (Table.Event);	// Event
+					break;
+				case Table.Event:
+					size = 2	// Flags
+						+ stridx_size // Name
+						+ GetCodedIndexSize (CodedIndex.TypeDefOrRef);	// EventType
+					break;
+				case Table.PropertyMap:
+					size = GetTableIndexSize (Table.TypeDef)	// Parent
+						+ GetTableIndexSize (Table.Property);	// PropertyList
+					break;
+				case Table.PropertyPtr:
+					size = GetTableIndexSize (Table.Property);	// Property
+					break;
+				case Table.Property:
+					size = 2	// Flags
+						+ stridx_size	// Name
+						+ blobidx_size;	// Type
+					break;
+				case Table.MethodSemantics:
+					size = 2	// Semantics
+						+ GetTableIndexSize (Table.Method)	// Method
+						+ GetCodedIndexSize (CodedIndex.HasSemantics);	// Association
+					break;
+				case Table.MethodImpl:
+					size = GetTableIndexSize (Table.TypeDef)	// Class
+						+ GetCodedIndexSize (CodedIndex.MethodDefOrRef)	// MethodBody
+						+ GetCodedIndexSize (CodedIndex.MethodDefOrRef);	// MethodDeclaration
+					break;
+				case Table.ModuleRef:
+					size = stridx_size;	// Name
+					break;
+				case Table.TypeSpec:
+					size = blobidx_size;	// Signature
+					break;
+				case Table.ImplMap:
+					size = 2	// MappingFlags
+						+ GetCodedIndexSize (CodedIndex.MemberForwarded)	// MemberForwarded
+						+ stridx_size	// ImportName
+						+ GetTableIndexSize (Table.ModuleRef);	// ImportScope
+					break;
+				case Table.FieldRVA:
+					size = 4	// RVA
+						+ GetTableIndexSize (Table.Field);	// Field
+					break;
+				case Table.EncLog:
+					size = 8;
+					break;
+				case Table.EncMap:
+					size = 4;
+					break;
+				case Table.Assembly:
+					size = 16 // HashAlgId 4, Version 4 * 2, Flags 4
+						+ blobidx_size	// PublicKey
+						+ (stridx_size * 2);	// Name, Culture
+					break;
+				case Table.AssemblyProcessor:
+					size = 4;	// Processor
+					break;
+				case Table.AssemblyOS:
+					size = 12;	// Platform 4, Version 2 * 4
+					break;
+				case Table.AssemblyRef:
+					size = 12	// Version 2 * 4 + Flags 4
+						+ (blobidx_size * 2)	// PublicKeyOrToken, HashValue
+						+ (stridx_size * 2);	// Name, Culture
+					break;
+				case Table.AssemblyRefProcessor:
+					size = 4	// Processor
+						+ GetTableIndexSize (Table.AssemblyRef);	// AssemblyRef
+					break;
+				case Table.AssemblyRefOS:
+					size = 12	// Platform 4, Version 2 * 4
+						+ GetTableIndexSize (Table.AssemblyRef);	// AssemblyRef
+					break;
+				case Table.File:
+					size = 4	// Flags
+						+ stridx_size	// Name
+						+ blobidx_size;	// HashValue
+					break;
+				case Table.ExportedType:
+					size = 8	// Flags 4, TypeDefId 4
+						+ (stridx_size * 2)	// Name, Namespace
+						+ GetCodedIndexSize (CodedIndex.Implementation);	// Implementation
+					break;
+				case Table.ManifestResource:
+					size = 8	// Offset, Flags
+						+ stridx_size	// Name
+						+ GetCodedIndexSize (CodedIndex.Implementation);	// Implementation
+					break;
+				case Table.NestedClass:
+					size = GetTableIndexSize (Table.TypeDef)	// NestedClass
+						+ GetTableIndexSize (Table.TypeDef);	// EnclosingClass
+					break;
+				case Table.GenericParam:
+					size = 4	// Number, Flags
+						+ GetCodedIndexSize (CodedIndex.TypeOrMethodDef)	// Owner
+						+ stridx_size;	// Name
+					break;
+				case Table.MethodSpec:
+					size = GetCodedIndexSize (CodedIndex.MethodDefOrRef)	// Method
+						+ blobidx_size;	// Instantiation
+					break;
+				case Table.GenericParamConstraint:
+					size = GetTableIndexSize (Table.GenericParam)	// Owner
+						+ GetCodedIndexSize (CodedIndex.TypeDefOrRef);	// Constraint
+					break;
+				case Table.Document:
+					size = blobidx_size	// Name
+						+ guididx_size	// HashAlgorithm
+						+ blobidx_size	// Hash
+						+ guididx_size;	// Language
+					break;
+				case Table.MethodDebugInformation:
+					size = GetTableIndexSize (Table.Document)  // Document
+						+ blobidx_size;	// SequencePoints
+					break;
+				case Table.LocalScope:
+					size = GetTableIndexSize (Table.Method)	// Method
+						+ GetTableIndexSize (Table.ImportScope)	// ImportScope
+						+ GetTableIndexSize (Table.LocalVariable)	// VariableList
+						+ GetTableIndexSize (Table.LocalConstant)	// ConstantList
+						+ 4 * 2;	// StartOffset, Length
+					break;
+				case Table.LocalVariable:
+					size = 2	// Attributes
+						+ 2		// Index
+						+ stridx_size;	// Name
+					break;
+				case Table.LocalConstant:
+					size = stridx_size	// Name
+						+ blobidx_size;	// Signature
+					break;
+				case Table.ImportScope:
+					size = GetTableIndexSize (Table.ImportScope)	// Parent
+						+ blobidx_size;
+					break;
+				case Table.StateMachineMethod:
+					size = GetTableIndexSize (Table.Method) // MoveNextMethod
+						+ GetTableIndexSize (Table.Method);	// KickOffMethod
+					break;
+				case Table.CustomDebugInformation:
+					size = GetCodedIndexSize (CodedIndex.HasCustomDebugInformation) // Parent
+						+ guididx_size	// Kind
+						+ blobidx_size;	// Value
+					break;
+				default:
+					throw new NotSupportedException ();
+				}
+
+				tables [i].RowSize = (uint) size;
+				tables [i].Offset = offset;
+
+				offset += (uint) size * tables [i].Length;
+			}
+		}
+
+		void ReadPdbHeap ()
+		{
+			var heap = image.PdbHeap;
+
+			var buffer = new ByteBuffer (heap.data);
+
+			heap.Id = buffer.ReadBytes (20);
+			heap.EntryPoint = buffer.ReadUInt32 ();
+			heap.TypeSystemTables = buffer.ReadInt64 ();
+			heap.TypeSystemTableRows = new uint [Mixin.TableCount];
+
+			for (int i = 0; i < Mixin.TableCount; i++) {
+				var table = (Table) i;
+				if (!heap.HasTable (table))
+					continue;
+
+				heap.TypeSystemTableRows [i] = buffer.ReadUInt32 ();
+			}
+		}
+
+		public static Image ReadImage (Disposable<Stream> stream, string file_name)
+		{
+			try {
+				var reader = new ImageReader (stream, file_name);
+				reader.ReadImage ();
+				return reader.image;
+			} catch (EndOfStreamException e) {
+				throw new BadImageFormatException (stream.value.GetFileName (), e);
+			}
+		}
+
+		public static Image ReadPortablePdb (Disposable<Stream> stream, string file_name)
+		{
+			try {
+				var reader = new ImageReader (stream, file_name);
+				var length = (uint) stream.value.Length;
+
+				reader.image.Sections = new[] {
+					new Section {
+						PointerToRawData = 0,
+						SizeOfRawData = length,
+						VirtualAddress = 0,
+						VirtualSize = length,
+					}
+				};
+
+				reader.metadata = new DataDirectory (0, length);
+				reader.ReadMetadata ();
+				return reader.image;
+			} catch (EndOfStreamException e) {
+				throw new BadImageFormatException (stream.value.GetFileName (), e);
+			}
+		}
+	}
+}
diff --git a/src/Mono/Cecil/PE/ImageWriter.cs b/src/Mono/Cecil/PE/ImageWriter.cs
new file mode 100644
index 00000000..95a36c13
--- /dev/null
+++ b/src/Mono/Cecil/PE/ImageWriter.cs
@@ -0,0 +1,855 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.IO;
+
+#if !READ_ONLY
+
+using Mono.Cecil.Cil;
+using Mono.Cecil.Metadata;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil.PE {
+
+	sealed class ImageWriter : BinaryStreamWriter {
+
+		readonly ModuleDefinition module;
+		readonly MetadataBuilder metadata;
+		readonly TextMap text_map;
+		readonly internal Disposable<Stream> stream;
+
+		readonly string runtime_version;
+
+		ImageDebugHeader debug_header;
+
+		ByteBuffer win32_resources;
+
+		const uint pe_header_size = 0x98u;
+		const uint section_header_size = 0x28u;
+		const uint file_alignment = 0x200;
+		const uint section_alignment = 0x2000;
+		const ulong image_base = 0x00400000;
+
+		internal const RVA text_rva = 0x2000;
+
+		readonly bool pe64;
+		readonly bool has_reloc;
+
+		internal Section text;
+		internal Section rsrc;
+		internal Section reloc;
+
+		ushort sections;
+
+		ImageWriter (ModuleDefinition module, string runtime_version, MetadataBuilder metadata, Disposable<Stream> stream, bool metadataOnly = false)
+			: base (stream.value)
+		{
+			this.module = module;
+			this.runtime_version = runtime_version;
+			this.text_map = metadata.text_map;
+			this.stream = stream;
+			this.metadata = metadata;
+			if (metadataOnly)
+				return;
+
+			this.pe64 = module.Architecture == TargetArchitecture.AMD64 || module.Architecture == TargetArchitecture.IA64 || module.Architecture == TargetArchitecture.ARM64;
+			this.has_reloc = module.Architecture == TargetArchitecture.I386;
+			this.GetDebugHeader ();
+			this.GetWin32Resources ();
+			this.BuildTextMap ();
+			this.sections = (ushort) (has_reloc ? 2 : 1); // text + reloc?
+		}
+
+		void GetDebugHeader ()
+		{
+			var symbol_writer = metadata.symbol_writer;
+			if (symbol_writer != null)
+				debug_header = symbol_writer.GetDebugHeader ();
+
+			if (module.HasDebugHeader) {
+				var header = module.GetDebugHeader ();
+				var deterministic = header.GetDeterministicEntry ();
+				if (deterministic == null)
+					return;
+
+				debug_header = debug_header.AddDeterministicEntry ();
+			}
+		}
+
+		void GetWin32Resources ()
+		{
+			if (!module.HasImage)
+				return;
+
+			DataDirectory win32_resources_directory = module.Image.Win32Resources;
+			var size = win32_resources_directory.Size;
+
+			if (size > 0) {
+				win32_resources = module.Image.GetReaderAt (win32_resources_directory.VirtualAddress, size, (s, reader) => new ByteBuffer (reader.ReadBytes ((int) s)));
+			}
+		}
+
+		public static ImageWriter CreateWriter (ModuleDefinition module, MetadataBuilder metadata, Disposable<Stream> stream)
+		{
+			var writer = new ImageWriter (module, module.runtime_version, metadata, stream);
+			writer.BuildSections ();
+			return writer;
+		}
+
+		public static ImageWriter CreateDebugWriter (ModuleDefinition module, MetadataBuilder metadata, Disposable<Stream> stream)
+		{
+			var writer = new ImageWriter (module, "PDB v1.0", metadata, stream, metadataOnly: true);
+			var length = metadata.text_map.GetLength ();
+			writer.text = new Section { SizeOfRawData = length, VirtualSize = length };
+			return writer;
+		}
+
+		void BuildSections ()
+		{
+			var has_win32_resources = win32_resources != null;
+			if (has_win32_resources)
+				sections++;
+
+			text = CreateSection (".text", text_map.GetLength (), null);
+			var previous = text;
+
+			if (has_win32_resources) {
+				rsrc = CreateSection (".rsrc", (uint) win32_resources.length, previous);
+
+				PatchWin32Resources (win32_resources);
+				previous = rsrc;
+			}
+
+			if (has_reloc)
+				reloc = CreateSection (".reloc", 12u, previous);
+		}
+
+		Section CreateSection (string name, uint size, Section previous)
+		{
+			return new Section {
+				Name = name,
+				VirtualAddress = previous != null
+					? previous.VirtualAddress + Align (previous.VirtualSize, section_alignment)
+					: text_rva,
+				VirtualSize = size,
+				PointerToRawData = previous != null
+					? previous.PointerToRawData + previous.SizeOfRawData
+					: Align (GetHeaderSize (), file_alignment),
+				SizeOfRawData = Align (size, file_alignment)
+			};
+		}
+
+		static uint Align (uint value, uint align)
+		{
+			align--;
+			return (value + align) & ~align;
+		}
+
+		void WriteDOSHeader ()
+		{
+			Write (new byte [] {
+				// dos header start
+				0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00, 0x00,
+				0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff,
+				0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00,
+				// lfanew
+				0x80, 0x00, 0x00, 0x00,
+				// dos header end
+				0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09,
+				0xcd, 0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21,
+				0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72,
+				0x6f, 0x67, 0x72, 0x61, 0x6d, 0x20, 0x63,
+				0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62,
+				0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69,
+				0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20, 0x6d,
+				0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a,
+				0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00
+			});
+		}
+
+		ushort SizeOfOptionalHeader ()
+		{
+			return (ushort) (!pe64 ? 0xe0 : 0xf0);
+		}
+
+		void WritePEFileHeader ()
+		{
+			WriteUInt32 (0x00004550);		// Magic
+			WriteUInt16 ((ushort) module.Architecture);	// Machine
+			WriteUInt16 (sections);			// NumberOfSections
+			WriteUInt32 (metadata.timestamp);
+			WriteUInt32 (0);	// PointerToSymbolTable
+			WriteUInt32 (0);	// NumberOfSymbols
+			WriteUInt16 (SizeOfOptionalHeader ());	// SizeOfOptionalHeader
+
+			// ExecutableImage | (pe64 ? 32BitsMachine : LargeAddressAware)
+			var characteristics = (ushort) (0x0002 | (!pe64 ? 0x0100 : 0x0020));
+			if (module.Kind == ModuleKind.Dll || module.Kind == ModuleKind.NetModule)
+				characteristics |= 0x2000;
+			WriteUInt16 (characteristics);	// Characteristics
+		}
+
+		Section LastSection ()
+		{
+			if (reloc != null)
+				return reloc;
+
+			if (rsrc != null)
+				return rsrc;
+
+			return text;
+		}
+
+		void WriteOptionalHeaders ()
+		{
+			WriteUInt16 ((ushort) (!pe64 ? 0x10b : 0x20b)); // Magic
+			WriteUInt16 (module.linker_version);
+			WriteUInt32 (text.SizeOfRawData);	// CodeSize
+			WriteUInt32 ((reloc != null ? reloc.SizeOfRawData : 0)
+				+ (rsrc != null ? rsrc.SizeOfRawData : 0));	// InitializedDataSize
+			WriteUInt32 (0);	// UninitializedDataSize
+
+			var startub_stub = text_map.GetRange (TextSegment.StartupStub);
+			WriteUInt32 (startub_stub.Length > 0 ? startub_stub.Start : 0);  // EntryPointRVA
+			WriteUInt32 (text_rva);	// BaseOfCode
+
+			if (!pe64) {
+				WriteUInt32 (0);	// BaseOfData
+				WriteUInt32 ((uint) image_base);	// ImageBase
+			} else {
+				WriteUInt64 (image_base);	// ImageBase
+			}
+
+			WriteUInt32 (section_alignment);	// SectionAlignment
+			WriteUInt32 (file_alignment);		// FileAlignment
+
+			WriteUInt16 (4);	// OSMajor
+			WriteUInt16 (0);	// OSMinor
+			WriteUInt16 (0);	// UserMajor
+			WriteUInt16 (0);	// UserMinor
+			WriteUInt16 (module.subsystem_major);	// SubSysMajor
+			WriteUInt16 (module.subsystem_minor);	// SubSysMinor
+			WriteUInt32 (0);	// Reserved
+
+			var last_section = LastSection();
+			WriteUInt32 (last_section.VirtualAddress + Align (last_section.VirtualSize, section_alignment));	// ImageSize
+			WriteUInt32 (text.PointerToRawData);	// HeaderSize
+
+			WriteUInt32 (0);	// Checksum
+			WriteUInt16 (GetSubSystem ());	// SubSystem
+			WriteUInt16 ((ushort) module.Characteristics);	// DLLFlags
+
+			if (!pe64) {
+				const uint stack_reserve = 0x100000;
+				const uint stack_commit = 0x1000;
+				const uint heap_reserve = 0x100000;
+				const uint heap_commit = 0x1000;
+
+				WriteUInt32 (stack_reserve);
+				WriteUInt32 (stack_commit);
+				WriteUInt32 (heap_reserve);
+				WriteUInt32 (heap_commit);
+			} else {
+				const ulong stack_reserve = 0x400000;
+				const ulong stack_commit = 0x4000;
+				const ulong heap_reserve = 0x100000;
+				const ulong heap_commit = 0x2000;
+
+				WriteUInt64 (stack_reserve);
+				WriteUInt64 (stack_commit);
+				WriteUInt64 (heap_reserve);
+				WriteUInt64 (heap_commit);
+			}
+
+			WriteUInt32 (0);	// LoaderFlags
+			WriteUInt32 (16);	// NumberOfDataDir
+
+			WriteZeroDataDirectory ();	// ExportTable
+			WriteDataDirectory (text_map.GetDataDirectory (TextSegment.ImportDirectory));	// ImportTable
+			if (rsrc != null) {							// ResourceTable
+				WriteUInt32 (rsrc.VirtualAddress);
+				WriteUInt32 (rsrc.VirtualSize);
+			} else
+				WriteZeroDataDirectory ();
+
+			WriteZeroDataDirectory ();	// ExceptionTable
+			WriteZeroDataDirectory ();	// CertificateTable
+			WriteUInt32 (reloc != null ? reloc.VirtualAddress : 0);			// BaseRelocationTable
+			WriteUInt32 (reloc != null ? reloc.VirtualSize : 0);
+
+			if (text_map.GetLength (TextSegment.DebugDirectory) > 0) {
+				WriteUInt32 (text_map.GetRVA (TextSegment.DebugDirectory));
+				WriteUInt32 ((uint) (debug_header.Entries.Length * ImageDebugDirectory.Size));
+			} else
+				WriteZeroDataDirectory ();
+
+			WriteZeroDataDirectory ();	// Copyright
+			WriteZeroDataDirectory ();	// GlobalPtr
+			WriteZeroDataDirectory ();	// TLSTable
+			WriteZeroDataDirectory ();	// LoadConfigTable
+			WriteZeroDataDirectory ();	// BoundImport
+			WriteDataDirectory (text_map.GetDataDirectory (TextSegment.ImportAddressTable));	// IAT
+			WriteZeroDataDirectory ();	// DelayImportDesc
+			WriteDataDirectory (text_map.GetDataDirectory (TextSegment.CLIHeader));	// CLIHeader
+			WriteZeroDataDirectory ();	// Reserved
+		}
+
+		void WriteZeroDataDirectory ()
+		{
+			WriteUInt32 (0);
+			WriteUInt32 (0);
+		}
+
+		ushort GetSubSystem ()
+		{
+			switch (module.Kind) {
+			case ModuleKind.Console:
+			case ModuleKind.Dll:
+			case ModuleKind.NetModule:
+				return 0x3;
+			case ModuleKind.Windows:
+				return 0x2;
+			default:
+				throw new ArgumentOutOfRangeException ();
+			}
+		}
+
+		void WriteSectionHeaders ()
+		{
+			WriteSection (text, 0x60000020);
+
+			if (rsrc != null)
+				WriteSection (rsrc, 0x40000040);
+
+			if (reloc != null)
+				WriteSection (reloc, 0x42000040);
+		}
+
+		void WriteSection (Section section, uint characteristics)
+		{
+			var name = new byte [8];
+			var sect_name = section.Name;
+			for (int i = 0; i < sect_name.Length; i++)
+				name [i] = (byte) sect_name [i];
+
+			WriteBytes (name);
+			WriteUInt32 (section.VirtualSize);
+			WriteUInt32 (section.VirtualAddress);
+			WriteUInt32 (section.SizeOfRawData);
+			WriteUInt32 (section.PointerToRawData);
+			WriteUInt32 (0);	// PointerToRelocations
+			WriteUInt32 (0);	// PointerToLineNumbers
+			WriteUInt16 (0);	// NumberOfRelocations
+			WriteUInt16 (0);	// NumberOfLineNumbers
+			WriteUInt32 (characteristics);
+		}
+
+		void MoveTo (uint pointer)
+		{
+			BaseStream.Seek (pointer, SeekOrigin.Begin);
+		}
+
+		void MoveToRVA (Section section, RVA rva)
+		{
+			BaseStream.Seek (section.PointerToRawData + rva - section.VirtualAddress, SeekOrigin.Begin);
+		}
+
+		void MoveToRVA (TextSegment segment)
+		{
+			MoveToRVA (text, text_map.GetRVA (segment));
+		}
+
+		void WriteRVA (RVA rva)
+		{
+			if (!pe64)
+				WriteUInt32 (rva);
+			else
+				WriteUInt64 (rva);
+		}
+
+		void PrepareSection (Section section)
+		{
+			MoveTo (section.PointerToRawData);
+
+			const int buffer_size = 4096;
+
+			if (section.SizeOfRawData <= buffer_size) {
+				Write (new byte [section.SizeOfRawData]);
+				MoveTo (section.PointerToRawData);
+				return;
+			}
+
+			var written = 0;
+			var buffer = new byte [buffer_size];
+			while (written != section.SizeOfRawData) {
+				var write_size = System.Math.Min((int) section.SizeOfRawData - written, buffer_size);
+				Write (buffer, 0, write_size);
+				written += write_size;
+			}
+
+			MoveTo (section.PointerToRawData);
+		}
+
+		void WriteText ()
+		{
+			PrepareSection (text);
+
+			// ImportAddressTable
+
+			if (has_reloc) {
+				WriteRVA (text_map.GetRVA (TextSegment.ImportHintNameTable));
+				WriteRVA (0);
+			}
+
+			// CLIHeader
+
+			WriteUInt32 (0x48);
+			WriteUInt16 (2);
+			WriteUInt16 ((ushort) ((module.Runtime <= TargetRuntime.Net_1_1) ? 0 : 5));
+
+			WriteUInt32 (text_map.GetRVA (TextSegment.MetadataHeader));
+			WriteUInt32 (GetMetadataLength ());
+			WriteUInt32 ((uint) module.Attributes);
+			WriteUInt32 (metadata.entry_point.ToUInt32 ());
+			WriteDataDirectory (text_map.GetDataDirectory (TextSegment.Resources));
+			WriteDataDirectory (text_map.GetDataDirectory (TextSegment.StrongNameSignature));
+			WriteZeroDataDirectory ();	// CodeManagerTable
+			WriteZeroDataDirectory ();	// VTableFixups
+			WriteZeroDataDirectory ();	// ExportAddressTableJumps
+			WriteZeroDataDirectory ();	// ManagedNativeHeader
+
+			// Code
+
+			MoveToRVA (TextSegment.Code);
+			WriteBuffer (metadata.code);
+
+			// Resources
+
+			MoveToRVA (TextSegment.Resources);
+			WriteBuffer (metadata.resources);
+
+			// Data
+
+			if (metadata.data.length > 0) {
+				MoveToRVA (TextSegment.Data);
+				WriteBuffer (metadata.data);
+			}
+
+			// StrongNameSignature
+			// stays blank
+
+			// MetadataHeader
+
+			MoveToRVA (TextSegment.MetadataHeader);
+			WriteMetadataHeader ();
+
+			WriteMetadata ();
+
+			// DebugDirectory
+			if (text_map.GetLength (TextSegment.DebugDirectory) > 0) {
+				MoveToRVA (TextSegment.DebugDirectory);
+				WriteDebugDirectory ();
+			}
+
+			if (!has_reloc)
+				return;
+
+			// ImportDirectory
+			MoveToRVA (TextSegment.ImportDirectory);
+			WriteImportDirectory ();
+
+			// StartupStub
+			MoveToRVA (TextSegment.StartupStub);
+			WriteStartupStub ();
+		}
+
+		uint GetMetadataLength ()
+		{
+			return text_map.GetRVA (TextSegment.DebugDirectory) - text_map.GetRVA (TextSegment.MetadataHeader);
+		}
+
+		public void WriteMetadataHeader ()
+		{
+			WriteUInt32 (0x424a5342);	// Signature
+			WriteUInt16 (1);	// MajorVersion
+			WriteUInt16 (1);	// MinorVersion
+			WriteUInt32 (0);	// Reserved
+
+			var version = GetZeroTerminatedString (runtime_version);
+			WriteUInt32 ((uint) version.Length);
+			WriteBytes (version);
+			WriteUInt16 (0);	// Flags
+			WriteUInt16 (GetStreamCount ());
+
+			uint offset = text_map.GetRVA (TextSegment.TableHeap) - text_map.GetRVA (TextSegment.MetadataHeader);
+
+			WriteStreamHeader (ref offset, TextSegment.TableHeap, "#~");
+			WriteStreamHeader (ref offset, TextSegment.StringHeap, "#Strings");
+			WriteStreamHeader (ref offset, TextSegment.UserStringHeap, "#US");
+			WriteStreamHeader (ref offset, TextSegment.GuidHeap, "#GUID");
+			WriteStreamHeader (ref offset, TextSegment.BlobHeap, "#Blob");
+			WriteStreamHeader (ref offset, TextSegment.PdbHeap, "#Pdb");
+		}
+
+		ushort GetStreamCount ()
+		{
+			return (ushort) (
+				1	// #~
+				+ 1	// #Strings
+				+ (metadata.user_string_heap.IsEmpty ? 0 : 1)	// #US
+				+ (metadata.guid_heap.IsEmpty ? 0 : 1)	// GUID
+				+ (metadata.blob_heap.IsEmpty ? 0 : 1)
+				+ (metadata.pdb_heap == null ? 0 : 1));	// #Blob
+		}
+
+		void WriteStreamHeader (ref uint offset, TextSegment heap, string name)
+		{
+			var length = (uint) text_map.GetLength (heap);
+			if (length == 0)
+				return;
+
+			WriteUInt32 (offset);
+			WriteUInt32 (length);
+			WriteBytes (GetZeroTerminatedString (name));
+			offset += length;
+		}
+
+		static int GetZeroTerminatedStringLength (string @string)
+		{
+			return (@string.Length + 1 + 3) & ~3;
+		}
+
+		static byte [] GetZeroTerminatedString (string @string)
+		{
+			return GetString (@string, GetZeroTerminatedStringLength (@string));
+		}
+
+		static byte [] GetSimpleString (string @string)
+		{
+			return GetString (@string, @string.Length);
+		}
+
+		static byte [] GetString (string @string, int length)
+		{
+			var bytes = new byte [length];
+			for (int i = 0; i < @string.Length; i++)
+				bytes [i] = (byte) @string [i];
+
+			return bytes;
+		}
+
+		public void WriteMetadata ()
+		{
+			WriteHeap (TextSegment.TableHeap, metadata.table_heap);
+			WriteHeap (TextSegment.StringHeap, metadata.string_heap);
+			WriteHeap (TextSegment.UserStringHeap, metadata.user_string_heap);
+			WriteHeap (TextSegment.GuidHeap, metadata.guid_heap);
+			WriteHeap (TextSegment.BlobHeap, metadata.blob_heap);
+			WriteHeap (TextSegment.PdbHeap, metadata.pdb_heap);
+		}
+
+		void WriteHeap (TextSegment heap, HeapBuffer buffer)
+		{
+			if (buffer == null || buffer.IsEmpty)
+				return;
+
+			MoveToRVA (heap);
+			WriteBuffer (buffer);
+		}
+
+		void WriteDebugDirectory ()
+		{
+			var data_start = (int) BaseStream.Position + (debug_header.Entries.Length * ImageDebugDirectory.Size);
+
+			for (var i = 0; i < debug_header.Entries.Length; i++) {
+				var entry = debug_header.Entries [i];
+				var directory = entry.Directory;
+				WriteInt32 (directory.Characteristics);
+				WriteInt32 (directory.TimeDateStamp);
+				WriteInt16 (directory.MajorVersion);
+				WriteInt16 (directory.MinorVersion);
+				WriteInt32 ((int) directory.Type);
+				WriteInt32 (directory.SizeOfData);
+				WriteInt32 (directory.AddressOfRawData);
+				WriteInt32 (data_start);
+
+				data_start += entry.Data.Length;
+			}
+			
+			for (var i = 0; i < debug_header.Entries.Length; i++) {
+				var entry = debug_header.Entries [i];
+				WriteBytes (entry.Data);
+			}
+		}
+
+		void WriteImportDirectory ()
+		{
+			WriteUInt32 (text_map.GetRVA (TextSegment.ImportDirectory) + 40);	// ImportLookupTable
+			WriteUInt32 (0);	// DateTimeStamp
+			WriteUInt32 (0);	// ForwarderChain
+			WriteUInt32 (text_map.GetRVA (TextSegment.ImportHintNameTable) + 14);
+			WriteUInt32 (text_map.GetRVA (TextSegment.ImportAddressTable));
+			Advance (20);
+
+			// ImportLookupTable
+			WriteUInt32 (text_map.GetRVA (TextSegment.ImportHintNameTable));
+
+			// ImportHintNameTable
+			MoveToRVA (TextSegment.ImportHintNameTable);
+
+			WriteUInt16 (0);	// Hint
+			WriteBytes (GetRuntimeMain ());
+			WriteByte (0);
+			WriteBytes (GetSimpleString ("mscoree.dll"));
+			WriteUInt16 (0);
+		}
+
+		byte [] GetRuntimeMain ()
+		{
+			return module.Kind == ModuleKind.Dll || module.Kind == ModuleKind.NetModule
+				? GetSimpleString ("_CorDllMain")
+				: GetSimpleString ("_CorExeMain");
+		}
+
+		void WriteStartupStub ()
+		{
+			switch (module.Architecture) {
+			case TargetArchitecture.I386:
+				WriteUInt16 (0x25ff);
+				WriteUInt32 ((uint) image_base + text_map.GetRVA (TextSegment.ImportAddressTable));
+				return;
+			default:
+				throw new NotSupportedException ();
+			}
+		}
+
+		void WriteRsrc ()
+		{
+			PrepareSection (rsrc);
+			WriteBuffer (win32_resources);
+		}
+
+		void WriteReloc ()
+		{
+			PrepareSection (reloc);
+
+			var reloc_rva = text_map.GetRVA (TextSegment.StartupStub);
+			reloc_rva += module.Architecture == TargetArchitecture.IA64 ? 0x20u : 2;
+			var page_rva = reloc_rva & ~0xfffu;
+
+			WriteUInt32 (page_rva);	// PageRVA
+			WriteUInt32 (0x000c);	// Block Size
+
+			switch (module.Architecture) {
+			case TargetArchitecture.I386:
+				WriteUInt32 (0x3000 + reloc_rva - page_rva);
+				break;
+			default:
+				throw new NotSupportedException();
+			}
+		}
+
+		public void WriteImage ()
+		{
+			WriteDOSHeader ();
+			WritePEFileHeader ();
+			WriteOptionalHeaders ();
+			WriteSectionHeaders ();
+			WriteText ();
+			if (rsrc != null)
+				WriteRsrc ();
+			if (reloc != null)
+				WriteReloc ();
+			Flush ();
+		}
+
+		void BuildTextMap ()
+		{
+			var map = text_map;
+
+			map.AddMap (TextSegment.Code, metadata.code.length, !pe64 ? 4 : 16);
+			map.AddMap (TextSegment.Resources, metadata.resources.length, 8);
+			map.AddMap (TextSegment.Data, metadata.data.length, 4);
+			if (metadata.data.length > 0)
+				metadata.table_heap.FixupData (map.GetRVA (TextSegment.Data));
+			map.AddMap (TextSegment.StrongNameSignature, GetStrongNameLength (), 4);
+
+			BuildMetadataTextMap ();
+
+			int debug_dir_len = 0;
+			if (debug_header != null && debug_header.HasEntries) {
+				var directories_len = debug_header.Entries.Length * ImageDebugDirectory.Size;
+				var data_address = (int) map.GetNextRVA (TextSegment.BlobHeap) + directories_len;
+				var data_len = 0;
+
+				for (var i = 0; i < debug_header.Entries.Length; i++) {
+					var entry = debug_header.Entries [i];
+					var directory = entry.Directory;
+					
+					directory.AddressOfRawData = entry.Data.Length == 0 ? 0 : data_address;
+					entry.Directory = directory;
+
+					data_len += entry.Data.Length;
+					data_address += data_len;
+				}
+
+				debug_dir_len = directories_len + data_len;
+			}
+
+			map.AddMap (TextSegment.DebugDirectory, debug_dir_len, 4);
+
+			if (!has_reloc) {
+				var start = map.GetNextRVA (TextSegment.DebugDirectory);
+				map.AddMap (TextSegment.ImportDirectory, new Range (start, 0));
+				map.AddMap (TextSegment.ImportHintNameTable, new Range (start, 0));
+				map.AddMap (TextSegment.StartupStub, new Range (start, 0));
+				return;
+			}
+
+			RVA import_dir_rva = map.GetNextRVA (TextSegment.DebugDirectory);
+			RVA import_hnt_rva = import_dir_rva + 48u;
+			import_hnt_rva = (import_hnt_rva + 15u) & ~15u;
+			uint import_dir_len = (import_hnt_rva - import_dir_rva) + 27u;
+
+			RVA startup_stub_rva = import_dir_rva + import_dir_len;
+			startup_stub_rva = module.Architecture == TargetArchitecture.IA64
+				? (startup_stub_rva + 15u) & ~15u
+				: 2 + ((startup_stub_rva + 3u) & ~3u);
+
+			map.AddMap (TextSegment.ImportDirectory, new Range (import_dir_rva, import_dir_len));
+			map.AddMap (TextSegment.ImportHintNameTable, new Range (import_hnt_rva, 0));
+			map.AddMap (TextSegment.StartupStub, new Range (startup_stub_rva, GetStartupStubLength ()));
+		}
+
+		public void BuildMetadataTextMap ()
+		{
+			var map = text_map;
+
+			map.AddMap (TextSegment.MetadataHeader, GetMetadataHeaderLength (module.RuntimeVersion));
+			map.AddMap (TextSegment.TableHeap, metadata.table_heap.length, 4);
+			map.AddMap (TextSegment.StringHeap, metadata.string_heap.length, 4);
+			map.AddMap (TextSegment.UserStringHeap, metadata.user_string_heap.IsEmpty ? 0 : metadata.user_string_heap.length, 4);
+			map.AddMap (TextSegment.GuidHeap, metadata.guid_heap.length, 4);
+			map.AddMap (TextSegment.BlobHeap, metadata.blob_heap.IsEmpty ? 0 : metadata.blob_heap.length, 4);
+			map.AddMap (TextSegment.PdbHeap, metadata.pdb_heap == null ? 0 : metadata.pdb_heap.length, 4);
+		}
+
+		uint GetStartupStubLength ()
+		{
+			switch (module.Architecture) {
+			case TargetArchitecture.I386:
+				return 6;
+			default:
+				throw new NotSupportedException ();
+			}
+		}
+
+		int GetMetadataHeaderLength (string runtimeVersion)
+		{
+			return
+				// MetadataHeader
+				20 + GetZeroTerminatedStringLength (runtimeVersion)
+				// #~ header
+				+ 12
+				// #Strings header
+				+ 20
+				// #US header
+				+ (metadata.user_string_heap.IsEmpty ? 0 : 12)
+				// #GUID header
+				+ 16
+				// #Blob header
+				+ (metadata.blob_heap.IsEmpty ? 0 : 16)
+				//
+				+ (metadata.pdb_heap == null ? 0 : 16);
+		}
+
+		int GetStrongNameLength ()
+		{
+			if (module.Assembly == null)
+				return 0;
+
+			var public_key = module.Assembly.Name.PublicKey;
+			if (public_key.IsNullOrEmpty ())
+				return 0;
+
+			// in fx 2.0 the key may be from 384 to 16384 bits
+			// so we must calculate the signature size based on
+			// the size of the public key (minus the 32 byte header)
+			int size = public_key.Length;
+			if (size > 32)
+				return size - 32;
+
+			// note: size == 16 for the ECMA "key" which is replaced
+			// by the runtime with a 1024 bits key (128 bytes)
+
+			return 128; // default strongname signature size
+		}
+
+		public DataDirectory GetStrongNameSignatureDirectory ()
+		{
+			return text_map.GetDataDirectory (TextSegment.StrongNameSignature);
+		}
+
+		public uint GetHeaderSize ()
+		{
+			return pe_header_size + SizeOfOptionalHeader () + (sections * section_header_size);
+		}
+
+		void PatchWin32Resources (ByteBuffer resources)
+		{
+			PatchResourceDirectoryTable (resources);
+		}
+
+		void PatchResourceDirectoryTable (ByteBuffer resources)
+		{
+			resources.Advance (12);
+
+			var entries = resources.ReadUInt16 () + resources.ReadUInt16 ();
+
+			for (int i = 0; i < entries; i++)
+				PatchResourceDirectoryEntry (resources);
+		}
+
+		void PatchResourceDirectoryEntry (ByteBuffer resources)
+		{
+			resources.Advance (4);
+			var child = resources.ReadUInt32 ();
+
+			var position = resources.position;
+			resources.position = (int) child & 0x7fffffff;
+
+			if ((child & 0x80000000) != 0)
+				PatchResourceDirectoryTable (resources);
+			else
+				PatchResourceDataEntry (resources);
+
+			resources.position = position;
+		}
+
+		void PatchResourceDataEntry (ByteBuffer resources)
+		{
+			var rva = resources.ReadUInt32 ();
+			resources.position -= 4;
+
+			resources.WriteUInt32 (rva - module.Image.Win32Resources.VirtualAddress + rsrc.VirtualAddress);
+		}
+	}
+}
+
+#endif
diff --git a/src/Mono/Cecil/PE/Section.cs b/src/Mono/Cecil/PE/Section.cs
new file mode 100644
index 00000000..49d8e900
--- /dev/null
+++ b/src/Mono/Cecil/PE/Section.cs
@@ -0,0 +1,24 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil.PE {
+
+	sealed class Section {
+		public string Name;
+		public RVA VirtualAddress;
+		public uint VirtualSize;
+		public uint SizeOfRawData;
+		public uint PointerToRawData;
+	}
+}
diff --git a/src/Mono/Cecil/PE/TextMap.cs b/src/Mono/Cecil/PE/TextMap.cs
new file mode 100644
index 00000000..614691b6
--- /dev/null
+++ b/src/Mono/Cecil/PE/TextMap.cs
@@ -0,0 +1,112 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+#if !READ_ONLY
+
+using RVA = System.UInt32;
+
+namespace Mono.Cecil.PE {
+
+	enum TextSegment {
+		ImportAddressTable,
+		CLIHeader,
+		Code,
+		Resources,
+		Data,
+		StrongNameSignature,
+
+		// Metadata
+		MetadataHeader,
+		TableHeap,
+		StringHeap,
+		UserStringHeap,
+		GuidHeap,
+		BlobHeap,
+		PdbHeap,
+		// End Metadata
+
+		DebugDirectory,
+		ImportDirectory,
+		ImportHintNameTable,
+		StartupStub,
+	}
+
+	sealed class TextMap {
+
+		readonly Range [] map = new Range [17 /*Enum.GetValues (typeof (TextSegment)).Length*/];
+
+		public void AddMap (TextSegment segment, int length)
+		{
+			map [(int) segment] = new Range (GetStart (segment), (uint) length);
+		}
+
+		public void AddMap (TextSegment segment, int length, int align)
+		{
+			align--;
+
+			AddMap (segment, (length + align) & ~align);
+		}
+
+		public void AddMap (TextSegment segment, Range range)
+		{
+			map [(int) segment] = range;
+		}
+
+		public Range GetRange (TextSegment segment)
+		{
+			return map [(int) segment];
+		}
+
+		public DataDirectory GetDataDirectory (TextSegment segment)
+		{
+			var range = map [(int) segment];
+
+			return new DataDirectory (range.Length == 0 ? 0 : range.Start, range.Length);
+		}
+
+		public RVA GetRVA (TextSegment segment)
+		{
+			return map [(int) segment].Start;
+		}
+
+		public RVA GetNextRVA (TextSegment segment)
+		{
+			var i = (int) segment;
+			return map [i].Start + map [i].Length;
+		}
+
+		public int GetLength (TextSegment segment)
+		{
+			return (int) map [(int) segment].Length;
+		}
+
+		RVA GetStart (TextSegment segment)
+		{
+			var index = (int) segment;
+			return index == 0 ? ImageWriter.text_rva : ComputeStart (index);
+		}
+
+		RVA ComputeStart (int index)
+		{
+			index--;
+			return map [index].Start + map [index].Length;
+		}
+
+		public uint GetLength ()
+		{
+			var range = map [(int) TextSegment.StartupStub];
+			return range.Start - ImageWriter.text_rva + range.Length;
+		}
+	}
+}
+
+#endif
diff --git a/src/Mono/Cecil/PInvokeAttributes.cs b/src/Mono/Cecil/PInvokeAttributes.cs
new file mode 100644
index 00000000..11e96d20
--- /dev/null
+++ b/src/Mono/Cecil/PInvokeAttributes.cs
@@ -0,0 +1,44 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum PInvokeAttributes : ushort {
+		NoMangle			= 0x0001,	// PInvoke is to use the member name as specified
+
+		// Character set
+		CharSetMask			= 0x0006,
+		CharSetNotSpec		= 0x0000,
+		CharSetAnsi			= 0x0002,
+		CharSetUnicode		= 0x0004,
+		CharSetAuto			= 0x0006,
+
+		SupportsLastError	= 0x0040,	// Information about target function. Not relevant for fields
+
+		// Calling convetion
+		CallConvMask		= 0x0700,
+		CallConvWinapi		= 0x0100,
+		CallConvCdecl		= 0x0200,
+		CallConvStdCall		= 0x0300,
+		CallConvThiscall	= 0x0400,
+		CallConvFastcall	= 0x0500,
+
+		BestFitMask			= 0x0030,
+		BestFitEnabled		= 0x0010,
+		BestFitDisabled		= 0x0020,
+
+		ThrowOnUnmappableCharMask = 0x3000,
+		ThrowOnUnmappableCharEnabled = 0x1000,
+		ThrowOnUnmappableCharDisabled = 0x2000,
+	}
+}
diff --git a/src/Mono/Cecil/PInvokeInfo.cs b/src/Mono/Cecil/PInvokeInfo.cs
new file mode 100644
index 00000000..8efc0108
--- /dev/null
+++ b/src/Mono/Cecil/PInvokeInfo.cs
@@ -0,0 +1,120 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public sealed class PInvokeInfo {
+
+		ushort attributes;
+		string entry_point;
+		ModuleReference module;
+
+		public PInvokeAttributes Attributes {
+			get { return (PInvokeAttributes) attributes; }
+			set { attributes = (ushort) value; }
+		}
+
+		public string EntryPoint {
+			get { return entry_point; }
+			set { entry_point = value; }
+		}
+
+		public ModuleReference Module {
+			get { return module; }
+			set { module = value; }
+		}
+
+		#region PInvokeAttributes
+
+		public bool IsNoMangle {
+			get { return attributes.GetAttributes ((ushort) PInvokeAttributes.NoMangle); }
+			set { attributes = attributes.SetAttributes ((ushort) PInvokeAttributes.NoMangle, value); }
+		}
+
+		public bool IsCharSetNotSpec {
+			get { return attributes.GetMaskedAttributes((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetNotSpec); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetNotSpec, value); }
+		}
+
+		public bool IsCharSetAnsi {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetAnsi); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetAnsi, value); }
+		}
+
+		public bool IsCharSetUnicode {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetUnicode); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetUnicode, value); }
+		}
+
+		public bool IsCharSetAuto {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetAuto); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CharSetMask, (ushort) PInvokeAttributes.CharSetAuto, value); }
+		}
+
+		public bool SupportsLastError {
+			get { return attributes.GetAttributes ((ushort) PInvokeAttributes.SupportsLastError); }
+			set { attributes = attributes.SetAttributes ((ushort) PInvokeAttributes.SupportsLastError, value); }
+		}
+
+		public bool IsCallConvWinapi {
+			get { return attributes.GetMaskedAttributes((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvWinapi); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvWinapi, value); }
+		}
+
+		public bool IsCallConvCdecl {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvCdecl); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvCdecl, value); }
+		}
+
+		public bool IsCallConvStdCall {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvStdCall); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvStdCall, value); }
+		}
+
+		public bool IsCallConvThiscall {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvThiscall); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvThiscall, value); }
+		}
+
+		public bool IsCallConvFastcall {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvFastcall); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.CallConvMask, (ushort) PInvokeAttributes.CallConvFastcall, value); }
+		}
+
+		public bool IsBestFitEnabled {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.BestFitMask, (ushort) PInvokeAttributes.BestFitEnabled); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.BestFitMask, (ushort) PInvokeAttributes.BestFitEnabled, value); }
+		}
+
+		public bool IsBestFitDisabled {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.BestFitMask, (ushort) PInvokeAttributes.BestFitDisabled); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.BestFitMask, (ushort) PInvokeAttributes.BestFitDisabled, value); }
+		}
+
+		public bool IsThrowOnUnmappableCharEnabled {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.ThrowOnUnmappableCharMask, (ushort) PInvokeAttributes.ThrowOnUnmappableCharEnabled); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.ThrowOnUnmappableCharMask, (ushort) PInvokeAttributes.ThrowOnUnmappableCharEnabled, value); }
+		}
+
+		public bool IsThrowOnUnmappableCharDisabled {
+			get { return attributes.GetMaskedAttributes ((ushort) PInvokeAttributes.ThrowOnUnmappableCharMask, (ushort) PInvokeAttributes.ThrowOnUnmappableCharDisabled); }
+			set { attributes = attributes.SetMaskedAttributes ((ushort) PInvokeAttributes.ThrowOnUnmappableCharMask, (ushort) PInvokeAttributes.ThrowOnUnmappableCharDisabled, value); }
+		}
+
+		#endregion
+
+		public PInvokeInfo (PInvokeAttributes attributes, string entryPoint, ModuleReference module)
+		{
+			this.attributes = (ushort) attributes;
+			this.entry_point = entryPoint;
+			this.module = module;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/ParameterAttributes.cs b/src/Mono/Cecil/ParameterAttributes.cs
new file mode 100644
index 00000000..9a0e35e0
--- /dev/null
+++ b/src/Mono/Cecil/ParameterAttributes.cs
@@ -0,0 +1,27 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum ParameterAttributes : ushort {
+		None				= 0x0000,
+		In					= 0x0001,	// Param is [In]
+		Out					= 0x0002,	// Param is [Out]
+		Lcid				= 0x0004,
+		Retval				= 0x0008,
+		Optional			= 0x0010,	// Param is optional
+		HasDefault			= 0x1000,	// Param has default value
+		HasFieldMarshal		= 0x2000,	// Param has field marshal
+		Unused				= 0xcfe0	 // Reserved: shall be zero in a conforming implementation
+	}
+}
diff --git a/src/Mono/Cecil/ParameterDefinition.cs b/src/Mono/Cecil/ParameterDefinition.cs
new file mode 100644
index 00000000..59bafe2c
--- /dev/null
+++ b/src/Mono/Cecil/ParameterDefinition.cs
@@ -0,0 +1,146 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class ParameterDefinition : ParameterReference, ICustomAttributeProvider, IConstantProvider, IMarshalInfoProvider {
+
+		ushort attributes;
+
+		internal IMethodSignature method;
+
+		object constant = Mixin.NotResolved;
+		Collection<CustomAttribute> custom_attributes;
+		MarshalInfo marshal_info;
+
+		public ParameterAttributes Attributes {
+			get { return (ParameterAttributes) attributes; }
+			set { attributes = (ushort) value; }
+		}
+
+		public IMethodSignature Method {
+			get { return method; }
+		}
+
+		public int Sequence {
+			get {
+				if (method == null)
+					return -1;
+
+				return method.HasImplicitThis () ? index + 1 : index;
+			}
+		}
+
+		public bool HasConstant {
+			get {
+				this.ResolveConstant (ref constant, parameter_type.Module);
+
+				return constant != Mixin.NoValue;
+			}
+			set { if (!value) constant = Mixin.NoValue; }
+		}
+
+		public object Constant {
+			get { return HasConstant ? constant : null;	}
+			set { constant = value; }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (parameter_type.Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, parameter_type.Module)); }
+		}
+
+		public bool HasMarshalInfo {
+			get {
+				if (marshal_info != null)
+					return true;
+
+				return this.GetHasMarshalInfo (parameter_type.Module);
+			}
+		}
+
+		public MarshalInfo MarshalInfo {
+			get { return marshal_info ?? (this.GetMarshalInfo (ref marshal_info, parameter_type.Module)); }
+			set { marshal_info = value; }
+		}
+
+		#region ParameterAttributes
+
+		public bool IsIn {
+			get { return attributes.GetAttributes ((ushort) ParameterAttributes.In); }
+			set { attributes = attributes.SetAttributes ((ushort) ParameterAttributes.In, value); }
+		}
+
+		public bool IsOut {
+			get { return attributes.GetAttributes ((ushort) ParameterAttributes.Out); }
+			set { attributes = attributes.SetAttributes ((ushort) ParameterAttributes.Out, value); }
+		}
+
+		public bool IsLcid {
+			get { return attributes.GetAttributes ((ushort) ParameterAttributes.Lcid); }
+			set { attributes = attributes.SetAttributes ((ushort) ParameterAttributes.Lcid, value); }
+		}
+
+		public bool IsReturnValue {
+			get { return attributes.GetAttributes ((ushort) ParameterAttributes.Retval); }
+			set { attributes = attributes.SetAttributes ((ushort) ParameterAttributes.Retval, value); }
+		}
+
+		public bool IsOptional {
+			get { return attributes.GetAttributes ((ushort) ParameterAttributes.Optional); }
+			set { attributes = attributes.SetAttributes ((ushort) ParameterAttributes.Optional, value); }
+		}
+
+		public bool HasDefault {
+			get { return attributes.GetAttributes ((ushort) ParameterAttributes.HasDefault); }
+			set { attributes = attributes.SetAttributes ((ushort) ParameterAttributes.HasDefault, value); }
+		}
+
+		public bool HasFieldMarshal {
+			get { return attributes.GetAttributes ((ushort) ParameterAttributes.HasFieldMarshal); }
+			set { attributes = attributes.SetAttributes ((ushort) ParameterAttributes.HasFieldMarshal, value); }
+		}
+
+		#endregion
+
+		internal ParameterDefinition (TypeReference parameterType, IMethodSignature method)
+			: this (string.Empty, ParameterAttributes.None, parameterType)
+		{
+			this.method = method;
+		}
+
+		public ParameterDefinition (TypeReference parameterType)
+			: this (string.Empty, ParameterAttributes.None, parameterType)
+		{
+		}
+
+		public ParameterDefinition (string name, ParameterAttributes attributes, TypeReference parameterType)
+			: base (name, parameterType)
+		{
+			this.attributes = (ushort) attributes;
+			this.token = new MetadataToken (TokenType.Param);
+		}
+
+		public override ParameterDefinition Resolve ()
+		{
+			return this;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/ParameterDefinitionCollection.cs b/src/Mono/Cecil/ParameterDefinitionCollection.cs
new file mode 100644
index 00000000..1a9764c5
--- /dev/null
+++ b/src/Mono/Cecil/ParameterDefinitionCollection.cs
@@ -0,0 +1,62 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	sealed class ParameterDefinitionCollection : Collection<ParameterDefinition> {
+
+		readonly IMethodSignature method;
+
+		internal ParameterDefinitionCollection (IMethodSignature method)
+		{
+			this.method = method;
+		}
+
+		internal ParameterDefinitionCollection (IMethodSignature method, int capacity)
+			: base (capacity)
+		{
+			this.method = method;
+		}
+
+		protected override void OnAdd (ParameterDefinition item, int index)
+		{
+			item.method = method;
+			item.index = index;
+		}
+
+		protected override void OnInsert (ParameterDefinition item, int index)
+		{
+			item.method = method;
+			item.index = index;
+
+			for (int i = index; i < size; i++)
+				items [i].index = i + 1;
+		}
+
+		protected override void OnSet (ParameterDefinition item, int index)
+		{
+			item.method = method;
+			item.index = index;
+		}
+
+		protected override void OnRemove (ParameterDefinition item, int index)
+		{
+			item.method = null;
+			item.index = -1;
+
+			for (int i = index + 1; i < size; i++)
+				items [i].index = i - 1;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/ParameterReference.cs b/src/Mono/Cecil/ParameterReference.cs
new file mode 100644
index 00000000..4670a562
--- /dev/null
+++ b/src/Mono/Cecil/ParameterReference.cs
@@ -0,0 +1,57 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	public abstract class ParameterReference : IMetadataTokenProvider {
+
+		string name;
+		internal int index = -1;
+		protected TypeReference parameter_type;
+		internal MetadataToken token;
+
+		public string Name {
+			get { return name; }
+			set { name = value; }
+		}
+
+		public int Index {
+			get { return index; }
+		}
+
+		public TypeReference ParameterType {
+			get { return parameter_type; }
+			set { parameter_type = value; }
+		}
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		internal ParameterReference (string name, TypeReference parameterType)
+		{
+			if (parameterType == null)
+				throw new ArgumentNullException ("parameterType");
+
+			this.name = name ?? string.Empty;
+			this.parameter_type = parameterType;
+		}
+
+		public override string ToString ()
+		{
+			return name;
+		}
+
+		public abstract ParameterDefinition Resolve ();
+	}
+}
diff --git a/src/Mono/Cecil/PinnedType.cs b/src/Mono/Cecil/PinnedType.cs
new file mode 100644
index 00000000..fa89af51
--- /dev/null
+++ b/src/Mono/Cecil/PinnedType.cs
@@ -0,0 +1,35 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public sealed class PinnedType : TypeSpecification {
+
+		public override bool IsValueType {
+			get { return false; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool IsPinned {
+			get { return true; }
+		}
+
+		public PinnedType (TypeReference type)
+			: base (type)
+		{
+			Mixin.CheckType (type);
+			this.etype = MD.ElementType.Pinned;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/PointerType.cs b/src/Mono/Cecil/PointerType.cs
new file mode 100644
index 00000000..4b21164a
--- /dev/null
+++ b/src/Mono/Cecil/PointerType.cs
@@ -0,0 +1,43 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public sealed class PointerType : TypeSpecification {
+
+		public override string Name {
+			get { return base.Name + "*"; }
+		}
+
+		public override string FullName {
+			get { return base.FullName + "*"; }
+		}
+
+		public override bool IsValueType {
+			get { return false; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool IsPointer {
+			get { return true; }
+		}
+
+		public PointerType (TypeReference type)
+			: base (type)
+		{
+			Mixin.CheckType (type);
+			this.etype = MD.ElementType.Ptr;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/PropertyAttributes.cs b/src/Mono/Cecil/PropertyAttributes.cs
new file mode 100644
index 00000000..4d1ce8c8
--- /dev/null
+++ b/src/Mono/Cecil/PropertyAttributes.cs
@@ -0,0 +1,23 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum PropertyAttributes : ushort {
+		None			= 0x0000,
+		SpecialName		= 0x0200,	// Property is special
+		RTSpecialName	= 0x0400,	// Runtime(metadata internal APIs) should check name encoding
+		HasDefault		= 0x1000,	// Property has default
+		Unused			= 0xe9ff	 // Reserved: shall be zero in a conforming implementation
+	}
+}
diff --git a/src/Mono/Cecil/PropertyDefinition.cs b/src/Mono/Cecil/PropertyDefinition.cs
new file mode 100644
index 00000000..87f29475
--- /dev/null
+++ b/src/Mono/Cecil/PropertyDefinition.cs
@@ -0,0 +1,244 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System.Text;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class PropertyDefinition : PropertyReference, IMemberDefinition, IConstantProvider {
+
+		bool? has_this;
+		ushort attributes;
+
+		Collection<CustomAttribute> custom_attributes;
+
+		internal MethodDefinition get_method;
+		internal MethodDefinition set_method;
+		internal Collection<MethodDefinition> other_methods;
+
+		object constant = Mixin.NotResolved;
+
+		public PropertyAttributes Attributes {
+			get { return (PropertyAttributes) attributes; }
+			set { attributes = (ushort) value; }
+		}
+
+		public bool HasThis {
+			get {
+				if (has_this.HasValue)
+					return has_this.Value;
+
+				if (GetMethod != null)
+					return get_method.HasThis;
+
+				if (SetMethod != null)
+					return set_method.HasThis;
+
+				return false;
+			}
+			set { has_this = value; }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, Module)); }
+		}
+
+		public MethodDefinition GetMethod {
+			get {
+				if (get_method != null)
+					return get_method;
+
+				InitializeMethods ();
+				return get_method;
+			}
+			set { get_method = value; }
+		}
+
+		public MethodDefinition SetMethod {
+			get {
+				if (set_method != null)
+					return set_method;
+
+				InitializeMethods ();
+				return set_method;
+			}
+			set { set_method = value; }
+		}
+
+		public bool HasOtherMethods {
+			get {
+				if (other_methods != null)
+					return other_methods.Count > 0;
+
+				InitializeMethods ();
+				return !other_methods.IsNullOrEmpty ();
+			}
+		}
+
+		public Collection<MethodDefinition> OtherMethods {
+			get {
+				if (other_methods != null)
+					return other_methods;
+
+				InitializeMethods ();
+
+				if (other_methods != null)
+					return other_methods;
+
+				return other_methods = new Collection<MethodDefinition> ();
+			}
+		}
+
+		public bool HasParameters {
+			get {
+				InitializeMethods ();
+
+				if (get_method != null)
+					return get_method.HasParameters;
+
+				if (set_method != null)
+					return set_method.HasParameters && set_method.Parameters.Count > 1;
+
+				return false;
+			}
+		}
+
+		public override Collection<ParameterDefinition> Parameters {
+			get {
+				InitializeMethods ();
+
+				if (get_method != null)
+					return MirrorParameters (get_method, 0);
+
+				if (set_method != null)
+					return MirrorParameters (set_method, 1);
+
+				return new Collection<ParameterDefinition> ();
+			}
+		}
+
+		static Collection<ParameterDefinition> MirrorParameters (MethodDefinition method, int bound)
+		{
+			var parameters = new Collection<ParameterDefinition> ();
+			if (!method.HasParameters)
+				return parameters;
+
+			var original_parameters = method.Parameters;
+			var end = original_parameters.Count - bound;
+
+			for (int i = 0; i < end; i++)
+				parameters.Add (original_parameters [i]);
+
+			return parameters;
+		}
+
+		public bool HasConstant {
+			get {
+				this.ResolveConstant (ref constant, Module);
+
+				return constant != Mixin.NoValue;
+			}
+			set { if (!value) constant = Mixin.NoValue; }
+		}
+
+		public object Constant {
+			get { return HasConstant ? constant : null;	}
+			set { constant = value; }
+		}
+
+		#region PropertyAttributes
+
+		public bool IsSpecialName {
+			get { return attributes.GetAttributes ((ushort) PropertyAttributes.SpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) PropertyAttributes.SpecialName, value); }
+		}
+
+		public bool IsRuntimeSpecialName {
+			get { return attributes.GetAttributes ((ushort) PropertyAttributes.RTSpecialName); }
+			set { attributes = attributes.SetAttributes ((ushort) PropertyAttributes.RTSpecialName, value); }
+		}
+
+		public bool HasDefault {
+			get { return attributes.GetAttributes ((ushort) PropertyAttributes.HasDefault); }
+			set { attributes = attributes.SetAttributes ((ushort) PropertyAttributes.HasDefault, value); }
+		}
+
+		#endregion
+
+		public new TypeDefinition DeclaringType {
+			get { return (TypeDefinition) base.DeclaringType; }
+			set { base.DeclaringType = value; }
+		}
+
+		public override bool IsDefinition {
+			get { return true; }
+		}
+
+		public override string FullName {
+			get {
+				var builder = new StringBuilder ();
+				builder.Append (PropertyType.ToString ());
+				builder.Append (' ');
+				builder.Append (MemberFullName ());
+				builder.Append ('(');
+				if (HasParameters) {
+					var parameters = Parameters;
+					for (int i = 0; i < parameters.Count; i++) {
+						if (i > 0)
+							builder.Append (',');
+						builder.Append (parameters [i].ParameterType.FullName);
+					}
+				}
+				builder.Append (')');
+				return builder.ToString ();
+			}
+		}
+
+		public PropertyDefinition (string name, PropertyAttributes attributes, TypeReference propertyType)
+			: base (name, propertyType)
+		{
+			this.attributes = (ushort) attributes;
+			this.token = new MetadataToken (TokenType.Property);
+		}
+
+		void InitializeMethods ()
+		{
+			var module = this.Module;
+			if (module == null)
+				return;
+
+			lock (module.SyncRoot) {
+				if (get_method != null || set_method != null)
+					return;
+
+				if (!module.HasImage ())
+					return;
+
+				module.Read (this, (property, reader) => reader.ReadMethods (property));
+			}
+		}
+
+		public override PropertyDefinition Resolve ()
+		{
+			return this;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/PropertyReference.cs b/src/Mono/Cecil/PropertyReference.cs
new file mode 100644
index 00000000..2434d0f8
--- /dev/null
+++ b/src/Mono/Cecil/PropertyReference.cs
@@ -0,0 +1,45 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public abstract class PropertyReference : MemberReference {
+
+		TypeReference property_type;
+
+		public TypeReference PropertyType {
+			get { return property_type; }
+			set { property_type = value; }
+		}
+
+		public abstract Collection<ParameterDefinition> Parameters {
+			get;
+		}
+
+		internal PropertyReference (string name, TypeReference propertyType)
+			: base (name)
+		{
+			Mixin.CheckType (propertyType, Mixin.Argument.propertyType);
+
+			property_type = propertyType;
+		}
+
+		protected override IMemberDefinition ResolveDefinition ()
+		{
+			return this.Resolve ();
+		}
+
+		public new abstract PropertyDefinition Resolve ();
+	}
+}
diff --git a/src/Mono/Cecil/ReferenceType.cs b/src/Mono/Cecil/ReferenceType.cs
new file mode 100644
index 00000000..67686fbf
--- /dev/null
+++ b/src/Mono/Cecil/ReferenceType.cs
@@ -0,0 +1,43 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public sealed class ByReferenceType : TypeSpecification {
+
+		public override string Name {
+			get { return base.Name + "&"; }
+		}
+
+		public override string FullName {
+			get { return base.FullName + "&"; }
+		}
+
+		public override bool IsValueType {
+			get { return false; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool IsByReference {
+			get { return true; }
+		}
+
+		public ByReferenceType (TypeReference type)
+			: base (type)
+		{
+			Mixin.CheckType (type);
+			this.etype = MD.ElementType.ByRef;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/Resource.cs b/src/Mono/Cecil/Resource.cs
new file mode 100644
index 00000000..cee75f9e
--- /dev/null
+++ b/src/Mono/Cecil/Resource.cs
@@ -0,0 +1,58 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum ResourceType {
+		Linked,
+		Embedded,
+		AssemblyLinked,
+	}
+
+	public abstract class Resource {
+
+		string name;
+		uint attributes;
+
+		public string Name {
+			get { return name; }
+			set { name = value; }
+		}
+
+		public ManifestResourceAttributes Attributes {
+			get { return (ManifestResourceAttributes) attributes; }
+			set { attributes = (uint) value; }
+		}
+
+		public abstract ResourceType ResourceType {
+			get;
+		}
+
+		#region ManifestResourceAttributes
+
+		public bool IsPublic {
+			get { return attributes.GetMaskedAttributes ((uint) ManifestResourceAttributes.VisibilityMask, (uint) ManifestResourceAttributes.Public); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) ManifestResourceAttributes.VisibilityMask, (uint) ManifestResourceAttributes.Public, value); }
+		}
+
+		public bool IsPrivate {
+			get { return attributes.GetMaskedAttributes ((uint) ManifestResourceAttributes.VisibilityMask, (uint) ManifestResourceAttributes.Private); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) ManifestResourceAttributes.VisibilityMask, (uint) ManifestResourceAttributes.Private, value); }
+		}
+
+		#endregion
+
+		internal Resource (string name, ManifestResourceAttributes attributes)
+		{
+			this.name = name;
+			this.attributes = (uint) attributes;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/SecurityDeclaration.cs b/src/Mono/Cecil/SecurityDeclaration.cs
new file mode 100644
index 00000000..a18d14f2
--- /dev/null
+++ b/src/Mono/Cecil/SecurityDeclaration.cs
@@ -0,0 +1,179 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Diagnostics;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public enum SecurityAction : ushort {
+		Request = 1,
+		Demand = 2,
+		Assert = 3,
+		Deny = 4,
+		PermitOnly = 5,
+		LinkDemand = 6,
+		InheritDemand = 7,
+		RequestMinimum = 8,
+		RequestOptional = 9,
+		RequestRefuse = 10,
+		PreJitGrant = 11,
+		PreJitDeny = 12,
+		NonCasDemand = 13,
+		NonCasLinkDemand = 14,
+		NonCasInheritance = 15
+	}
+
+	public interface ISecurityDeclarationProvider : IMetadataTokenProvider {
+
+		bool HasSecurityDeclarations { get; }
+		Collection<SecurityDeclaration> SecurityDeclarations { get; }
+	}
+
+	[DebuggerDisplay ("{AttributeType}")]
+	public sealed class SecurityAttribute : ICustomAttribute {
+
+		TypeReference attribute_type;
+
+		internal Collection<CustomAttributeNamedArgument> fields;
+		internal Collection<CustomAttributeNamedArgument> properties;
+
+		public TypeReference AttributeType {
+			get { return attribute_type; }
+			set { attribute_type = value; }
+		}
+
+		public bool HasFields {
+			get { return !fields.IsNullOrEmpty (); }
+		}
+
+		public Collection<CustomAttributeNamedArgument> Fields {
+			get { return fields ?? (fields = new Collection<CustomAttributeNamedArgument> ()); }
+		}
+
+		public bool HasProperties {
+			get { return !properties.IsNullOrEmpty (); }
+		}
+
+		public Collection<CustomAttributeNamedArgument> Properties {
+			get { return properties ?? (properties = new Collection<CustomAttributeNamedArgument> ()); }
+		}
+
+		public SecurityAttribute (TypeReference attributeType)
+		{
+			this.attribute_type = attributeType;
+		}
+
+		bool ICustomAttribute.HasConstructorArguments {
+			get { return false; }
+		}
+
+		Collection<CustomAttributeArgument> ICustomAttribute.ConstructorArguments {
+			get { throw new NotSupportedException (); }
+		}
+	}
+
+	public sealed class SecurityDeclaration {
+
+		readonly internal uint signature;
+		byte [] blob;
+		readonly ModuleDefinition module;
+
+		internal bool resolved;
+		SecurityAction action;
+		internal Collection<SecurityAttribute> security_attributes;
+
+		public SecurityAction Action {
+			get { return action; }
+			set { action = value; }
+		}
+
+		public bool HasSecurityAttributes {
+			get {
+				Resolve ();
+
+				return !security_attributes.IsNullOrEmpty ();
+			}
+		}
+
+		public Collection<SecurityAttribute> SecurityAttributes {
+			get {
+				Resolve ();
+
+				return security_attributes ?? (security_attributes = new Collection<SecurityAttribute> ());
+			}
+		}
+
+		internal bool HasImage {
+			get { return module != null && module.HasImage; }
+		}
+
+		internal SecurityDeclaration (SecurityAction action, uint signature, ModuleDefinition module)
+		{
+			this.action = action;
+			this.signature = signature;
+			this.module = module;
+		}
+
+		public SecurityDeclaration (SecurityAction action)
+		{
+			this.action = action;
+			this.resolved = true;
+		}
+
+		public SecurityDeclaration (SecurityAction action, byte [] blob)
+		{
+			this.action = action;
+			this.resolved = false;
+			this.blob = blob;
+		}
+
+		public byte [] GetBlob ()
+		{
+			if (blob != null)
+				return blob;
+
+			if (!HasImage || signature == 0)
+				throw new NotSupportedException ();
+
+			return blob = module.Read (this, (declaration, reader) => reader.ReadSecurityDeclarationBlob (declaration.signature));
+		}
+
+		void Resolve ()
+		{
+			if (resolved || !HasImage)
+				return;
+
+			module.Read (this, (declaration, reader) => reader.ReadSecurityDeclarationSignature (declaration));
+			resolved = true;
+		}
+	}
+
+	static partial class Mixin {
+
+		public static bool GetHasSecurityDeclarations (
+			this ISecurityDeclarationProvider self,
+			ModuleDefinition module)
+		{
+			return module.HasImage () && module.Read (self, (provider, reader) => reader.HasSecurityDeclarations (provider));
+		}
+
+		public static Collection<SecurityDeclaration> GetSecurityDeclarations (
+			this ISecurityDeclarationProvider self,
+			ref Collection<SecurityDeclaration> variable,
+			ModuleDefinition module)
+		{
+			return module.HasImage ()
+				? module.Read (ref variable, self, (provider, reader) => reader.ReadSecurityDeclarations (provider))
+				: variable = new Collection<SecurityDeclaration>();
+		}
+	}
+}
diff --git a/src/Mono/Cecil/SentinelType.cs b/src/Mono/Cecil/SentinelType.cs
new file mode 100644
index 00000000..b603cc3c
--- /dev/null
+++ b/src/Mono/Cecil/SentinelType.cs
@@ -0,0 +1,35 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using MD = Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public sealed class SentinelType : TypeSpecification {
+
+		public override bool IsValueType {
+			get { return false; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override bool IsSentinel {
+			get { return true; }
+		}
+
+		public SentinelType (TypeReference type)
+			: base (type)
+		{
+			Mixin.CheckType (type);
+			this.etype = MD.ElementType.Sentinel;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/TargetRuntime.cs b/src/Mono/Cecil/TargetRuntime.cs
new file mode 100644
index 00000000..c1cd0269
--- /dev/null
+++ b/src/Mono/Cecil/TargetRuntime.cs
@@ -0,0 +1,19 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum TargetRuntime {
+		Net_1_0,
+		Net_1_1,
+		Net_2_0,
+		Net_4_0,
+	}
+}
diff --git a/src/Mono/Cecil/Treatments.cs b/src/Mono/Cecil/Treatments.cs
new file mode 100644
index 00000000..4ceaebf7
--- /dev/null
+++ b/src/Mono/Cecil/Treatments.cs
@@ -0,0 +1,66 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	enum TypeDefinitionTreatment {
+		None = 0x0,
+
+		KindMask = 0xf,
+		NormalType = 0x1,
+		NormalAttribute = 0x2,
+		UnmangleWindowsRuntimeName = 0x3,
+		PrefixWindowsRuntimeName = 0x4,
+		RedirectToClrType = 0x5,
+		RedirectToClrAttribute = 0x6,
+
+		Abstract = 0x10,
+		Internal = 0x20,
+	}
+
+	enum TypeReferenceTreatment {
+		None = 0x0,
+		SystemDelegate = 0x1,
+		SystemAttribute = 0x2,
+		UseProjectionInfo = 0x3,
+	}
+
+	[Flags]
+	enum MethodDefinitionTreatment {
+		None = 0x0,
+		Dispose = 0x1,
+		Abstract = 0x2,
+		Private = 0x4,
+		Public = 0x8,
+		Runtime = 0x10,
+		InternalCall = 0x20,
+	}
+
+	enum FieldDefinitionTreatment {
+		None = 0x0,
+		Public = 0x1,
+	}
+
+	enum MemberReferenceTreatment {
+		None = 0x0,
+		Dispose = 0x1,
+	}
+
+	enum CustomAttributeValueTreatment {
+		None = 0x0,
+		AllowSingle = 0x1,
+		AllowMultiple = 0x2,
+		VersionAttribute = 0x3,
+		DeprecatedAttribute = 0x4,
+	}
+}
diff --git a/src/Mono/Cecil/TypeAttributes.cs b/src/Mono/Cecil/TypeAttributes.cs
new file mode 100644
index 00000000..92a71aca
--- /dev/null
+++ b/src/Mono/Cecil/TypeAttributes.cs
@@ -0,0 +1,63 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono.Cecil {
+
+	[Flags]
+	public enum TypeAttributes : uint {
+		// Visibility attributes
+		VisibilityMask		= 0x00000007,	// Use this mask to retrieve visibility information
+		NotPublic			= 0x00000000,	// Class has no public scope
+		Public				= 0x00000001,	// Class has public scope
+		NestedPublic		= 0x00000002,	// Class is nested with public visibility
+		NestedPrivate		= 0x00000003,	// Class is nested with private visibility
+		NestedFamily		= 0x00000004,	// Class is nested with family visibility
+		NestedAssembly		= 0x00000005,	// Class is nested with assembly visibility
+		NestedFamANDAssem	= 0x00000006,	// Class is nested with family and assembly visibility
+		NestedFamORAssem	= 0x00000007,	// Class is nested with family or assembly visibility
+
+		// Class layout attributes
+		LayoutMask			= 0x00000018,	// Use this mask to retrieve class layout information
+		AutoLayout			= 0x00000000,	// Class fields are auto-laid out
+		SequentialLayout	= 0x00000008,	// Class fields are laid out sequentially
+		ExplicitLayout		= 0x00000010,	// Layout is supplied explicitly
+
+		// Class semantics attributes
+		ClassSemanticMask	= 0x00000020,	// Use this mask to retrieve class semantics information
+		Class				= 0x00000000,	// Type is a class
+		Interface			= 0x00000020,	// Type is an interface
+
+		// Special semantics in addition to class semantics
+		Abstract			= 0x00000080,	// Class is abstract
+		Sealed				= 0x00000100,	// Class cannot be extended
+		SpecialName			= 0x00000400,	// Class name is special
+
+		// Implementation attributes
+		Import				= 0x00001000,	// Class/Interface is imported
+		Serializable		= 0x00002000,	// Class is serializable
+		WindowsRuntime		= 0x00004000,	// Windows Runtime type
+
+		// String formatting attributes
+		StringFormatMask	= 0x00030000,	// Use this mask to retrieve string information for native interop
+		AnsiClass			= 0x00000000,	// LPSTR is interpreted as ANSI
+		UnicodeClass		= 0x00010000,	// LPSTR is interpreted as Unicode
+		AutoClass			= 0x00020000,	// LPSTR is interpreted automatically
+
+		// Class initialization attributes
+		BeforeFieldInit		= 0x00100000,	// Initialize the class before first static field access
+
+		// Additional flags
+		RTSpecialName		= 0x00000800,	// CLI provides 'special' behavior, depending upon the name of the Type
+		HasSecurity			= 0x00040000,	// Type has security associate with it
+		Forwarder			= 0x00200000,   // Exported type is a type forwarder
+	}
+}
diff --git a/src/Mono/Cecil/TypeDefinition.cs b/src/Mono/Cecil/TypeDefinition.cs
new file mode 100644
index 00000000..6b6558c4
--- /dev/null
+++ b/src/Mono/Cecil/TypeDefinition.cs
@@ -0,0 +1,609 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Cecil.Metadata;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public sealed class TypeDefinition : TypeReference, IMemberDefinition, ISecurityDeclarationProvider {
+
+		uint attributes;
+		TypeReference base_type;
+		internal Range fields_range;
+		internal Range methods_range;
+
+		short packing_size = Mixin.NotResolvedMarker;
+		int class_size = Mixin.NotResolvedMarker;
+
+		InterfaceImplementationCollection interfaces;
+		Collection<TypeDefinition> nested_types;
+		Collection<MethodDefinition> methods;
+		Collection<FieldDefinition> fields;
+		Collection<EventDefinition> events;
+		Collection<PropertyDefinition> properties;
+		Collection<CustomAttribute> custom_attributes;
+		Collection<SecurityDeclaration> security_declarations;
+
+		public TypeAttributes Attributes {
+			get { return (TypeAttributes) attributes; }
+			set {
+				if (IsWindowsRuntimeProjection && (ushort) value != attributes)
+					throw new InvalidOperationException ();
+
+				attributes = (uint) value;
+			}
+		}
+
+		public TypeReference BaseType {
+			get { return base_type; }
+			set { base_type = value; }
+		}
+
+		public override string Name {
+			get { return base.Name; }
+			set {
+				if (IsWindowsRuntimeProjection && value != base.Name)
+					throw new InvalidOperationException ();
+
+				base.Name = value;
+			}
+		}
+
+		void ResolveLayout ()
+		{
+			if (packing_size != Mixin.NotResolvedMarker || class_size != Mixin.NotResolvedMarker)
+				return;
+
+			if (!HasImage) {
+				packing_size = Mixin.NoDataMarker;
+				class_size = Mixin.NoDataMarker;
+				return;
+			}
+
+			var row = Module.Read (this, (type, reader) => reader.ReadTypeLayout (type));
+
+			packing_size = row.Col1;
+			class_size = row.Col2;
+		}
+
+		public bool HasLayoutInfo {
+			get {
+				if (packing_size >= 0 || class_size >= 0)
+					return true;
+
+				ResolveLayout ();
+
+				return packing_size >= 0 || class_size >= 0;
+			}
+		}
+
+		public short PackingSize {
+			get {
+				if (packing_size >= 0)
+					return packing_size;
+
+				ResolveLayout ();
+
+				return packing_size >= 0 ? packing_size : (short) -1;
+			}
+			set { packing_size = value; }
+		}
+
+		public int ClassSize {
+			get {
+				if (class_size >= 0)
+					return class_size;
+
+				ResolveLayout ();
+
+				return class_size >= 0 ? class_size : -1;
+			}
+			set { class_size = value; }
+		}
+
+		public bool HasInterfaces {
+			get {
+				if (interfaces != null)
+					return interfaces.Count > 0;
+
+				return HasImage && Module.Read (this, (type, reader) => reader.HasInterfaces (type));
+			}
+		}
+
+		public Collection<InterfaceImplementation> Interfaces {
+			get {
+				if (interfaces != null)
+					return interfaces;
+
+				if (HasImage)
+					return Module.Read (ref interfaces, this, (type, reader) => reader.ReadInterfaces (type));
+
+				return interfaces = new InterfaceImplementationCollection (this);
+			}
+		}
+
+		public bool HasNestedTypes {
+			get {
+				if (nested_types != null)
+					return nested_types.Count > 0;
+
+				return HasImage && Module.Read (this, (type, reader) => reader.HasNestedTypes (type));
+			}
+		}
+
+		public Collection<TypeDefinition> NestedTypes {
+			get {
+				if (nested_types != null)
+					return nested_types;
+
+				if (HasImage)
+					return Module.Read (ref nested_types, this, (type, reader) => reader.ReadNestedTypes (type));
+
+				return nested_types = new MemberDefinitionCollection<TypeDefinition> (this);
+			}
+		}
+
+		public bool HasMethods {
+			get {
+				if (methods != null)
+					return methods.Count > 0;
+
+				return HasImage && methods_range.Length > 0;
+			}
+		}
+
+		public Collection<MethodDefinition> Methods {
+			get {
+				if (methods != null)
+					return methods;
+
+				if (HasImage)
+					return Module.Read (ref methods, this, (type, reader) => reader.ReadMethods (type));
+
+				return methods = new MemberDefinitionCollection<MethodDefinition> (this);
+			}
+		}
+
+		public bool HasFields {
+			get {
+				if (fields != null)
+					return fields.Count > 0;
+
+				return HasImage && fields_range.Length > 0;
+			}
+		}
+
+		public Collection<FieldDefinition> Fields {
+			get {
+				if (fields != null)
+					return fields;
+
+				if (HasImage)
+					return Module.Read (ref fields, this, (type, reader) => reader.ReadFields (type));
+
+				return fields = new MemberDefinitionCollection<FieldDefinition> (this);
+			}
+		}
+
+		public bool HasEvents {
+			get {
+				if (events != null)
+					return events.Count > 0;
+
+				return HasImage && Module.Read (this, (type, reader) => reader.HasEvents (type));
+			}
+		}
+
+		public Collection<EventDefinition> Events {
+			get {
+				if (events != null)
+					return events;
+
+				if (HasImage)
+					return Module.Read (ref events, this, (type, reader) => reader.ReadEvents (type));
+
+				return events = new MemberDefinitionCollection<EventDefinition> (this);
+			}
+		}
+
+		public bool HasProperties {
+			get {
+				if (properties != null)
+					return properties.Count > 0;
+
+				return HasImage && Module.Read (this, (type, reader) => reader.HasProperties (type));
+			}
+		}
+
+		public Collection<PropertyDefinition> Properties {
+			get {
+				if (properties != null)
+					return properties;
+
+				if (HasImage)
+					return Module.Read (ref properties, this, (type, reader) => reader.ReadProperties (type));
+
+				return properties = new MemberDefinitionCollection<PropertyDefinition> (this);
+			}
+		}
+
+		public bool HasSecurityDeclarations {
+			get {
+				if (security_declarations != null)
+					return security_declarations.Count > 0;
+
+				return this.GetHasSecurityDeclarations (Module);
+			}
+		}
+
+		public Collection<SecurityDeclaration> SecurityDeclarations {
+			get { return security_declarations ?? (this.GetSecurityDeclarations (ref security_declarations, Module)); }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				return this.GetHasCustomAttributes (Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, Module)); }
+		}
+
+		public override bool HasGenericParameters {
+			get {
+				if (generic_parameters != null)
+					return generic_parameters.Count > 0;
+
+				return this.GetHasGenericParameters (Module);
+			}
+		}
+
+		public override Collection<GenericParameter> GenericParameters {
+			get { return generic_parameters ?? (this.GetGenericParameters (ref generic_parameters, Module)); }
+		}
+
+		#region TypeAttributes
+
+		public bool IsNotPublic {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NotPublic); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NotPublic, value); }
+		}
+
+		public bool IsPublic {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.Public); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.Public, value); }
+		}
+
+		public bool IsNestedPublic {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPublic); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPublic, value); }
+		}
+
+		public bool IsNestedPrivate {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPrivate); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedPrivate, value); }
+		}
+
+		public bool IsNestedFamily {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamily); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamily, value); }
+		}
+
+		public bool IsNestedAssembly {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedAssembly); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedAssembly, value); }
+		}
+
+		public bool IsNestedFamilyAndAssembly {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamANDAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamANDAssem, value); }
+		}
+
+		public bool IsNestedFamilyOrAssembly {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamORAssem); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.VisibilityMask, (uint) TypeAttributes.NestedFamORAssem, value); }
+		}
+
+		public bool IsAutoLayout {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.AutoLayout); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.AutoLayout, value); }
+		}
+
+		public bool IsSequentialLayout {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.SequentialLayout); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.SequentialLayout, value); }
+		}
+
+		public bool IsExplicitLayout {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.ExplicitLayout); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.LayoutMask, (uint) TypeAttributes.ExplicitLayout, value); }
+		}
+
+		public bool IsClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Class); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Class, value); }
+		}
+
+		public bool IsInterface {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Interface); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.ClassSemanticMask, (uint) TypeAttributes.Interface, value); }
+		}
+
+		public bool IsAbstract {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Abstract); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Abstract, value); }
+		}
+
+		public bool IsSealed {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Sealed); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Sealed, value); }
+		}
+
+		public bool IsSpecialName {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.SpecialName); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.SpecialName, value); }
+		}
+
+		public bool IsImport {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Import); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Import, value); }
+		}
+
+		public bool IsSerializable {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.Serializable); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.Serializable, value); }
+		}
+
+		public bool IsWindowsRuntime {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.WindowsRuntime); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.WindowsRuntime, value); }
+		}
+
+		public bool IsAnsiClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AnsiClass); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AnsiClass, value); }
+		}
+
+		public bool IsUnicodeClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.UnicodeClass); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.UnicodeClass, value); }
+		}
+
+		public bool IsAutoClass {
+			get { return attributes.GetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AutoClass); }
+			set { attributes = attributes.SetMaskedAttributes ((uint) TypeAttributes.StringFormatMask, (uint) TypeAttributes.AutoClass, value); }
+		}
+
+		public bool IsBeforeFieldInit {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.BeforeFieldInit); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.BeforeFieldInit, value); }
+		}
+
+		public bool IsRuntimeSpecialName {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.RTSpecialName); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.RTSpecialName, value); }
+		}
+
+		public bool HasSecurity {
+			get { return attributes.GetAttributes ((uint) TypeAttributes.HasSecurity); }
+			set { attributes = attributes.SetAttributes ((uint) TypeAttributes.HasSecurity, value); }
+		}
+
+		#endregion
+
+		public bool IsEnum {
+			get { return base_type != null && base_type.IsTypeOf ("System", "Enum"); }
+		}
+
+		public override bool IsValueType {
+			get {
+				if (base_type == null)
+					return false;
+
+				return base_type.IsTypeOf ("System", "Enum") || (base_type.IsTypeOf ("System", "ValueType") && !this.IsTypeOf ("System", "Enum"));
+			}
+			set {
+				throw new NotSupportedException ();
+			}
+		}
+
+		public override bool IsPrimitive {
+			get {
+				ElementType primitive_etype;
+				return MetadataSystem.TryGetPrimitiveElementType (this, out primitive_etype) && primitive_etype.IsPrimitive ();
+			}
+		}
+
+		public override MetadataType MetadataType {
+			get {
+				ElementType primitive_etype;
+				if (MetadataSystem.TryGetPrimitiveElementType (this, out primitive_etype))
+					return (MetadataType) primitive_etype;
+
+				return base.MetadataType;
+			}
+		}
+
+		public override bool IsDefinition {
+			get { return true; }
+		}
+
+		public new TypeDefinition DeclaringType {
+			get { return (TypeDefinition) base.DeclaringType; }
+			set { base.DeclaringType = value; }
+		}
+
+		internal new TypeDefinitionProjection WindowsRuntimeProjection {
+			get { return (TypeDefinitionProjection) projection; }
+			set { projection = value; }
+		}
+
+		public TypeDefinition (string @namespace, string name, TypeAttributes attributes)
+			: base (@namespace, name)
+		{
+			this.attributes = (uint) attributes;
+			this.token = new MetadataToken (TokenType.TypeDef);
+		}
+
+		public TypeDefinition (string @namespace, string name, TypeAttributes attributes, TypeReference baseType) :
+			this (@namespace, name, attributes)
+		{
+			this.BaseType = baseType;
+		}
+
+		protected override void ClearFullName ()
+		{
+			base.ClearFullName ();
+
+			if (!HasNestedTypes)
+				return;
+
+			var nested_types = this.NestedTypes;
+
+			for (int i = 0; i < nested_types.Count; i++)
+				nested_types [i].ClearFullName ();
+		}
+
+		public override TypeDefinition Resolve ()
+		{
+			return this;
+		}
+	}
+
+	public sealed class InterfaceImplementation : ICustomAttributeProvider
+	{
+		internal TypeDefinition type;
+		internal MetadataToken token;
+
+		TypeReference interface_type;
+		Collection<CustomAttribute> custom_attributes;
+
+		public TypeReference InterfaceType {
+			get { return interface_type; }
+			set { interface_type = value; }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				if (type == null)
+					return false;
+
+				return this.GetHasCustomAttributes (type.Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get {
+				if (type == null)
+					return custom_attributes = new Collection<CustomAttribute> ();
+
+				return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, type.Module));
+			}
+		}
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		internal InterfaceImplementation (TypeReference interfaceType, MetadataToken token)
+		{
+			this.interface_type = interfaceType;
+			this.token = token;
+		}
+
+		public InterfaceImplementation (TypeReference interfaceType)
+		{
+			Mixin.CheckType (interfaceType, Mixin.Argument.interfaceType);
+
+			this.interface_type = interfaceType;
+			this.token = new MetadataToken (TokenType.InterfaceImpl);
+		}
+	}
+
+	class InterfaceImplementationCollection : Collection<InterfaceImplementation>
+	{
+		readonly TypeDefinition type;
+
+		internal InterfaceImplementationCollection (TypeDefinition type)
+		{
+			this.type = type;
+		}
+
+		internal InterfaceImplementationCollection (TypeDefinition type, int length)
+			: base (length)
+		{
+			this.type = type;
+		}
+
+		protected override void OnAdd (InterfaceImplementation item, int index)
+		{
+			item.type = type;
+		}
+
+		protected override void OnInsert (InterfaceImplementation item, int index)
+		{
+			item.type = type;
+		}
+
+		protected override void OnSet (InterfaceImplementation item, int index)
+		{
+			item.type = type;
+		}
+
+		protected override void OnRemove (InterfaceImplementation item, int index)
+		{
+			item.type = null;
+		}
+	}
+
+	static partial class Mixin {
+
+		public static TypeReference GetEnumUnderlyingType (this TypeDefinition self)
+		{
+			var fields = self.Fields;
+
+			for (int i = 0; i < fields.Count; i++) {
+				var field = fields [i];
+				if (!field.IsStatic)
+					return field.FieldType;
+			}
+
+			throw new ArgumentException ();
+		}
+
+		public static TypeDefinition GetNestedType (this TypeDefinition self, string fullname)
+		{
+			if (!self.HasNestedTypes)
+				return null;
+
+			var nested_types = self.NestedTypes;
+
+			for (int i = 0; i < nested_types.Count; i++) {
+				var nested_type = nested_types [i];
+
+				if (nested_type.TypeFullName () == fullname)
+					return nested_type;
+			}
+
+			return null;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/TypeDefinitionCollection.cs b/src/Mono/Cecil/TypeDefinitionCollection.cs
new file mode 100644
index 00000000..95e39b9a
--- /dev/null
+++ b/src/Mono/Cecil/TypeDefinitionCollection.cs
@@ -0,0 +1,100 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+
+using Mono.Cecil.Metadata;
+
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	using Slot = Row<string, string>;
+
+	sealed class TypeDefinitionCollection : Collection<TypeDefinition> {
+
+		readonly ModuleDefinition container;
+		readonly Dictionary<Slot, TypeDefinition> name_cache;
+
+		internal TypeDefinitionCollection (ModuleDefinition container)
+		{
+			this.container = container;
+			this.name_cache = new Dictionary<Slot, TypeDefinition> (new RowEqualityComparer ());
+		}
+
+		internal TypeDefinitionCollection (ModuleDefinition container, int capacity)
+			: base (capacity)
+		{
+			this.container = container;
+			this.name_cache = new Dictionary<Slot, TypeDefinition> (capacity, new RowEqualityComparer ());
+		}
+
+		protected override void OnAdd (TypeDefinition item, int index)
+		{
+			Attach (item);
+		}
+
+		protected override void OnSet (TypeDefinition item, int index)
+		{
+			Attach (item);
+		}
+
+		protected override void OnInsert (TypeDefinition item, int index)
+		{
+			Attach (item);
+		}
+
+		protected override void OnRemove (TypeDefinition item, int index)
+		{
+			Detach (item);
+		}
+
+		protected override void OnClear ()
+		{
+			foreach (var type in this)
+				Detach (type);
+		}
+
+		void Attach (TypeDefinition type)
+		{
+			if (type.Module != null && type.Module != container)
+				throw new ArgumentException ("Type already attached");
+
+			type.module = container;
+			type.scope = container;
+			name_cache [new Slot (type.Namespace, type.Name)] = type;
+		}
+
+		void Detach (TypeDefinition type)
+		{
+			type.module = null;
+			type.scope = null;
+			name_cache.Remove (new Slot (type.Namespace, type.Name));
+		}
+
+		public TypeDefinition GetType (string fullname)
+		{
+			string @namespace, name;
+			TypeParser.SplitFullName (fullname, out @namespace, out name);
+
+			return GetType (@namespace, name);
+		}
+
+		public TypeDefinition GetType (string @namespace, string name)
+		{
+			TypeDefinition type;
+			if (name_cache.TryGetValue (new Slot (@namespace, name), out type))
+				return type;
+
+			return null;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/TypeParser.cs b/src/Mono/Cecil/TypeParser.cs
new file mode 100644
index 00000000..07854cd6
--- /dev/null
+++ b/src/Mono/Cecil/TypeParser.cs
@@ -0,0 +1,532 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+
+using Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	class TypeParser {
+
+		class Type {
+			public const int Ptr = -1;
+			public const int ByRef = -2;
+			public const int SzArray = -3;
+
+			public string type_fullname;
+			public string [] nested_names;
+			public int arity;
+			public int [] specs;
+			public Type [] generic_arguments;
+			public string assembly;
+		}
+
+		readonly string fullname;
+		readonly int length;
+
+		int position;
+
+		TypeParser (string fullname)
+		{
+			this.fullname = fullname;
+			this.length = fullname.Length;
+		}
+
+		Type ParseType (bool fq_name)
+		{
+			var type = new Type ();
+			type.type_fullname = ParsePart ();
+
+			type.nested_names = ParseNestedNames ();
+
+			if (TryGetArity (type))
+				type.generic_arguments = ParseGenericArguments (type.arity);
+
+			type.specs = ParseSpecs ();
+
+			if (fq_name)
+				type.assembly = ParseAssemblyName ();
+
+			return type;
+		}
+
+		static bool TryGetArity (Type type)
+		{
+			int arity = 0;
+
+			TryAddArity (type.type_fullname, ref arity);
+
+			var nested_names = type.nested_names;
+			if (!nested_names.IsNullOrEmpty ()) {
+				for (int i = 0; i < nested_names.Length; i++)
+					TryAddArity (nested_names [i], ref arity);
+			}
+
+			type.arity = arity;
+			return arity > 0;
+		}
+
+		static bool TryGetArity (string name, out int arity)
+		{
+			arity = 0;
+			var index = name.LastIndexOf ('`');
+			if (index == -1)
+				return false;
+
+			return ParseInt32 (name.Substring (index + 1), out arity);
+		}
+
+		static bool ParseInt32 (string value, out int result)
+		{
+			return int.TryParse (value, out result);
+		}
+
+		static void TryAddArity (string name, ref int arity)
+		{
+			int type_arity;
+			if (!TryGetArity (name, out type_arity))
+				return;
+
+			arity += type_arity;
+		}
+
+		string ParsePart ()
+		{
+			var part = new StringBuilder ();
+			while (position < length && !IsDelimiter (fullname [position])) {
+				if (fullname [position] == '\\')
+					position++;
+
+				part.Append (fullname [position++]);
+			}
+
+			return part.ToString ();
+		}
+
+		static bool IsDelimiter (char chr)
+		{
+			return "+,[]*&".IndexOf (chr) != -1;
+		}
+
+		void TryParseWhiteSpace ()
+		{
+			while (position < length && Char.IsWhiteSpace (fullname [position]))
+				position++;
+		}
+
+		string [] ParseNestedNames ()
+		{
+			string [] nested_names = null;
+			while (TryParse ('+'))
+				Add (ref nested_names, ParsePart ());
+
+			return nested_names;
+		}
+
+		bool TryParse (char chr)
+		{
+			if (position < length && fullname [position] == chr) {
+				position++;
+				return true;
+			}
+
+			return false;
+		}
+
+		static void Add<T> (ref T [] array, T item)
+		{
+			array = array.Add (item);
+		}
+
+		int [] ParseSpecs ()
+		{
+			int [] specs = null;
+
+			while (position < length) {
+				switch (fullname [position]) {
+				case '*':
+					position++;
+					Add (ref specs, Type.Ptr);
+					break;
+				case '&':
+					position++;
+					Add (ref specs, Type.ByRef);
+					break;
+				case '[':
+					position++;
+					switch (fullname [position]) {
+					case ']':
+						position++;
+						Add (ref specs, Type.SzArray);
+						break;
+					case '*':
+						position++;
+						Add (ref specs, 1);
+						break;
+					default:
+						var rank = 1;
+						while (TryParse (','))
+							rank++;
+
+						Add (ref specs, rank);
+
+						TryParse (']');
+						break;
+					}
+					break;
+				default:
+					return specs;
+				}
+			}
+
+			return specs;
+		}
+
+		Type [] ParseGenericArguments (int arity)
+		{
+			Type [] generic_arguments = null;
+
+			if (position == length || fullname [position] != '[')
+				return generic_arguments;
+
+			TryParse ('[');
+
+			for (int i = 0; i < arity; i++) {
+				var fq_argument = TryParse ('[');
+				Add (ref generic_arguments, ParseType (fq_argument));
+				if (fq_argument)
+					TryParse (']');
+
+				TryParse (',');
+				TryParseWhiteSpace ();
+			}
+
+			TryParse (']');
+
+			return generic_arguments;
+		}
+
+		string ParseAssemblyName ()
+		{
+			if (!TryParse (','))
+				return string.Empty;
+
+			TryParseWhiteSpace ();
+
+			var start = position;
+			while (position < length) {
+				var chr = fullname [position];
+				if (chr == '[' || chr == ']')
+					break;
+
+				position++;
+			}
+
+			return fullname.Substring (start, position - start);
+		}
+
+		public static TypeReference ParseType (ModuleDefinition module, string fullname, bool typeDefinitionOnly = false)
+		{
+			if (string.IsNullOrEmpty (fullname))
+				return null;
+
+			var parser = new TypeParser (fullname);
+			return GetTypeReference (module, parser.ParseType (true), typeDefinitionOnly);
+		}
+
+		static TypeReference GetTypeReference (ModuleDefinition module, Type type_info, bool type_def_only)
+		{
+			TypeReference type;
+			if (!TryGetDefinition (module, type_info, out type)) {
+				if (type_def_only)
+					return null;
+
+				type = CreateReference (type_info, module, GetMetadataScope (module, type_info));
+			}
+
+			return CreateSpecs (type, type_info);
+		}
+
+		static TypeReference CreateSpecs (TypeReference type, Type type_info)
+		{
+			type = TryCreateGenericInstanceType (type, type_info);
+
+			var specs = type_info.specs;
+			if (specs.IsNullOrEmpty ())
+				return type;
+
+			for (int i = 0; i < specs.Length; i++) {
+				switch (specs [i]) {
+				case Type.Ptr:
+					type = new PointerType (type);
+					break;
+				case Type.ByRef:
+					type = new ByReferenceType (type);
+					break;
+				case Type.SzArray:
+					type = new ArrayType (type);
+					break;
+				default:
+					var array = new ArrayType (type);
+					array.Dimensions.Clear ();
+
+					for (int j = 0; j < specs [i]; j++)
+						array.Dimensions.Add (new ArrayDimension ());
+
+					type = array;
+					break;
+				}
+			}
+
+			return type;
+		}
+
+		static TypeReference TryCreateGenericInstanceType (TypeReference type, Type type_info)
+		{
+			var generic_arguments = type_info.generic_arguments;
+			if (generic_arguments.IsNullOrEmpty ())
+				return type;
+
+			var instance = new GenericInstanceType (type);
+			var instance_arguments = instance.GenericArguments;
+
+			for (int i = 0; i < generic_arguments.Length; i++)
+				instance_arguments.Add (GetTypeReference (type.Module, generic_arguments [i], false));
+
+			return instance;
+		}
+
+		public static void SplitFullName (string fullname, out string @namespace, out string name)
+		{
+			var last_dot = fullname.LastIndexOf ('.');
+
+			if (last_dot == -1) {
+				@namespace = string.Empty;
+				name = fullname;
+			} else {
+				@namespace = fullname.Substring (0, last_dot);
+				name = fullname.Substring (last_dot + 1);
+			}
+		}
+
+		static TypeReference CreateReference (Type type_info, ModuleDefinition module, IMetadataScope scope)
+		{
+			string @namespace, name;
+			SplitFullName (type_info.type_fullname, out @namespace, out name);
+
+			var type = new TypeReference (@namespace, name, module, scope);
+			MetadataSystem.TryProcessPrimitiveTypeReference (type);
+
+			AdjustGenericParameters (type);
+
+			var nested_names = type_info.nested_names;
+			if (nested_names.IsNullOrEmpty ())
+				return type;
+
+			for (int i = 0; i < nested_names.Length; i++) {
+				type = new TypeReference (string.Empty, nested_names [i], module, null) {
+					DeclaringType = type,
+				};
+
+				AdjustGenericParameters (type);
+			}
+
+			return type;
+		}
+
+		static void AdjustGenericParameters (TypeReference type)
+		{
+			int arity;
+			if (!TryGetArity (type.Name, out arity))
+				return;
+
+			for (int i = 0; i < arity; i++)
+				type.GenericParameters.Add (new GenericParameter (type));
+		}
+
+		static IMetadataScope GetMetadataScope (ModuleDefinition module, Type type_info)
+		{
+			if (string.IsNullOrEmpty (type_info.assembly))
+				return module.TypeSystem.CoreLibrary;
+
+			AssemblyNameReference match;
+			var reference = AssemblyNameReference.Parse (type_info.assembly);
+
+			return module.TryGetAssemblyNameReference (reference, out match)
+				? match
+				: reference;
+		}
+
+		static bool TryGetDefinition (ModuleDefinition module, Type type_info, out TypeReference type)
+		{
+			type = null;
+			if (!TryCurrentModule (module, type_info))
+				return false;
+
+			var typedef = module.GetType (type_info.type_fullname);
+			if (typedef == null)
+				return false;
+
+			var nested_names = type_info.nested_names;
+			if (!nested_names.IsNullOrEmpty ()) {
+				for (int i = 0; i < nested_names.Length; i++) {
+					var nested_type = typedef.GetNestedType (nested_names [i]);
+					if (nested_type == null)
+						return false;
+
+					typedef = nested_type;
+				}
+			}
+
+			type = typedef;
+			return true;
+		}
+
+		static bool TryCurrentModule (ModuleDefinition module, Type type_info)
+		{
+			if (string.IsNullOrEmpty (type_info.assembly))
+				return true;
+
+			if (module.assembly != null && module.assembly.Name.FullName == type_info.assembly)
+				return true;
+
+			return false;
+		}
+
+		public static string ToParseable (TypeReference type, bool top_level = true)
+		{
+			if (type == null)
+				return null;
+
+			var name = new StringBuilder ();
+			AppendType (type, name, true, top_level);
+			return name.ToString ();
+		}
+
+		static void AppendNamePart (string part, StringBuilder name)
+		{
+			foreach (var c in part) {
+				if (IsDelimiter (c))
+					name.Append ('\\');
+
+				name.Append (c);
+			}
+		}
+
+		static void AppendType (TypeReference type, StringBuilder name, bool fq_name, bool top_level)
+		{
+			var element_type = type.GetElementType ();
+
+			var declaring_type = element_type.DeclaringType;
+			if (declaring_type != null) {
+				AppendType (declaring_type, name, false, top_level);
+				name.Append ('+');
+			}
+
+			var @namespace = type.Namespace;
+			if (!string.IsNullOrEmpty (@namespace)) {
+				AppendNamePart (@namespace, name);
+				name.Append ('.');
+			}
+
+			AppendNamePart (element_type.Name, name);
+
+			if (!fq_name)
+				return;
+
+			if (type.IsTypeSpecification ())
+				AppendTypeSpecification ((TypeSpecification) type, name);
+
+			if (RequiresFullyQualifiedName (type, top_level)) {
+				name.Append (", ");
+				name.Append (GetScopeFullName (type));
+			}
+		}
+
+		static string GetScopeFullName (TypeReference type)
+		{
+			var scope = type.Scope;
+			switch (scope.MetadataScopeType) {
+			case MetadataScopeType.AssemblyNameReference:
+				return ((AssemblyNameReference) scope).FullName;
+			case MetadataScopeType.ModuleDefinition:
+				return ((ModuleDefinition) scope).Assembly.Name.FullName;
+			}
+
+			throw new ArgumentException ();
+		}
+
+		static void AppendTypeSpecification (TypeSpecification type, StringBuilder name)
+		{
+			if (type.ElementType.IsTypeSpecification ())
+				AppendTypeSpecification ((TypeSpecification) type.ElementType, name);
+
+			switch (type.etype) {
+			case ElementType.Ptr:
+				name.Append ('*');
+				break;
+			case ElementType.ByRef:
+				name.Append ('&');
+				break;
+			case ElementType.SzArray:
+			case ElementType.Array:
+				var array = (ArrayType) type;
+				if (array.IsVector) {
+					name.Append ("[]");
+				} else {
+					name.Append ('[');
+					for (int i = 1; i < array.Rank; i++)
+						name.Append (',');
+					name.Append (']');
+				}
+				break;
+			case ElementType.GenericInst:
+				var instance = (GenericInstanceType) type;
+				var arguments = instance.GenericArguments;
+
+				name.Append ('[');
+
+				for (int i = 0; i < arguments.Count; i++) {
+					if (i > 0)
+						name.Append (',');
+
+					var argument = arguments [i];
+					var requires_fqname = argument.Scope != argument.Module;
+
+					if (requires_fqname)
+						name.Append ('[');
+
+					AppendType (argument, name, true, false);
+
+					if (requires_fqname)
+						name.Append (']');
+				}
+
+				name.Append (']');
+				break;
+			default:
+				return;
+			}
+		}
+
+		static bool RequiresFullyQualifiedName (TypeReference type, bool top_level)
+		{
+			if (type.Scope == type.Module)
+				return false;
+
+			if (type.Scope.Name == "mscorlib" && top_level)
+				return false;
+
+			return true;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/TypeReference.cs b/src/Mono/Cecil/TypeReference.cs
new file mode 100644
index 00000000..c2643b67
--- /dev/null
+++ b/src/Mono/Cecil/TypeReference.cs
@@ -0,0 +1,352 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Cecil.Metadata;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	public enum MetadataType : byte {
+		Void = ElementType.Void,
+		Boolean = ElementType.Boolean,
+		Char = ElementType.Char,
+		SByte = ElementType.I1,
+		Byte = ElementType.U1,
+		Int16 = ElementType.I2,
+		UInt16 = ElementType.U2,
+		Int32 = ElementType.I4,
+		UInt32 = ElementType.U4,
+		Int64 = ElementType.I8,
+		UInt64 = ElementType.U8,
+		Single = ElementType.R4,
+		Double = ElementType.R8,
+		String = ElementType.String,
+		Pointer = ElementType.Ptr,
+		ByReference = ElementType.ByRef,
+		ValueType = ElementType.ValueType,
+		Class = ElementType.Class,
+		Var = ElementType.Var,
+		Array = ElementType.Array,
+		GenericInstance = ElementType.GenericInst,
+		TypedByReference = ElementType.TypedByRef,
+		IntPtr = ElementType.I,
+		UIntPtr = ElementType.U,
+		FunctionPointer = ElementType.FnPtr,
+		Object = ElementType.Object,
+		MVar = ElementType.MVar,
+		RequiredModifier = ElementType.CModReqD,
+		OptionalModifier = ElementType.CModOpt,
+		Sentinel = ElementType.Sentinel,
+		Pinned = ElementType.Pinned,
+	}
+
+	public class TypeReference : MemberReference, IGenericParameterProvider, IGenericContext {
+
+		string @namespace;
+		bool value_type;
+		internal IMetadataScope scope;
+		internal ModuleDefinition module;
+
+		internal ElementType etype = ElementType.None;
+
+		string fullname;
+
+		protected Collection<GenericParameter> generic_parameters;
+
+		public override string Name {
+			get { return base.Name; }
+			set {
+				if (IsWindowsRuntimeProjection && value != base.Name)
+					throw new InvalidOperationException ("Projected type reference name can't be changed.");
+				base.Name = value;
+				ClearFullName ();
+			}
+		}
+
+		public virtual string Namespace {
+			get { return @namespace; }
+			set {
+				if (IsWindowsRuntimeProjection && value != @namespace)
+					throw new InvalidOperationException ("Projected type reference namespace can't be changed.");
+				@namespace = value;
+				ClearFullName ();
+			}
+		}
+
+		public virtual bool IsValueType {
+			get { return value_type; }
+			set { value_type = value; }
+		}
+
+		public override ModuleDefinition Module {
+			get {
+				if (module != null)
+					return module;
+
+				var declaring_type = this.DeclaringType;
+				if (declaring_type != null)
+					return declaring_type.Module;
+
+				return null;
+			}
+		}
+
+		internal new TypeReferenceProjection WindowsRuntimeProjection {
+			get { return (TypeReferenceProjection) projection; }
+			set { projection = value; }
+		}
+
+		IGenericParameterProvider IGenericContext.Type {
+			get { return this; }
+		}
+
+		IGenericParameterProvider IGenericContext.Method {
+			get { return null; }
+		}
+
+		GenericParameterType IGenericParameterProvider.GenericParameterType {
+			get { return GenericParameterType.Type; }
+		}
+
+		public virtual bool HasGenericParameters {
+			get { return !generic_parameters.IsNullOrEmpty (); }
+		}
+
+		public virtual Collection<GenericParameter> GenericParameters {
+			get {
+				if (generic_parameters != null)
+					return generic_parameters;
+
+				return generic_parameters = new GenericParameterCollection (this);
+			}
+		}
+
+		public virtual IMetadataScope Scope {
+			get {
+				var declaring_type = this.DeclaringType;
+				if (declaring_type != null)
+					return declaring_type.Scope;
+
+				return scope;
+			}
+			set {
+				var declaring_type = this.DeclaringType;
+				if (declaring_type != null) {
+					if (IsWindowsRuntimeProjection && value != declaring_type.Scope)
+						throw new InvalidOperationException ("Projected type scope can't be changed.");
+					declaring_type.Scope = value;
+					return;
+				}
+
+				if (IsWindowsRuntimeProjection && value != scope)
+					throw new InvalidOperationException ("Projected type scope can't be changed.");
+				scope = value;
+			}
+		}
+
+		public bool IsNested {
+			get { return this.DeclaringType != null; }
+		}
+
+		public override TypeReference DeclaringType {
+			get { return base.DeclaringType; }
+			set {
+				if (IsWindowsRuntimeProjection && value != base.DeclaringType)
+					throw new InvalidOperationException ("Projected type declaring type can't be changed.");
+				base.DeclaringType = value;
+				ClearFullName ();
+			}
+		}
+
+		public override string FullName {
+			get {
+				if (fullname != null)
+					return fullname;
+
+				fullname = this.TypeFullName ();
+
+				if (IsNested)
+					fullname = DeclaringType.FullName + "/" + fullname;
+
+				return fullname;
+			}
+		}
+
+		public virtual bool IsByReference {
+			get { return false; }
+		}
+
+		public virtual bool IsPointer {
+			get { return false; }
+		}
+
+		public virtual bool IsSentinel {
+			get { return false; }
+		}
+
+		public virtual bool IsArray {
+			get { return false; }
+		}
+
+		public virtual bool IsGenericParameter {
+			get { return false; }
+		}
+
+		public virtual bool IsGenericInstance {
+			get { return false; }
+		}
+
+		public virtual bool IsRequiredModifier {
+			get { return false; }
+		}
+
+		public virtual bool IsOptionalModifier {
+			get { return false; }
+		}
+
+		public virtual bool IsPinned {
+			get { return false; }
+		}
+
+		public virtual bool IsFunctionPointer {
+			get { return false; }
+		}
+
+		public virtual bool IsPrimitive {
+			get { return etype.IsPrimitive (); }
+		}
+
+		public virtual MetadataType MetadataType {
+			get {
+				switch (etype) {
+				case ElementType.None:
+					return IsValueType ? MetadataType.ValueType : MetadataType.Class;
+				default:
+					return (MetadataType) etype;
+				}
+			}
+		}
+
+		protected TypeReference (string @namespace, string name)
+			: base (name)
+		{
+			this.@namespace = @namespace ?? string.Empty;
+			this.token = new MetadataToken (TokenType.TypeRef, 0);
+		}
+
+		public TypeReference (string @namespace, string name, ModuleDefinition module, IMetadataScope scope)
+			: this (@namespace, name)
+		{
+			this.module = module;
+			this.scope = scope;
+		}
+
+		public TypeReference (string @namespace, string name, ModuleDefinition module, IMetadataScope scope, bool valueType) :
+			this (@namespace, name, module, scope)
+		{
+			value_type = valueType;
+		}
+
+		protected virtual void ClearFullName ()
+		{
+			this.fullname = null;
+		}
+
+		public virtual TypeReference GetElementType ()
+		{
+			return this;
+		}
+
+		protected override IMemberDefinition ResolveDefinition ()
+		{
+			return this.Resolve ();
+		}
+
+		public new virtual TypeDefinition Resolve ()
+		{
+			var module = this.Module;
+			if (module == null)
+				throw new NotSupportedException ();
+
+			return module.Resolve (this);
+		}
+	}
+
+	static partial class Mixin {
+
+		public static bool IsPrimitive (this ElementType self)
+		{
+			switch (self) {
+			case ElementType.Boolean:
+			case ElementType.Char:
+			case ElementType.I:
+			case ElementType.U:
+			case ElementType.I1:
+			case ElementType.U1:
+			case ElementType.I2:
+			case ElementType.U2:
+			case ElementType.I4:
+			case ElementType.U4:
+			case ElementType.I8:
+			case ElementType.U8:
+			case ElementType.R4:
+			case ElementType.R8:
+				return true;
+			default:
+				return false;
+			}
+		}
+
+		public static string TypeFullName (this TypeReference self)
+		{
+			return string.IsNullOrEmpty (self.Namespace)
+				? self.Name
+				: self.Namespace + '.' + self.Name;
+		}
+
+		public static bool IsTypeOf (this TypeReference self, string @namespace, string name)
+		{
+			return self.Name == name
+				&& self.Namespace == @namespace;
+		}
+
+		public static bool IsTypeSpecification (this TypeReference type)
+		{
+			switch (type.etype) {
+			case ElementType.Array:
+			case ElementType.ByRef:
+			case ElementType.CModOpt:
+			case ElementType.CModReqD:
+			case ElementType.FnPtr:
+			case ElementType.GenericInst:
+			case ElementType.MVar:
+			case ElementType.Pinned:
+			case ElementType.Ptr:
+			case ElementType.SzArray:
+			case ElementType.Sentinel:
+			case ElementType.Var:
+				return true;
+			}
+
+			return false;
+		}
+
+		public static TypeDefinition CheckedResolve (this TypeReference self)
+		{
+			var type = self.Resolve ();
+			if (type == null)
+				throw new ResolutionException (self);
+
+			return type;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/TypeSpecification.cs b/src/Mono/Cecil/TypeSpecification.cs
new file mode 100644
index 00000000..16e0cab8
--- /dev/null
+++ b/src/Mono/Cecil/TypeSpecification.cs
@@ -0,0 +1,68 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public abstract class TypeSpecification : TypeReference {
+
+		readonly TypeReference element_type;
+
+		public TypeReference ElementType {
+			get { return element_type; }
+		}
+
+		public override string Name {
+			get { return element_type.Name; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override string Namespace {
+			get { return element_type.Namespace; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override IMetadataScope Scope {
+			get { return element_type.Scope; }
+			set { throw new InvalidOperationException (); }
+		}
+
+		public override ModuleDefinition Module {
+			get { return element_type.Module; }
+		}
+
+		public override string FullName {
+			get { return element_type.FullName; }
+		}
+
+		public override bool ContainsGenericParameter {
+			get { return element_type.ContainsGenericParameter; }
+		}
+
+		public override MetadataType MetadataType {
+			get { return (MetadataType) etype; }
+		}
+
+		internal TypeSpecification (TypeReference type)
+			: base (null, null)
+		{
+			this.element_type = type;
+			this.token = new MetadataToken (TokenType.TypeSpec);
+		}
+
+		public override TypeReference GetElementType ()
+		{
+			return element_type.GetElementType ();
+		}
+	}
+}
diff --git a/src/Mono/Cecil/TypeSystem.cs b/src/Mono/Cecil/TypeSystem.cs
new file mode 100644
index 00000000..e16ec6f3
--- /dev/null
+++ b/src/Mono/Cecil/TypeSystem.cs
@@ -0,0 +1,331 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+using Mono.Cecil.Metadata;
+
+namespace Mono.Cecil {
+
+	public abstract class TypeSystem {
+
+		sealed class CoreTypeSystem : TypeSystem {
+
+			public CoreTypeSystem (ModuleDefinition module)
+				: base (module)
+			{
+			}
+
+			internal override TypeReference LookupType (string @namespace, string name)
+			{
+				var type = LookupTypeDefinition (@namespace, name) ?? LookupTypeForwarded (@namespace, name);
+				if (type != null)
+					return type;
+
+				throw new NotSupportedException ();
+			}
+
+			TypeReference LookupTypeDefinition (string @namespace, string name)
+			{
+				var metadata = module.MetadataSystem;
+				if (metadata.Types == null)
+					Initialize (module.Types);
+
+				return module.Read (new Row<string, string> (@namespace, name), (row, reader) => {
+					var types = reader.metadata.Types;
+
+					for (int i = 0; i < types.Length; i++) {
+						if (types [i] == null)
+							types [i] = reader.GetTypeDefinition ((uint) i + 1);
+
+						var type = types [i];
+
+						if (type.Name == row.Col2 && type.Namespace == row.Col1)
+							return type;
+					}
+
+					return null;
+				});
+			}
+
+			TypeReference LookupTypeForwarded (string @namespace, string name)
+			{
+				if (!module.HasExportedTypes)
+					return null;
+
+				var exported_types = module.ExportedTypes;
+				for (int i = 0; i < exported_types.Count; i++) {
+					var exported_type = exported_types [i];
+
+					if (exported_type.Name == name && exported_type.Namespace == @namespace)
+						return exported_type.CreateReference ();
+				}
+
+				return null;
+			}
+
+			static void Initialize (object obj)
+			{
+			}
+		}
+
+		sealed class CommonTypeSystem : TypeSystem {
+
+			AssemblyNameReference core_library;
+
+			public CommonTypeSystem (ModuleDefinition module)
+				: base (module)
+			{
+			}
+
+			internal override TypeReference LookupType (string @namespace, string name)
+			{
+				return CreateTypeReference (@namespace, name);
+			}
+
+			public AssemblyNameReference GetCoreLibraryReference ()
+			{
+				if (core_library != null)
+					return core_library;
+
+				if (module.TryGetCoreLibraryReference (out core_library))
+					return core_library;
+
+				core_library = new AssemblyNameReference {
+					Name = Mixin.mscorlib,
+					Version = GetCorlibVersion (),
+					PublicKeyToken = new byte [] { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 },
+				};
+
+				module.AssemblyReferences.Add (core_library);
+
+				return core_library;
+			}
+
+			Version GetCorlibVersion ()
+			{
+				switch (module.Runtime) {
+				case TargetRuntime.Net_1_0:
+				case TargetRuntime.Net_1_1:
+					return new Version (1, 0, 0, 0);
+				case TargetRuntime.Net_2_0:
+					return new Version (2, 0, 0, 0);
+				case TargetRuntime.Net_4_0:
+					return new Version (4, 0, 0, 0);
+				default:
+					throw new NotSupportedException ();
+				}
+			}
+
+			TypeReference CreateTypeReference (string @namespace, string name)
+			{
+				return new TypeReference (@namespace, name, module, GetCoreLibraryReference ());
+			}
+		}
+
+		readonly ModuleDefinition module;
+
+		TypeReference type_object;
+		TypeReference type_void;
+		TypeReference type_bool;
+		TypeReference type_char;
+		TypeReference type_sbyte;
+		TypeReference type_byte;
+		TypeReference type_int16;
+		TypeReference type_uint16;
+		TypeReference type_int32;
+		TypeReference type_uint32;
+		TypeReference type_int64;
+		TypeReference type_uint64;
+		TypeReference type_single;
+		TypeReference type_double;
+		TypeReference type_intptr;
+		TypeReference type_uintptr;
+		TypeReference type_string;
+		TypeReference type_typedref;
+
+		TypeSystem (ModuleDefinition module)
+		{
+			this.module = module;
+		}
+
+		internal static TypeSystem CreateTypeSystem (ModuleDefinition module)
+		{
+			if (module.IsCoreLibrary ())
+				return new CoreTypeSystem (module);
+
+			return new CommonTypeSystem (module);
+		}
+
+		internal abstract TypeReference LookupType (string @namespace, string name);
+
+		TypeReference LookupSystemType (ref TypeReference reference, string name, ElementType element_type)
+		{
+			lock (module.SyncRoot) {
+				if (reference != null)
+					return reference;
+				var type = LookupType ("System", name);
+				type.etype = element_type;
+				return reference = type;
+			}
+		}
+
+		TypeReference LookupSystemValueType (ref TypeReference typeRef, string name, ElementType element_type)
+		{
+			lock (module.SyncRoot) {
+				if (typeRef != null)
+					return typeRef;
+				var type = LookupType ("System", name);
+				type.etype = element_type;
+				type.KnownValueType ();
+				return typeRef = type;
+			}
+		}
+
+		[Obsolete ("Use CoreLibrary")]
+		public IMetadataScope Corlib {
+			get { return CoreLibrary; }
+		}
+
+		public IMetadataScope CoreLibrary {
+			get {
+				var common = this as CommonTypeSystem;
+				if (common == null)
+					return module;
+
+				return common.GetCoreLibraryReference ();
+			}
+		}
+
+		public TypeReference Object {
+			get { return type_object ?? (LookupSystemType (ref type_object, "Object", ElementType.Object)); }
+		}
+
+		public TypeReference Void {
+			get { return type_void ?? (LookupSystemType (ref type_void, "Void", ElementType.Void)); }
+		}
+
+		public TypeReference Boolean {
+			get { return type_bool ?? (LookupSystemValueType (ref type_bool, "Boolean", ElementType.Boolean)); }
+		}
+
+		public TypeReference Char {
+			get { return type_char ?? (LookupSystemValueType (ref type_char, "Char", ElementType.Char)); }
+		}
+
+		public TypeReference SByte {
+			get { return type_sbyte ?? (LookupSystemValueType (ref type_sbyte, "SByte", ElementType.I1)); }
+		}
+
+		public TypeReference Byte {
+			get { return type_byte ?? (LookupSystemValueType (ref type_byte, "Byte", ElementType.U1)); }
+		}
+
+		public TypeReference Int16 {
+			get { return type_int16 ?? (LookupSystemValueType (ref type_int16, "Int16", ElementType.I2)); }
+		}
+
+		public TypeReference UInt16 {
+			get { return type_uint16 ?? (LookupSystemValueType (ref type_uint16, "UInt16", ElementType.U2)); }
+		}
+
+		public TypeReference Int32 {
+			get { return type_int32 ?? (LookupSystemValueType (ref type_int32, "Int32", ElementType.I4)); }
+		}
+
+		public TypeReference UInt32 {
+			get { return type_uint32 ?? (LookupSystemValueType (ref type_uint32, "UInt32", ElementType.U4)); }
+		}
+
+		public TypeReference Int64 {
+			get { return type_int64 ?? (LookupSystemValueType (ref type_int64, "Int64", ElementType.I8)); }
+		}
+
+		public TypeReference UInt64 {
+			get { return type_uint64 ?? (LookupSystemValueType (ref type_uint64, "UInt64", ElementType.U8)); }
+		}
+
+		public TypeReference Single {
+			get { return type_single ?? (LookupSystemValueType (ref type_single, "Single", ElementType.R4)); }
+		}
+
+		public TypeReference Double {
+			get { return type_double ?? (LookupSystemValueType (ref type_double, "Double", ElementType.R8)); }
+		}
+
+		public TypeReference IntPtr {
+			get { return type_intptr ?? (LookupSystemValueType (ref type_intptr, "IntPtr", ElementType.I)); }
+		}
+
+		public TypeReference UIntPtr {
+			get { return type_uintptr ?? (LookupSystemValueType (ref type_uintptr, "UIntPtr", ElementType.U)); }
+		}
+
+		public TypeReference String {
+			get { return type_string ?? (LookupSystemType (ref type_string, "String", ElementType.String)); }
+		}
+
+		public TypeReference TypedReference {
+			get { return type_typedref ?? (LookupSystemValueType (ref type_typedref, "TypedReference", ElementType.TypedByRef)); }
+		}
+	}
+
+	static partial class Mixin {
+
+		public const string mscorlib = "mscorlib";
+		public const string system_runtime = "System.Runtime";
+		public const string system_private_corelib = "System.Private.CoreLib";
+		public const string netstandard = "netstandard";
+
+		public static bool TryGetCoreLibraryReference (this ModuleDefinition module, out AssemblyNameReference reference)
+		{
+			var references = module.AssemblyReferences;
+
+			for (int i = 0; i < references.Count; i++) {
+				reference = references [i];
+				if (IsCoreLibrary (reference))
+					return true;
+			}
+
+			reference = null;
+			return false;
+
+		}
+
+		public static bool IsCoreLibrary (this ModuleDefinition module)
+		{
+			if (module.Assembly == null)
+				return false;
+
+			if (!IsCoreLibrary (module.Assembly.Name))
+				return false;
+
+			if (module.HasImage && module.Read (module, (m, reader) => reader.image.GetTableLength (Table.AssemblyRef) > 0))
+				return false;
+
+			return true;
+		}
+
+		public static void KnownValueType (this TypeReference type)
+		{
+			if (!type.IsDefinition)
+				type.IsValueType = true;
+		}
+
+		static bool IsCoreLibrary (AssemblyNameReference reference)
+		{
+			var name = reference.Name;
+			return name == mscorlib
+				|| name == system_runtime
+				|| name == system_private_corelib
+				|| name == netstandard;
+		}
+	}
+}
diff --git a/src/Mono/Cecil/VariantType.cs b/src/Mono/Cecil/VariantType.cs
new file mode 100644
index 00000000..81aa7fa4
--- /dev/null
+++ b/src/Mono/Cecil/VariantType.cs
@@ -0,0 +1,35 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace Mono.Cecil {
+
+	public enum VariantType {
+		None = 0,
+		I2 = 2,
+		I4 = 3,
+		R4 = 4,
+		R8 = 5,
+		CY = 6,
+		Date = 7,
+		BStr = 8,
+		Dispatch = 9,
+		Error = 10,
+		Bool = 11,
+		Variant = 12,
+		Unknown = 13,
+		Decimal = 14,
+		I1 = 16,
+		UI1 = 17,
+		UI2 = 18,
+		UI4 = 19,
+		Int = 22,
+		UInt = 23
+	}
+}
diff --git a/src/Mono/Cecil/WindowsRuntimeProjections.cs b/src/Mono/Cecil/WindowsRuntimeProjections.cs
new file mode 100644
index 00000000..04ba8c60
--- /dev/null
+++ b/src/Mono/Cecil/WindowsRuntimeProjections.cs
@@ -0,0 +1,875 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Mono.Collections.Generic;
+
+namespace Mono.Cecil {
+
+	sealed class MemberReferenceProjection {
+
+		public readonly string Name;
+		public readonly MemberReferenceTreatment Treatment;
+
+		public MemberReferenceProjection (MemberReference member, MemberReferenceTreatment treatment)
+		{
+			Name = member.Name;
+			Treatment = treatment;
+		}
+	}
+
+	sealed class TypeDefinitionProjection {
+
+		public readonly TypeAttributes Attributes;
+		public readonly string Name;
+		public readonly TypeDefinitionTreatment Treatment;
+
+		public TypeDefinitionProjection (TypeDefinition type, TypeDefinitionTreatment treatment)
+		{
+			Attributes = type.Attributes;
+			Name = type.Name;
+			Treatment = treatment;
+		}
+	}
+
+	sealed class TypeReferenceProjection {
+
+		public readonly string Name;
+		public readonly string Namespace;
+		public readonly IMetadataScope Scope;
+		public readonly TypeReferenceTreatment Treatment;
+
+		public TypeReferenceProjection (TypeReference type, TypeReferenceTreatment treatment)
+		{
+			Name = type.Name;
+			Namespace = type.Namespace;
+			Scope = type.Scope;
+			Treatment = treatment;
+		}
+	}
+
+	sealed class MethodDefinitionProjection {
+
+		public readonly MethodAttributes Attributes;
+		public readonly MethodImplAttributes ImplAttributes;
+		public readonly string Name;
+		public readonly MethodDefinitionTreatment Treatment;
+
+		public MethodDefinitionProjection (MethodDefinition method, MethodDefinitionTreatment treatment)
+		{
+			Attributes = method.Attributes;
+			ImplAttributes = method.ImplAttributes;
+			Name = method.Name;
+			Treatment = treatment;
+		}
+	}
+
+	sealed class FieldDefinitionProjection {
+
+		public readonly FieldAttributes Attributes;
+		public readonly FieldDefinitionTreatment Treatment;
+
+		public FieldDefinitionProjection (FieldDefinition field, FieldDefinitionTreatment treatment)
+		{
+			Attributes = field.Attributes;
+			Treatment = treatment;
+		}
+	}
+
+	sealed class CustomAttributeValueProjection {
+
+		public readonly AttributeTargets Targets;
+		public readonly CustomAttributeValueTreatment Treatment;
+
+		public CustomAttributeValueProjection (AttributeTargets targets, CustomAttributeValueTreatment treatment)
+		{
+			Targets = targets;
+			Treatment = treatment;
+		}
+	}
+
+	sealed class WindowsRuntimeProjections {
+
+		struct ProjectionInfo {
+
+			public readonly string WinRTNamespace;
+			public readonly string ClrNamespace;
+			public readonly string ClrName;
+			public readonly string ClrAssembly;
+			public readonly bool Attribute;
+			public readonly bool Disposable;
+
+			public ProjectionInfo (string winrt_namespace, string clr_namespace, string clr_name, string clr_assembly, bool attribute = false, bool disposable = false)
+			{
+				WinRTNamespace = winrt_namespace;
+				ClrNamespace = clr_namespace;
+				ClrName = clr_name;
+				ClrAssembly = clr_assembly;
+				Attribute = attribute;
+				Disposable = disposable;
+			}
+		}
+
+		static readonly Version version = new Version (4, 0, 0, 0);
+
+		static readonly byte[] contract_pk_token = {
+			0xB0, 0x3F, 0x5F, 0x7F, 0x11, 0xD5, 0x0A, 0x3A
+		};
+
+		static readonly byte[] contract_pk = {
+			0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x06, 0x02, 0x00, 0x00,
+			0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+			0x07, 0xD1, 0xFA, 0x57, 0xC4, 0xAE, 0xD9, 0xF0, 0xA3, 0x2E, 0x84, 0xAA, 0x0F, 0xAE, 0xFD, 0x0D,
+			0xE9, 0xE8, 0xFD, 0x6A, 0xEC, 0x8F, 0x87, 0xFB, 0x03, 0x76, 0x6C, 0x83, 0x4C, 0x99, 0x92, 0x1E,
+			0xB2, 0x3B, 0xE7, 0x9A, 0xD9, 0xD5, 0xDC, 0xC1, 0xDD, 0x9A, 0xD2, 0x36, 0x13, 0x21, 0x02, 0x90,
+			0x0B, 0x72, 0x3C, 0xF9, 0x80, 0x95, 0x7F, 0xC4, 0xE1, 0x77, 0x10, 0x8F, 0xC6, 0x07, 0x77, 0x4F,
+			0x29, 0xE8, 0x32, 0x0E, 0x92, 0xEA, 0x05, 0xEC, 0xE4, 0xE8, 0x21, 0xC0, 0xA5, 0xEF, 0xE8, 0xF1,
+			0x64, 0x5C, 0x4C, 0x0C, 0x93, 0xC1, 0xAB, 0x99, 0x28, 0x5D, 0x62, 0x2C, 0xAA, 0x65, 0x2C, 0x1D,
+			0xFA, 0xD6, 0x3D, 0x74, 0x5D, 0x6F, 0x2D, 0xE5, 0xF1, 0x7E, 0x5E, 0xAF, 0x0F, 0xC4, 0x96, 0x3D,
+			0x26, 0x1C, 0x8A, 0x12, 0x43, 0x65, 0x18, 0x20, 0x6D, 0xC0, 0x93, 0x34, 0x4D, 0x5A, 0xD2, 0x93
+		};
+
+		static Dictionary<string, ProjectionInfo> projections;
+
+		static Dictionary<string, ProjectionInfo> Projections
+		{
+			get {
+				if (projections != null)
+					return projections;
+
+				return projections = new Dictionary<string, ProjectionInfo> {
+					{ "AttributeTargets", new ProjectionInfo ("Windows.Foundation.Metadata", "System", "AttributeTargets", "System.Runtime") },
+					{ "AttributeUsageAttribute", new ProjectionInfo ("Windows.Foundation.Metadata", "System", "AttributeUsageAttribute", "System.Runtime", attribute: true) },
+					{ "Color", new ProjectionInfo ("Windows.UI", "Windows.UI", "Color", "System.Runtime.WindowsRuntime") },
+					{ "CornerRadius", new ProjectionInfo ("Windows.UI.Xaml", "Windows.UI.Xaml", "CornerRadius", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "DateTime", new ProjectionInfo ("Windows.Foundation", "System", "DateTimeOffset", "System.Runtime") },
+					{ "Duration", new ProjectionInfo ("Windows.UI.Xaml", "Windows.UI.Xaml", "Duration", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "DurationType", new ProjectionInfo ("Windows.UI.Xaml", "Windows.UI.Xaml", "DurationType", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "EventHandler`1", new ProjectionInfo ("Windows.Foundation", "System", "EventHandler`1", "System.Runtime") },
+					{ "EventRegistrationToken", new ProjectionInfo ("Windows.Foundation", "System.Runtime.InteropServices.WindowsRuntime", "EventRegistrationToken", "System.Runtime.InteropServices.WindowsRuntime") },
+					{ "GeneratorPosition", new ProjectionInfo ("Windows.UI.Xaml.Controls.Primitives", "Windows.UI.Xaml.Controls.Primitives", "GeneratorPosition", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "GridLength", new ProjectionInfo ("Windows.UI.Xaml", "Windows.UI.Xaml", "GridLength", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "GridUnitType", new ProjectionInfo ("Windows.UI.Xaml", "Windows.UI.Xaml", "GridUnitType", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "HResult", new ProjectionInfo ("Windows.Foundation", "System", "Exception", "System.Runtime") },
+					{ "IBindableIterable", new ProjectionInfo ("Windows.UI.Xaml.Interop", "System.Collections", "IEnumerable", "System.Runtime") },
+					{ "IBindableVector", new ProjectionInfo ("Windows.UI.Xaml.Interop", "System.Collections", "IList", "System.Runtime") },
+					{ "IClosable", new ProjectionInfo ("Windows.Foundation", "System", "IDisposable", "System.Runtime", disposable: true) },
+					{ "ICommand", new ProjectionInfo ("Windows.UI.Xaml.Input", "System.Windows.Input", "ICommand", "System.ObjectModel") },
+					{ "IIterable`1", new ProjectionInfo ("Windows.Foundation.Collections", "System.Collections.Generic", "IEnumerable`1", "System.Runtime") },
+					{ "IKeyValuePair`2", new ProjectionInfo ("Windows.Foundation.Collections", "System.Collections.Generic", "KeyValuePair`2", "System.Runtime") },
+					{ "IMapView`2", new ProjectionInfo ("Windows.Foundation.Collections", "System.Collections.Generic", "IReadOnlyDictionary`2", "System.Runtime") },
+					{ "IMap`2", new ProjectionInfo ("Windows.Foundation.Collections", "System.Collections.Generic", "IDictionary`2", "System.Runtime") },
+					{ "INotifyCollectionChanged", new ProjectionInfo ("Windows.UI.Xaml.Interop", "System.Collections.Specialized", "INotifyCollectionChanged", "System.ObjectModel") },
+					{ "INotifyPropertyChanged", new ProjectionInfo ("Windows.UI.Xaml.Data", "System.ComponentModel", "INotifyPropertyChanged", "System.ObjectModel") },
+					{ "IReference`1", new ProjectionInfo ("Windows.Foundation", "System", "Nullable`1", "System.Runtime") },
+					{ "IVectorView`1", new ProjectionInfo ("Windows.Foundation.Collections", "System.Collections.Generic", "IReadOnlyList`1", "System.Runtime") },
+					{ "IVector`1", new ProjectionInfo ("Windows.Foundation.Collections", "System.Collections.Generic", "IList`1", "System.Runtime") },
+					{ "KeyTime", new ProjectionInfo ("Windows.UI.Xaml.Media.Animation", "Windows.UI.Xaml.Media.Animation", "KeyTime", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "Matrix", new ProjectionInfo ("Windows.UI.Xaml.Media", "Windows.UI.Xaml.Media", "Matrix", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "Matrix3D", new ProjectionInfo ("Windows.UI.Xaml.Media.Media3D", "Windows.UI.Xaml.Media.Media3D", "Matrix3D", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "Matrix3x2", new ProjectionInfo ("Windows.Foundation.Numerics", "System.Numerics", "Matrix3x2", "System.Numerics.Vectors") },
+					{ "Matrix4x4", new ProjectionInfo ("Windows.Foundation.Numerics", "System.Numerics", "Matrix4x4", "System.Numerics.Vectors") },
+					{ "NotifyCollectionChangedAction", new ProjectionInfo ("Windows.UI.Xaml.Interop", "System.Collections.Specialized", "NotifyCollectionChangedAction", "System.ObjectModel") },
+					{ "NotifyCollectionChangedEventArgs", new ProjectionInfo ("Windows.UI.Xaml.Interop", "System.Collections.Specialized", "NotifyCollectionChangedEventArgs", "System.ObjectModel") },
+					{ "NotifyCollectionChangedEventHandler", new ProjectionInfo ("Windows.UI.Xaml.Interop", "System.Collections.Specialized", "NotifyCollectionChangedEventHandler", "System.ObjectModel") },
+					{ "Plane", new ProjectionInfo ("Windows.Foundation.Numerics", "System.Numerics", "Plane", "System.Numerics.Vectors") },
+					{ "Point", new ProjectionInfo ("Windows.Foundation", "Windows.Foundation", "Point", "System.Runtime.WindowsRuntime") },
+					{ "PropertyChangedEventArgs", new ProjectionInfo ("Windows.UI.Xaml.Data", "System.ComponentModel", "PropertyChangedEventArgs", "System.ObjectModel") },
+					{ "PropertyChangedEventHandler", new ProjectionInfo ("Windows.UI.Xaml.Data", "System.ComponentModel", "PropertyChangedEventHandler", "System.ObjectModel") },
+					{ "Quaternion", new ProjectionInfo ("Windows.Foundation.Numerics", "System.Numerics", "Quaternion", "System.Numerics.Vectors") },
+					{ "Rect", new ProjectionInfo ("Windows.Foundation", "Windows.Foundation", "Rect", "System.Runtime.WindowsRuntime") },
+					{ "RepeatBehavior", new ProjectionInfo ("Windows.UI.Xaml.Media.Animation", "Windows.UI.Xaml.Media.Animation", "RepeatBehavior", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "RepeatBehaviorType", new ProjectionInfo ("Windows.UI.Xaml.Media.Animation", "Windows.UI.Xaml.Media.Animation", "RepeatBehaviorType", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "Size", new ProjectionInfo ("Windows.Foundation", "Windows.Foundation", "Size", "System.Runtime.WindowsRuntime") },
+					{ "Thickness", new ProjectionInfo ("Windows.UI.Xaml", "Windows.UI.Xaml", "Thickness", "System.Runtime.WindowsRuntime.UI.Xaml") },
+					{ "TimeSpan", new ProjectionInfo ("Windows.Foundation", "System", "TimeSpan", "System.Runtime") },
+					{ "TypeName", new ProjectionInfo ("Windows.UI.Xaml.Interop", "System", "Type", "System.Runtime") },
+					{ "Uri", new ProjectionInfo ("Windows.Foundation", "System", "Uri", "System.Runtime") },
+					{ "Vector2", new ProjectionInfo ("Windows.Foundation.Numerics", "System.Numerics", "Vector2", "System.Numerics.Vectors") },
+					{ "Vector3", new ProjectionInfo ("Windows.Foundation.Numerics", "System.Numerics", "Vector3", "System.Numerics.Vectors") },
+					{ "Vector4", new ProjectionInfo ("Windows.Foundation.Numerics", "System.Numerics", "Vector4", "System.Numerics.Vectors") },
+				};
+			}
+		}
+
+		readonly ModuleDefinition module;
+		Version corlib_version = new Version (255, 255, 255, 255);
+		AssemblyNameReference[] virtual_references;
+
+		AssemblyNameReference[] VirtualReferences {
+			get {
+				if (virtual_references == null) {
+					// force module to read its assembly references. that will in turn initialize virtual_references
+					Mixin.Read (module.AssemblyReferences);
+				}
+
+				return virtual_references;
+			}
+		}
+
+		public WindowsRuntimeProjections (ModuleDefinition module)
+		{
+			this.module = module;
+		}
+
+		public static void Project (TypeDefinition type)
+		{
+			var treatment = TypeDefinitionTreatment.None;
+			var metadata_kind = type.Module.MetadataKind;
+
+			if (type.IsWindowsRuntime) {
+				if (metadata_kind == MetadataKind.WindowsMetadata) {
+					treatment = GetWellKnownTypeDefinitionTreatment (type);
+					if (treatment != TypeDefinitionTreatment.None) {
+						ApplyProjection (type, new TypeDefinitionProjection (type, treatment));
+						return;
+					}
+
+					var base_type = type.BaseType;
+					if (base_type != null && IsAttribute (base_type))
+						treatment = TypeDefinitionTreatment.NormalAttribute;
+					else
+						treatment = TypeDefinitionTreatment.NormalType;
+				}
+				else if (metadata_kind == MetadataKind.ManagedWindowsMetadata && NeedsWindowsRuntimePrefix (type))
+					treatment = TypeDefinitionTreatment.PrefixWindowsRuntimeName;
+
+				if (treatment == TypeDefinitionTreatment.PrefixWindowsRuntimeName || treatment == TypeDefinitionTreatment.NormalType)
+					if (!type.IsInterface && HasAttribute (type, "Windows.UI.Xaml", "TreatAsAbstractComposableClassAttribute"))
+						treatment |= TypeDefinitionTreatment.Abstract;
+			}
+			else if (metadata_kind == MetadataKind.ManagedWindowsMetadata && IsClrImplementationType (type))
+				treatment = TypeDefinitionTreatment.UnmangleWindowsRuntimeName;
+
+			if (treatment != TypeDefinitionTreatment.None)
+				ApplyProjection (type, new TypeDefinitionProjection (type, treatment));
+		}
+
+		static TypeDefinitionTreatment GetWellKnownTypeDefinitionTreatment (TypeDefinition type)
+		{
+			ProjectionInfo info;
+			if (!Projections.TryGetValue (type.Name, out info))
+				return TypeDefinitionTreatment.None;
+
+			var treatment = info.Attribute ? TypeDefinitionTreatment.RedirectToClrAttribute : TypeDefinitionTreatment.RedirectToClrType;
+
+			if (type.Namespace == info.ClrNamespace)
+				return treatment;
+
+			if (type.Namespace == info.WinRTNamespace)
+				return treatment | TypeDefinitionTreatment.Internal;
+
+			return TypeDefinitionTreatment.None;
+		}
+
+		static bool NeedsWindowsRuntimePrefix (TypeDefinition type)
+		{
+			if ((type.Attributes & (TypeAttributes.VisibilityMask | TypeAttributes.Interface)) != TypeAttributes.Public)
+				return false;
+
+			var base_type = type.BaseType;
+			if (base_type == null || base_type.MetadataToken.TokenType != TokenType.TypeRef)
+				return false;
+
+			if (base_type.Namespace == "System")
+				switch (base_type.Name)
+				{
+					case "Attribute":
+					case "MulticastDelegate":
+					case "ValueType":
+						return false;
+				}
+
+			return true;
+		}
+
+		static bool IsClrImplementationType (TypeDefinition type)
+		{
+			if ((type.Attributes & (TypeAttributes.VisibilityMask | TypeAttributes.SpecialName)) != TypeAttributes.SpecialName)
+				return false;
+			return type.Name.StartsWith ("<CLR>");
+		}
+
+		public static void ApplyProjection (TypeDefinition type, TypeDefinitionProjection projection)
+		{
+			if (projection == null)
+				return;
+
+			var treatment = projection.Treatment;
+
+			switch (treatment & TypeDefinitionTreatment.KindMask) {
+			case TypeDefinitionTreatment.NormalType:
+				type.Attributes |= TypeAttributes.WindowsRuntime | TypeAttributes.Import;
+				break;
+
+			case TypeDefinitionTreatment.NormalAttribute:
+				type.Attributes |= TypeAttributes.WindowsRuntime | TypeAttributes.Sealed;
+				break;
+
+			case TypeDefinitionTreatment.UnmangleWindowsRuntimeName:
+				type.Attributes = type.Attributes & ~TypeAttributes.SpecialName | TypeAttributes.Public;
+				type.Name = type.Name.Substring ("<CLR>".Length);
+				break;
+
+			case TypeDefinitionTreatment.PrefixWindowsRuntimeName:
+				type.Attributes = type.Attributes & ~TypeAttributes.Public | TypeAttributes.Import;
+				type.Name = "<WinRT>" + type.Name;
+				break;
+
+			case TypeDefinitionTreatment.RedirectToClrType:
+				type.Attributes = type.Attributes & ~TypeAttributes.Public | TypeAttributes.Import;
+				break;
+
+			case TypeDefinitionTreatment.RedirectToClrAttribute:
+				type.Attributes = type.Attributes & ~TypeAttributes.Public;
+				break;
+			}
+
+			if ((treatment & TypeDefinitionTreatment.Abstract) != 0)
+				type.Attributes |= TypeAttributes.Abstract;
+
+			if ((treatment & TypeDefinitionTreatment.Internal) != 0)
+				type.Attributes &= ~TypeAttributes.Public;
+
+			type.WindowsRuntimeProjection = projection;
+		}
+
+		public static TypeDefinitionProjection RemoveProjection (TypeDefinition type)
+		{
+			if (!type.IsWindowsRuntimeProjection)
+				return null;
+
+			var projection = type.WindowsRuntimeProjection;
+			type.WindowsRuntimeProjection = null;
+
+			type.Attributes = projection.Attributes;
+			type.Name = projection.Name;
+
+			return projection;
+		}
+
+		public static void Project (TypeReference type)
+		{
+			TypeReferenceTreatment treatment;
+
+			ProjectionInfo info;
+			if (Projections.TryGetValue (type.Name, out info) && info.WinRTNamespace == type.Namespace)
+				treatment = TypeReferenceTreatment.UseProjectionInfo;
+			else
+				treatment = GetSpecialTypeReferenceTreatment (type);
+
+			if (treatment != TypeReferenceTreatment.None)
+				ApplyProjection (type, new TypeReferenceProjection (type, treatment));
+		}
+
+		static TypeReferenceTreatment GetSpecialTypeReferenceTreatment (TypeReference type)
+		{
+			if (type.Namespace == "System") {
+				if (type.Name == "MulticastDelegate")
+					return TypeReferenceTreatment.SystemDelegate;
+				if (type.Name == "Attribute")
+					return TypeReferenceTreatment.SystemAttribute;
+			}
+
+			return TypeReferenceTreatment.None;
+		}
+
+		static bool IsAttribute (TypeReference type)
+		{
+			if (type.MetadataToken.TokenType != TokenType.TypeRef)
+				return false;
+			return type.Name == "Attribute" && type.Namespace == "System";
+		}
+
+		static bool IsEnum (TypeReference type)
+		{
+			if (type.MetadataToken.TokenType != TokenType.TypeRef)
+				return false;
+			return type.Name == "Enum" && type.Namespace == "System";
+		}
+
+		public static void ApplyProjection (TypeReference type, TypeReferenceProjection projection)
+		{
+			if (projection == null)
+				return;
+
+			switch (projection.Treatment)
+			{
+				case TypeReferenceTreatment.SystemDelegate:
+				case TypeReferenceTreatment.SystemAttribute:
+					type.Scope = type.Module.Projections.GetAssemblyReference ("System.Runtime");
+					break;
+
+				case TypeReferenceTreatment.UseProjectionInfo:
+					var info = Projections [type.Name];
+					type.Name = info.ClrName;
+					type.Namespace = info.ClrNamespace;
+					type.Scope = type.Module.Projections.GetAssemblyReference (info.ClrAssembly);
+					break;
+			}
+
+			type.WindowsRuntimeProjection = projection;
+		}
+
+		public static TypeReferenceProjection RemoveProjection (TypeReference type)
+		{
+			if (!type.IsWindowsRuntimeProjection)
+				return null;
+
+			var projection = type.WindowsRuntimeProjection;
+			type.WindowsRuntimeProjection = null;
+
+			type.Name = projection.Name;
+			type.Namespace = projection.Namespace;
+			type.Scope = projection.Scope;
+
+			return projection;
+		}
+
+		public static void Project (MethodDefinition method)
+		{
+			var treatment = MethodDefinitionTreatment.None;
+			var other = false;
+			var declaring_type = method.DeclaringType;
+
+			if (declaring_type.IsWindowsRuntime)
+			{
+				if (IsClrImplementationType (declaring_type))
+					treatment = MethodDefinitionTreatment.None;
+				else if (declaring_type.IsNested)
+					treatment = MethodDefinitionTreatment.None;
+				else if (declaring_type.IsInterface)
+					treatment = MethodDefinitionTreatment.Runtime | MethodDefinitionTreatment.InternalCall;
+				else if (declaring_type.Module.MetadataKind == MetadataKind.ManagedWindowsMetadata && !method.IsPublic)
+					treatment = MethodDefinitionTreatment.None;
+				else
+				{
+					other = true;
+
+					var base_type = declaring_type.BaseType;
+					if (base_type != null && base_type.MetadataToken.TokenType == TokenType.TypeRef)
+					{
+						switch (GetSpecialTypeReferenceTreatment(base_type))
+						{
+							case TypeReferenceTreatment.SystemDelegate:
+								treatment = MethodDefinitionTreatment.Runtime | MethodDefinitionTreatment.Public;
+								other = false;
+								break;
+
+							case TypeReferenceTreatment.SystemAttribute:
+								treatment = MethodDefinitionTreatment.Runtime | MethodDefinitionTreatment.InternalCall;
+								other = false;
+								break;
+						}
+					}
+				}
+			}
+
+			if (other)
+			{
+				var seen_redirected = false;
+				var seen_non_redirected = false;
+				var disposable = false;
+
+				foreach (var @override in method.Overrides)
+				{
+					if (@override.MetadataToken.TokenType == TokenType.MemberRef && ImplementsRedirectedInterface (@override, out disposable))
+					{
+						seen_redirected = true;
+						if (disposable)
+							break;
+					}
+					else
+						seen_non_redirected = true;
+				}
+
+				if (disposable)
+				{
+					treatment = MethodDefinitionTreatment.Dispose;
+					other = false;
+				}
+				else if (seen_redirected && !seen_non_redirected)
+				{
+					treatment = MethodDefinitionTreatment.Runtime | MethodDefinitionTreatment.InternalCall | MethodDefinitionTreatment.Private;
+					other = false;
+				}
+			}
+
+			if (other)
+				treatment |= GetMethodDefinitionTreatmentFromCustomAttributes(method);
+
+			if (treatment != MethodDefinitionTreatment.None)
+				ApplyProjection (method, new MethodDefinitionProjection (method, treatment));
+		}
+
+		static MethodDefinitionTreatment GetMethodDefinitionTreatmentFromCustomAttributes(MethodDefinition method)
+		{
+			var treatment = MethodDefinitionTreatment.None;
+
+			foreach (var attribute in method.CustomAttributes)
+			{
+				var type = attribute.AttributeType;
+				if (type.Namespace != "Windows.UI.Xaml")
+					continue;
+				if (type.Name == "TreatAsPublicMethodAttribute")
+					treatment |= MethodDefinitionTreatment.Public;
+				else if (type.Name == "TreatAsAbstractMethodAttribute")
+					treatment |= MethodDefinitionTreatment.Abstract;
+			}
+
+			return treatment;
+		}
+
+		public static void ApplyProjection (MethodDefinition method, MethodDefinitionProjection projection)
+		{
+			if (projection == null)
+				return;
+
+			var treatment = projection.Treatment;
+
+			if ((treatment & MethodDefinitionTreatment.Dispose) != 0)
+				method.Name = "Dispose";
+
+			if ((treatment & MethodDefinitionTreatment.Abstract) != 0)
+				method.Attributes |= MethodAttributes.Abstract;
+
+			if ((treatment & MethodDefinitionTreatment.Private) != 0)
+				method.Attributes = (method.Attributes & ~MethodAttributes.MemberAccessMask) | MethodAttributes.Private;
+
+			if ((treatment & MethodDefinitionTreatment.Public) != 0)
+				method.Attributes = (method.Attributes & ~MethodAttributes.MemberAccessMask) | MethodAttributes.Public;
+
+			if ((treatment & MethodDefinitionTreatment.Runtime) != 0)
+				method.ImplAttributes |= MethodImplAttributes.Runtime;
+
+			if ((treatment & MethodDefinitionTreatment.InternalCall) != 0)
+				method.ImplAttributes |= MethodImplAttributes.InternalCall;
+
+			method.WindowsRuntimeProjection = projection;
+		}
+
+		public static MethodDefinitionProjection RemoveProjection (MethodDefinition method)
+		{
+			if (!method.IsWindowsRuntimeProjection)
+				return null;
+
+			var projection = method.WindowsRuntimeProjection;
+			method.WindowsRuntimeProjection = null;
+
+			method.Attributes = projection.Attributes;
+			method.ImplAttributes = projection.ImplAttributes;
+			method.Name = projection.Name;
+
+			return projection;
+		}
+
+		public static void Project (FieldDefinition field)
+		{
+			var treatment = FieldDefinitionTreatment.None;
+			var declaring_type = field.DeclaringType;
+
+			if (declaring_type.Module.MetadataKind == MetadataKind.WindowsMetadata && field.IsRuntimeSpecialName && field.Name == "value__") {
+				var base_type = declaring_type.BaseType;
+				if (base_type != null && IsEnum (base_type))
+					treatment = FieldDefinitionTreatment.Public;
+			}
+
+			if (treatment != FieldDefinitionTreatment.None)
+				ApplyProjection (field, new FieldDefinitionProjection (field, treatment));
+		}
+
+		public static void ApplyProjection (FieldDefinition field, FieldDefinitionProjection projection)
+		{
+			if (projection == null)
+				return;
+
+			if (projection.Treatment == FieldDefinitionTreatment.Public)
+				field.Attributes = (field.Attributes & ~FieldAttributes.FieldAccessMask) | FieldAttributes.Public;
+
+			field.WindowsRuntimeProjection = projection;
+		}
+
+		public static FieldDefinitionProjection RemoveProjection (FieldDefinition field)
+		{
+			if (!field.IsWindowsRuntimeProjection)
+				return null;
+
+			var projection = field.WindowsRuntimeProjection;
+			field.WindowsRuntimeProjection = null;
+
+			field.Attributes = projection.Attributes;
+
+			return projection;
+		}
+
+		public static void Project (MemberReference member)
+		{
+			bool disposable;
+			if (!ImplementsRedirectedInterface (member, out disposable) || !disposable)
+				return;
+
+			ApplyProjection (member, new MemberReferenceProjection (member, MemberReferenceTreatment.Dispose));
+		}
+
+		static bool ImplementsRedirectedInterface (MemberReference member, out bool disposable)
+		{
+			disposable = false;
+
+			var declaring_type = member.DeclaringType;
+			TypeReference type;
+			switch (declaring_type.MetadataToken.TokenType) {
+				case TokenType.TypeRef:
+					type = declaring_type;
+					break;
+
+				case TokenType.TypeSpec:
+					if (!declaring_type.IsGenericInstance)
+						return false;
+
+					type = ((TypeSpecification) declaring_type).ElementType;
+					if (type.MetadataType != MetadataType.Class || type.MetadataToken.TokenType != TokenType.TypeRef)
+						return false;
+
+					break;
+
+				default:
+					return false;
+			}
+
+			var projection = RemoveProjection (type);
+
+			var found = false;
+
+			ProjectionInfo info;
+			if (Projections.TryGetValue (type.Name, out info) && type.Namespace == info.WinRTNamespace) {
+				disposable = info.Disposable;
+				found = true;
+			}
+
+			ApplyProjection (type, projection);
+
+			return found;
+		}
+
+		public static void ApplyProjection (MemberReference member, MemberReferenceProjection projection)
+		{
+			if (projection == null)
+				return;
+
+			if (projection.Treatment == MemberReferenceTreatment.Dispose)
+				member.Name = "Dispose";
+
+			member.WindowsRuntimeProjection = projection;
+		}
+
+		public static MemberReferenceProjection RemoveProjection (MemberReference member)
+		{
+			if (!member.IsWindowsRuntimeProjection)
+				return null;
+
+			var projection = member.WindowsRuntimeProjection;
+			member.WindowsRuntimeProjection = null;
+
+			member.Name = projection.Name;
+
+			return projection;
+		}
+
+		public void AddVirtualReferences (Collection<AssemblyNameReference> references)
+		{
+			var corlib = GetCoreLibrary (references);
+			corlib_version = corlib.Version;
+			corlib.Version = version;
+
+			if (virtual_references == null) {
+				var winrt_references = GetAssemblyReferences (corlib);
+				Interlocked.CompareExchange (ref virtual_references, winrt_references, null);
+			}
+
+			foreach (var reference in virtual_references)
+				references.Add (reference);
+		}
+
+		public void RemoveVirtualReferences (Collection<AssemblyNameReference> references)
+		{
+			var corlib = GetCoreLibrary (references);
+			corlib.Version = corlib_version;
+
+			foreach (var reference in VirtualReferences)
+				references.Remove (reference);
+		}
+
+		static AssemblyNameReference[] GetAssemblyReferences (AssemblyNameReference corlib)
+		{
+			var system_runtime = new AssemblyNameReference ("System.Runtime", version);
+			var system_runtime_interopservices_windowsruntime = new AssemblyNameReference ("System.Runtime.InteropServices.WindowsRuntime", version);
+			var system_objectmodel = new AssemblyNameReference ("System.ObjectModel", version);
+			var system_runtime_windowsruntime = new AssemblyNameReference ("System.Runtime.WindowsRuntime", version);
+			var system_runtime_windowsruntime_ui_xaml = new AssemblyNameReference ("System.Runtime.WindowsRuntime.UI.Xaml", version);
+			var system_numerics_vectors = new AssemblyNameReference ("System.Numerics.Vectors", version);
+
+			if (corlib.HasPublicKey) {
+				system_runtime_windowsruntime.PublicKey =
+				system_runtime_windowsruntime_ui_xaml.PublicKey = corlib.PublicKey;
+
+				system_runtime.PublicKey =
+				system_runtime_interopservices_windowsruntime.PublicKey =
+				system_objectmodel.PublicKey =
+				system_numerics_vectors.PublicKey = contract_pk;
+			}
+			else {
+				system_runtime_windowsruntime.PublicKeyToken =
+				system_runtime_windowsruntime_ui_xaml.PublicKeyToken = corlib.PublicKeyToken;
+
+				system_runtime.PublicKeyToken =
+				system_runtime_interopservices_windowsruntime.PublicKeyToken =
+				system_objectmodel.PublicKeyToken =
+				system_numerics_vectors.PublicKeyToken = contract_pk_token;
+			}
+
+			return new[] {
+				system_runtime,
+				system_runtime_interopservices_windowsruntime,
+				system_objectmodel,
+				system_runtime_windowsruntime,
+				system_runtime_windowsruntime_ui_xaml,
+				system_numerics_vectors,
+			};
+		}
+
+		static AssemblyNameReference GetCoreLibrary (Collection<AssemblyNameReference> references)
+		{
+			foreach (var reference in references)
+				if (reference.Name == "mscorlib")
+					return reference;
+
+			throw new BadImageFormatException ("Missing mscorlib reference in AssemblyRef table.");
+		}
+
+		AssemblyNameReference GetAssemblyReference (string name)
+		{
+			foreach (var assembly in VirtualReferences)
+				if (assembly.Name == name)
+					return assembly;
+
+			throw new Exception ();
+		}
+
+		public static void Project (ICustomAttributeProvider owner, CustomAttribute attribute)
+		{
+			if (!IsWindowsAttributeUsageAttribute (owner, attribute))
+				return;
+
+			var treatment = CustomAttributeValueTreatment.None;
+			var type = (TypeDefinition) owner;
+
+			if (type.Namespace == "Windows.Foundation.Metadata") {
+				if (type.Name == "VersionAttribute")
+					treatment = CustomAttributeValueTreatment.VersionAttribute;
+				else if (type.Name == "DeprecatedAttribute")
+					treatment = CustomAttributeValueTreatment.DeprecatedAttribute;
+			}
+
+			if (treatment == CustomAttributeValueTreatment.None) {
+				var multiple = HasAttribute (type, "Windows.Foundation.Metadata", "AllowMultipleAttribute");
+				treatment = multiple ? CustomAttributeValueTreatment.AllowMultiple : CustomAttributeValueTreatment.AllowSingle;
+			}
+
+			if (treatment != CustomAttributeValueTreatment.None) {
+				var attribute_targets = (AttributeTargets) attribute.ConstructorArguments [0].Value;
+				ApplyProjection (attribute, new CustomAttributeValueProjection (attribute_targets, treatment));
+			}
+		}
+
+		static bool IsWindowsAttributeUsageAttribute (ICustomAttributeProvider owner, CustomAttribute attribute)
+		{
+			if (owner.MetadataToken.TokenType != TokenType.TypeDef)
+				return false;
+
+			var constructor = attribute.Constructor;
+
+			if (constructor.MetadataToken.TokenType != TokenType.MemberRef)
+				return false;
+
+			var declaring_type = constructor.DeclaringType;
+
+			if (declaring_type.MetadataToken.TokenType != TokenType.TypeRef)
+				return false;
+
+			// declaring type is already projected
+			return declaring_type.Name == "AttributeUsageAttribute" && declaring_type.Namespace == /*"Windows.Foundation.Metadata"*/"System";
+		}
+
+		static bool HasAttribute (TypeDefinition type, string @namespace, string name)
+		{
+			foreach (var attribute in type.CustomAttributes) {
+				var attribute_type = attribute.AttributeType;
+				if (attribute_type.Name == name && attribute_type.Namespace == @namespace)
+					return true;
+			}
+			return false;
+		}
+
+		public static void ApplyProjection (CustomAttribute attribute, CustomAttributeValueProjection projection)
+		{
+			if (projection == null)
+				return;
+
+			bool version_or_deprecated;
+			bool multiple;
+
+			switch (projection.Treatment) {
+			case CustomAttributeValueTreatment.AllowSingle:
+				version_or_deprecated = false;
+				multiple = false;
+				break;
+
+			case CustomAttributeValueTreatment.AllowMultiple:
+				version_or_deprecated = false;
+				multiple = true;
+				break;
+
+			case CustomAttributeValueTreatment.VersionAttribute:
+			case CustomAttributeValueTreatment.DeprecatedAttribute:
+				version_or_deprecated = true;
+				multiple = true;
+				break;
+
+			default:
+				throw new ArgumentException ();
+			}
+
+			var attribute_targets = (AttributeTargets) attribute.ConstructorArguments [0].Value;
+			if (version_or_deprecated)
+				attribute_targets |= AttributeTargets.Constructor | AttributeTargets.Property;
+			attribute.ConstructorArguments [0] = new CustomAttributeArgument (attribute.ConstructorArguments [0].Type, attribute_targets);
+
+			attribute.Properties.Add (new CustomAttributeNamedArgument ("AllowMultiple", new CustomAttributeArgument (attribute.Module.TypeSystem.Boolean, multiple)));
+
+			attribute.projection = projection;
+		}
+
+		public static CustomAttributeValueProjection RemoveProjection (CustomAttribute attribute)
+		{
+			if (attribute.projection == null)
+				return null;
+
+			var projection = attribute.projection;
+			attribute.projection = null;
+
+			attribute.ConstructorArguments [0] = new CustomAttributeArgument (attribute.ConstructorArguments [0].Type, projection.Targets);
+			attribute.Properties.Clear ();
+
+			return projection;
+		}
+	}
+}
diff --git a/src/Mono/Collections/Generic/Collection.cs b/src/Mono/Collections/Generic/Collection.cs
new file mode 100644
index 00000000..015d271b
--- /dev/null
+++ b/src/Mono/Collections/Generic/Collection.cs
@@ -0,0 +1,416 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using Mono.Cecil;
+
+namespace Mono.Collections.Generic {
+
+	public class Collection<T> : IList<T>, IList {
+
+		internal T [] items;
+		internal int size;
+		int version;
+
+		public int Count {
+			get { return size; }
+		}
+
+		public T this [int index] {
+			get {
+				if (index >= size)
+					throw new ArgumentOutOfRangeException ();
+
+				return items [index];
+			}
+			set {
+				CheckIndex (index);
+				if (index == size)
+					throw new ArgumentOutOfRangeException ();
+
+				OnSet (value, index);
+
+				items [index] = value;
+			}
+		}
+
+		public int Capacity {
+			get { return items.Length; }
+			set {
+				if (value < 0 || value < size)
+					throw new ArgumentOutOfRangeException ();
+
+				Resize (value);
+			}
+		}
+
+		bool ICollection<T>.IsReadOnly {
+			get { return false; }
+		}
+
+		bool IList.IsFixedSize {
+			get { return false; }
+		}
+
+		bool IList.IsReadOnly {
+			get { return false; }
+		}
+
+		object IList.this [int index] {
+			get { return this [index]; }
+			set {
+				CheckIndex (index);
+
+				try {
+					this [index] = (T) value;
+					return;
+				} catch (InvalidCastException) {
+				} catch (NullReferenceException) {
+				}
+
+				throw new ArgumentException ();
+			}
+		}
+
+		int ICollection.Count {
+			get { return Count; }
+		}
+
+		bool ICollection.IsSynchronized {
+			get { return false; }
+		}
+
+		object ICollection.SyncRoot {
+			get { return this; }
+		}
+
+		public Collection ()
+		{
+			items = Empty<T>.Array;
+		}
+
+		public Collection (int capacity)
+		{
+			if (capacity < 0)
+				throw new ArgumentOutOfRangeException ();
+
+			items = new T [capacity];
+		}
+
+		public Collection (ICollection<T> items)
+		{
+			if (items == null)
+				throw new ArgumentNullException ("items");
+
+			this.items = new T [items.Count];
+			items.CopyTo (this.items, 0);
+			this.size = this.items.Length;
+		}
+
+		public void Add (T item)
+		{
+			if (size == items.Length)
+				Grow (1);
+
+			OnAdd (item, size);
+
+			items [size++] = item;
+			version++;
+		}
+
+		public bool Contains (T item)
+		{
+			return IndexOf (item) != -1;
+		}
+
+		public int IndexOf (T item)
+		{
+			return Array.IndexOf (items, item, 0, size);
+		}
+
+		public void Insert (int index, T item)
+		{
+			CheckIndex (index);
+			if (size == items.Length)
+				Grow (1);
+
+			OnInsert (item, index);
+
+			Shift (index, 1);
+			items [index] = item;
+			version++;
+		}
+
+		public void RemoveAt (int index)
+		{
+			if (index < 0 || index >= size)
+				throw new ArgumentOutOfRangeException ();
+
+			var item = items [index];
+
+			OnRemove (item, index);
+
+			Shift (index, -1);
+			version++;
+		}
+
+		public bool Remove (T item)
+		{
+			var index = IndexOf (item);
+			if (index == -1)
+				return false;
+
+			OnRemove (item, index);
+
+			Shift (index, -1);
+			version++;
+
+			return true;
+		}
+
+		public void Clear ()
+		{
+			OnClear ();
+
+			Array.Clear (items, 0, size);
+			size = 0;
+			version++;
+		}
+
+		public void CopyTo (T [] array, int arrayIndex)
+		{
+			Array.Copy (items, 0, array, arrayIndex, size);
+		}
+
+		public T [] ToArray ()
+		{
+			var array = new T [size];
+			Array.Copy (items, 0, array, 0, size);
+			return array;
+		}
+
+		void CheckIndex (int index)
+		{
+			if (index < 0 || index > size)
+				throw new ArgumentOutOfRangeException ();
+		}
+
+		void Shift (int start, int delta)
+		{
+			if (delta < 0)
+				start -= delta;
+
+			if (start < size)
+				Array.Copy (items, start, items, start + delta, size - start);
+
+			size += delta;
+
+			if (delta < 0)
+				Array.Clear (items, size, -delta);
+		}
+
+		protected virtual void OnAdd (T item, int index)
+		{
+		}
+
+		protected virtual void OnInsert (T item, int index)
+		{
+		}
+
+		protected virtual void OnSet (T item, int index)
+		{
+		}
+
+		protected virtual void OnRemove (T item, int index)
+		{
+		}
+
+		protected virtual void OnClear ()
+		{
+		}
+
+		internal virtual void Grow (int desired)
+		{
+			int new_size = size + desired;
+			if (new_size <= items.Length)
+				return;
+
+			const int default_capacity = 4;
+
+			new_size = System.Math.Max (
+				System.Math.Max (items.Length * 2, default_capacity),
+				new_size);
+
+			Resize (new_size);
+		}
+
+		protected void Resize (int new_size)
+		{
+			if (new_size == size)
+				return;
+			if (new_size < size)
+				throw new ArgumentOutOfRangeException ();
+
+			items = items.Resize (new_size);
+		}
+
+		int IList.Add (object value)
+		{
+			try {
+				Add ((T) value);
+				return size - 1;
+			} catch (InvalidCastException) {
+			} catch (NullReferenceException) {
+			}
+
+			throw new ArgumentException ();
+		}
+
+		void IList.Clear ()
+		{
+			Clear ();
+		}
+
+		bool IList.Contains (object value)
+		{
+			return ((IList) this).IndexOf (value) > -1;
+		}
+
+		int IList.IndexOf (object value)
+		{
+			try {
+				return IndexOf ((T) value);
+			} catch (InvalidCastException) {
+			} catch (NullReferenceException) {
+			}
+
+			return -1;
+		}
+
+		void IList.Insert (int index, object value)
+		{
+			CheckIndex (index);
+
+			try {
+				Insert (index, (T) value);
+				return;
+			} catch (InvalidCastException) {
+			} catch (NullReferenceException) {
+			}
+
+			throw new ArgumentException ();
+		}
+
+		void IList.Remove (object value)
+		{
+			try {
+				Remove ((T) value);
+			} catch (InvalidCastException) {
+			} catch (NullReferenceException) {
+			}
+		}
+
+		void IList.RemoveAt (int index)
+		{
+			RemoveAt (index);
+		}
+
+		void ICollection.CopyTo (Array array, int index)
+		{
+			Array.Copy (items, 0, array, index, size);
+		}
+
+		public Enumerator GetEnumerator ()
+		{
+			return new Enumerator (this);
+		}
+
+		IEnumerator IEnumerable.GetEnumerator ()
+		{
+			return new Enumerator (this);
+		}
+
+		IEnumerator<T> IEnumerable<T>.GetEnumerator ()
+		{
+			return new Enumerator (this);
+		}
+
+		public struct Enumerator : IEnumerator<T>, IDisposable {
+
+			Collection<T> collection;
+			T current;
+
+			int next;
+			readonly int version;
+
+			public T Current {
+				get { return current; }
+			}
+
+			object IEnumerator.Current {
+				get {
+					CheckState ();
+
+					if (next <= 0)
+						throw new InvalidOperationException ();
+
+					return current;
+				}
+			}
+
+			internal Enumerator (Collection<T> collection)
+				: this ()
+			{
+				this.collection = collection;
+				this.version = collection.version;
+			}
+
+			public bool MoveNext ()
+			{
+				CheckState ();
+
+				if (next < 0)
+					return false;
+
+				if (next < collection.size) {
+					current = collection.items [next++];
+					return true;
+				}
+
+				next = -1;
+				return false;
+			}
+
+			public void Reset ()
+			{
+				CheckState ();
+
+				next = 0;
+			}
+
+			void CheckState ()
+			{
+				if (collection == null)
+					throw new ObjectDisposedException (GetType ().FullName);
+
+				if (version != collection.version)
+					throw new InvalidOperationException ();
+			}
+
+			public void Dispose ()
+			{
+				collection = null;
+			}
+		}
+	}
+}
diff --git a/src/Mono/Collections/Generic/ReadOnlyCollection.cs b/src/Mono/Collections/Generic/ReadOnlyCollection.cs
new file mode 100644
index 00000000..fe784149
--- /dev/null
+++ b/src/Mono/Collections/Generic/ReadOnlyCollection.cs
@@ -0,0 +1,94 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Mono.Collections.Generic {
+
+	public sealed class ReadOnlyCollection<T> : Collection<T>, ICollection<T>, IList {
+
+		static ReadOnlyCollection<T> empty;
+
+		public static ReadOnlyCollection<T> Empty {
+			get { return empty ?? (empty = new ReadOnlyCollection<T> ()); }
+		}
+
+		bool ICollection<T>.IsReadOnly {
+			get { return true; }
+		}
+
+		bool IList.IsFixedSize {
+			get { return true; }
+		}
+
+		bool IList.IsReadOnly {
+			get { return true; }
+		}
+
+		ReadOnlyCollection ()
+		{
+		}
+
+		public ReadOnlyCollection (T [] array)
+		{
+			if (array == null)
+				throw new ArgumentNullException ();
+
+			Initialize (array, array.Length);
+		}
+
+		public ReadOnlyCollection (Collection<T> collection)
+		{
+			if (collection == null)
+				throw new ArgumentNullException ();
+
+			Initialize (collection.items, collection.size);
+		}
+
+		void Initialize (T [] items, int size)
+		{
+			this.items = new T [size];
+			Array.Copy (items, 0, this.items, 0, size);
+			this.size = size;
+		}
+
+		internal override void Grow (int desired)
+		{
+			throw new InvalidOperationException ();
+		}
+
+		protected override void OnAdd (T item, int index)
+		{
+			throw new InvalidOperationException ();
+		}
+
+		protected override void OnClear ()
+		{
+			throw new InvalidOperationException ();
+		}
+
+		protected override void OnInsert (T item, int index)
+		{
+			throw new InvalidOperationException ();
+		}
+
+		protected override void OnRemove (T item, int index)
+		{
+			throw new InvalidOperationException ();
+		}
+
+		protected override void OnSet (T item, int index)
+		{
+			throw new InvalidOperationException ();
+		}
+	}
+}
diff --git a/src/Mono/Disposable.cs b/src/Mono/Disposable.cs
new file mode 100644
index 00000000..dc2b1a3d
--- /dev/null
+++ b/src/Mono/Disposable.cs
@@ -0,0 +1,45 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace Mono {
+
+	static class Disposable {
+
+		public static Disposable<T> Owned<T> (T value) where T : class, IDisposable
+		{
+			return new Disposable<T> (value, owned: true);
+		}
+
+		public static Disposable<T> NotOwned<T> (T value) where T : class, IDisposable
+		{
+			return new Disposable<T> (value, owned: false);
+		}
+	}
+
+	struct Disposable<T> : IDisposable where T : class, IDisposable {
+
+		internal readonly T value;
+		readonly bool owned;
+
+		public Disposable (T value, bool owned)
+		{
+			this.value = value;
+			this.owned = owned;
+		}
+
+		public void Dispose ()
+		{
+			if (value != null && owned)
+				value.Dispose ();
+		}
+	}
+}
diff --git a/src/Mono/Empty.cs b/src/Mono/Empty.cs
new file mode 100644
index 00000000..de28e656
--- /dev/null
+++ b/src/Mono/Empty.cs
@@ -0,0 +1,62 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using Mono.Collections.Generic;
+
+namespace Mono {
+
+	static class Empty<T> {
+
+		public static readonly T [] Array = new T [0];
+	}
+
+	class ArgumentNullOrEmptyException : ArgumentException {
+
+		public ArgumentNullOrEmptyException (string paramName)
+			: base ("Argument null or empty", paramName)
+		{
+		}
+	}
+}
+
+namespace Mono.Cecil {
+
+	static partial class Mixin {
+
+		public static bool IsNullOrEmpty<T> (this T [] self)
+		{
+			return self == null || self.Length == 0;
+		}
+
+		public static bool IsNullOrEmpty<T> (this Collection<T> self)
+		{
+			return self == null || self.size == 0;
+		}
+
+		public static T [] Resize<T> (this T [] self, int length)
+		{
+			Array.Resize (ref self, length);
+			return self;
+		}
+
+		public static T [] Add<T> (this T [] self, T item)
+		{
+			if (self == null) {
+				self = new [] { item };
+				return self;
+			}
+
+			self = self.Resize (self.Length + 1);
+			self [self.Length - 1] = item;
+			return self;
+		}
+	}
+}
diff --git a/src/Mono/MergeSort.cs b/src/Mono/MergeSort.cs
new file mode 100644
index 00000000..5d856eaf
--- /dev/null
+++ b/src/Mono/MergeSort.cs
@@ -0,0 +1,66 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+
+namespace Mono {
+
+	class MergeSort<T> {
+		private readonly T [] elements;
+		private readonly T [] buffer;
+		private readonly IComparer<T> comparer;
+
+		private MergeSort (T [] elements, IComparer<T> comparer)
+		{
+			this.elements = elements;
+			this.buffer = new T [elements.Length];
+			Array.Copy (this.elements, this.buffer, elements.Length);
+			this.comparer = comparer;
+		}
+
+		public static void Sort (T [] source, IComparer<T> comparer)
+		{
+			Sort (source, 0, source.Length, comparer);
+		}
+
+		public static void Sort (T [] source, int start, int length, IComparer<T> comparer)
+		{
+			new MergeSort<T> (source, comparer).Sort (start, length);
+		}
+
+		private void Sort (int start, int length)
+		{
+			TopDownSplitMerge (this.buffer, this.elements, start, length);
+		}
+
+		private void TopDownSplitMerge (T [] a, T [] b, int start, int end)
+		{
+			if (end - start < 2)
+				return;
+
+			int middle = (end + start) / 2;
+			TopDownSplitMerge (b, a, start, middle);
+			TopDownSplitMerge (b, a, middle, end);
+			TopDownMerge (a, b, start, middle, end);
+		}
+
+		private void TopDownMerge (T [] a, T [] b, int start, int middle, int end)
+		{
+			for (int i = start, j = middle, k = start; k < end; k++) {
+				if (i < middle && (j >= end || comparer.Compare (a [i], a [j]) <= 0)) {
+					b [k] = a [i++];
+				} else {
+					b [k] = a [j++];
+				}
+			}
+		}
+	}
+}
diff --git a/src/Mono/Security/Cryptography/CryptoConvert.cs b/src/Mono/Security/Cryptography/CryptoConvert.cs
new file mode 100644
index 00000000..51f4ca13
--- /dev/null
+++ b/src/Mono/Security/Cryptography/CryptoConvert.cs
@@ -0,0 +1,253 @@
+//
+// CryptoConvert.cs - Crypto Convertion Routines
+//
+// Author:
+//	Sebastien Pouliot  <sebastien@ximian.com>
+//
+// (C) 2003 Motus Technologies Inc. (http://www.motus.com)
+// Copyright (C) 2004-2006 Novell Inc. (http://www.novell.com)
+//
+// 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.
+//
+
+#if !READ_ONLY
+
+#if !NET_CORE
+
+using System;
+using System.Security.Cryptography;
+
+namespace Mono.Security.Cryptography {
+
+	static class CryptoConvert {
+
+		static private int ToInt32LE (byte [] bytes, int offset)
+		{
+			return (bytes [offset+3] << 24) | (bytes [offset+2] << 16) | (bytes [offset+1] << 8) | bytes [offset];
+		}
+
+		static private uint ToUInt32LE (byte [] bytes, int offset)
+		{
+			return (uint)((bytes [offset+3] << 24) | (bytes [offset+2] << 16) | (bytes [offset+1] << 8) | bytes [offset]);
+		}
+
+		static private byte[] Trim (byte[] array)
+		{
+			for (int i=0; i < array.Length; i++) {
+				if (array [i] != 0x00) {
+					byte[] result = new byte [array.Length - i];
+					Buffer.BlockCopy (array, i, result, 0, result.Length);
+					return result;
+				}
+			}
+			return null;
+		}
+
+		static RSA FromCapiPrivateKeyBlob (byte[] blob, int offset)
+		{
+			RSAParameters rsap = new RSAParameters ();
+			try {
+				if ((blob [offset]   != 0x07) ||				// PRIVATEKEYBLOB (0x07)
+				    (blob [offset+1] != 0x02) ||				// Version (0x02)
+				    (blob [offset+2] != 0x00) ||				// Reserved (word)
+				    (blob [offset+3] != 0x00) ||
+				    (ToUInt32LE (blob, offset+8) != 0x32415352))	// DWORD magic = RSA2
+					throw new CryptographicException ("Invalid blob header");
+
+				// ALGID (CALG_RSA_SIGN, CALG_RSA_KEYX, ...)
+				// int algId = ToInt32LE (blob, offset+4);
+
+				// DWORD bitlen
+				int bitLen = ToInt32LE (blob, offset+12);
+
+				// DWORD public exponent
+				byte[] exp = new byte [4];
+				Buffer.BlockCopy (blob, offset+16, exp, 0, 4);
+				Array.Reverse (exp);
+				rsap.Exponent = Trim (exp);
+
+				int pos = offset+20;
+				// BYTE modulus[rsapubkey.bitlen/8];
+				int byteLen = (bitLen >> 3);
+				rsap.Modulus = new byte [byteLen];
+				Buffer.BlockCopy (blob, pos, rsap.Modulus, 0, byteLen);
+				Array.Reverse (rsap.Modulus);
+				pos += byteLen;
+
+				// BYTE prime1[rsapubkey.bitlen/16];
+				int byteHalfLen = (byteLen >> 1);
+				rsap.P = new byte [byteHalfLen];
+				Buffer.BlockCopy (blob, pos, rsap.P, 0, byteHalfLen);
+				Array.Reverse (rsap.P);
+				pos += byteHalfLen;
+
+				// BYTE prime2[rsapubkey.bitlen/16];
+				rsap.Q = new byte [byteHalfLen];
+				Buffer.BlockCopy (blob, pos, rsap.Q, 0, byteHalfLen);
+				Array.Reverse (rsap.Q);
+				pos += byteHalfLen;
+
+				// BYTE exponent1[rsapubkey.bitlen/16];
+				rsap.DP = new byte [byteHalfLen];
+				Buffer.BlockCopy (blob, pos, rsap.DP, 0, byteHalfLen);
+				Array.Reverse (rsap.DP);
+				pos += byteHalfLen;
+
+				// BYTE exponent2[rsapubkey.bitlen/16];
+				rsap.DQ = new byte [byteHalfLen];
+				Buffer.BlockCopy (blob, pos, rsap.DQ, 0, byteHalfLen);
+				Array.Reverse (rsap.DQ);
+				pos += byteHalfLen;
+
+				// BYTE coefficient[rsapubkey.bitlen/16];
+				rsap.InverseQ = new byte [byteHalfLen];
+				Buffer.BlockCopy (blob, pos, rsap.InverseQ, 0, byteHalfLen);
+				Array.Reverse (rsap.InverseQ);
+				pos += byteHalfLen;
+
+				// ok, this is hackish but CryptoAPI support it so...
+				// note: only works because CRT is used by default
+				// http://bugzilla.ximian.com/show_bug.cgi?id=57941
+				rsap.D = new byte [byteLen]; // must be allocated
+				if (pos + byteLen + offset <= blob.Length) {
+					// BYTE privateExponent[rsapubkey.bitlen/8];
+					Buffer.BlockCopy (blob, pos, rsap.D, 0, byteLen);
+					Array.Reverse (rsap.D);
+				}
+			}
+			catch (Exception e) {
+				throw new CryptographicException ("Invalid blob.", e);
+			}
+
+			RSA rsa = null;
+			try {
+				rsa = RSA.Create ();
+				rsa.ImportParameters (rsap);
+			}
+			catch (CryptographicException) {
+				// this may cause problem when this code is run under
+				// the SYSTEM identity on Windows (e.g. ASP.NET). See
+				// http://bugzilla.ximian.com/show_bug.cgi?id=77559
+				bool throws = false;
+				try {
+					CspParameters csp = new CspParameters ();
+					csp.Flags = CspProviderFlags.UseMachineKeyStore;
+					rsa = new RSACryptoServiceProvider (csp);
+					rsa.ImportParameters (rsap);
+				}
+				catch {
+					throws = true;
+				}
+
+				if (throws) {
+					// rethrow original, not the latter, exception if this fails
+					throw;
+				}
+			}
+			return rsa;
+		}
+
+		static RSA FromCapiPublicKeyBlob (byte[] blob, int offset)
+		{
+			try {
+				if ((blob [offset]   != 0x06) ||				// PUBLICKEYBLOB (0x06)
+				    (blob [offset+1] != 0x02) ||				// Version (0x02)
+				    (blob [offset+2] != 0x00) ||				// Reserved (word)
+				    (blob [offset+3] != 0x00) ||
+				    (ToUInt32LE (blob, offset+8) != 0x31415352))	// DWORD magic = RSA1
+					throw new CryptographicException ("Invalid blob header");
+
+				// ALGID (CALG_RSA_SIGN, CALG_RSA_KEYX, ...)
+				// int algId = ToInt32LE (blob, offset+4);
+
+				// DWORD bitlen
+				int bitLen = ToInt32LE (blob, offset+12);
+
+				// DWORD public exponent
+				RSAParameters rsap = new RSAParameters ();
+				rsap.Exponent = new byte [3];
+				rsap.Exponent [0] = blob [offset+18];
+				rsap.Exponent [1] = blob [offset+17];
+				rsap.Exponent [2] = blob [offset+16];
+
+				int pos = offset+20;
+				// BYTE modulus[rsapubkey.bitlen/8];
+				int byteLen = (bitLen >> 3);
+				rsap.Modulus = new byte [byteLen];
+				Buffer.BlockCopy (blob, pos, rsap.Modulus, 0, byteLen);
+				Array.Reverse (rsap.Modulus);
+
+				RSA rsa = null;
+				try {
+					rsa = RSA.Create ();
+					rsa.ImportParameters (rsap);
+				}
+				catch (CryptographicException) {
+					// this may cause problem when this code is run under
+					// the SYSTEM identity on Windows (e.g. ASP.NET). See
+					// http://bugzilla.ximian.com/show_bug.cgi?id=77559
+					CspParameters csp = new CspParameters ();
+					csp.Flags = CspProviderFlags.UseMachineKeyStore;
+					rsa = new RSACryptoServiceProvider (csp);
+					rsa.ImportParameters (rsap);
+				}
+				return rsa;
+			}
+			catch (Exception e) {
+				throw new CryptographicException ("Invalid blob.", e);
+			}
+		}
+
+		// PRIVATEKEYBLOB
+		// PUBLICKEYBLOB
+		static public RSA FromCapiKeyBlob (byte[] blob)
+		{
+			return FromCapiKeyBlob (blob, 0);
+		}
+
+		static public RSA FromCapiKeyBlob (byte[] blob, int offset)
+		{
+			if (blob == null)
+				throw new ArgumentNullException ("blob");
+			if (offset >= blob.Length)
+				throw new ArgumentException ("blob is too small.");
+
+			switch (blob [offset]) {
+				case 0x00:
+					// this could be a public key inside an header
+					// like "sn -e" would produce
+					if (blob [offset + 12] == 0x06) {
+						return FromCapiPublicKeyBlob (blob, offset + 12);
+					}
+					break;
+				case 0x06:
+					return FromCapiPublicKeyBlob (blob, offset);
+				case 0x07:
+					return FromCapiPrivateKeyBlob (blob, offset);
+			}
+			throw new CryptographicException ("Unknown blob format.");
+		}
+	}
+}
+
+#endif
+
+#endif
+
diff --git a/src/Mono/Security/Cryptography/CryptoService.cs b/src/Mono/Security/Cryptography/CryptoService.cs
new file mode 100644
index 00000000..840276d2
--- /dev/null
+++ b/src/Mono/Security/Cryptography/CryptoService.cs
@@ -0,0 +1,158 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+#if !READ_ONLY
+
+#if !NET_CORE
+
+using System;
+using System.IO;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Runtime.Serialization;
+
+using Mono.Security.Cryptography;
+
+using Mono.Cecil.PE;
+
+namespace Mono.Cecil {
+
+	// Most of this code has been adapted
+	// from Jeroen Frijters' fantastic work
+	// in IKVM.Reflection.Emit. Thanks!
+
+	static class CryptoService {
+
+		public static void StrongName (Stream stream, ImageWriter writer, StrongNameKeyPair key_pair)
+		{
+			int strong_name_pointer;
+
+			var strong_name = CreateStrongName (key_pair, HashStream (stream, writer, out strong_name_pointer));
+			PatchStrongName (stream, strong_name_pointer, strong_name);
+		}
+
+		static void PatchStrongName (Stream stream, int strong_name_pointer, byte [] strong_name)
+		{
+			stream.Seek (strong_name_pointer, SeekOrigin.Begin);
+			stream.Write (strong_name, 0, strong_name.Length);
+		}
+
+		static byte [] CreateStrongName (StrongNameKeyPair key_pair, byte [] hash)
+		{
+			const string hash_algo = "SHA1";
+
+			using (var rsa = key_pair.CreateRSA ()) {
+				var formatter = new RSAPKCS1SignatureFormatter (rsa);
+				formatter.SetHashAlgorithm (hash_algo);
+
+				byte [] signature = formatter.CreateSignature (hash);
+				Array.Reverse (signature);
+
+				return signature;
+			}
+		}
+
+		static byte [] HashStream (Stream stream, ImageWriter writer, out int strong_name_pointer)
+		{
+			const int buffer_size = 8192;
+
+			var text = writer.text;
+			var header_size = (int) writer.GetHeaderSize ();
+			var text_section_pointer = (int) text.PointerToRawData;
+			var strong_name_directory = writer.GetStrongNameSignatureDirectory ();
+
+			if (strong_name_directory.Size == 0)
+				throw new InvalidOperationException ();
+
+			strong_name_pointer = (int) (text_section_pointer
+				+ (strong_name_directory.VirtualAddress - text.VirtualAddress));
+			var strong_name_length = (int) strong_name_directory.Size;
+
+			var sha1 = new SHA1Managed ();
+			var buffer = new byte [buffer_size];
+			using (var crypto_stream = new CryptoStream (Stream.Null, sha1, CryptoStreamMode.Write)) {
+
+				stream.Seek (0, SeekOrigin.Begin);
+				CopyStreamChunk (stream, crypto_stream, buffer, header_size);
+
+				stream.Seek (text_section_pointer, SeekOrigin.Begin);
+				CopyStreamChunk (stream, crypto_stream, buffer, (int) strong_name_pointer - text_section_pointer);
+
+				stream.Seek (strong_name_length, SeekOrigin.Current);
+				CopyStreamChunk (stream, crypto_stream, buffer, (int) (stream.Length - (strong_name_pointer + strong_name_length)));
+			}
+
+			return sha1.Hash;
+		}
+
+		static void CopyStreamChunk (Stream stream, Stream dest_stream, byte [] buffer, int length)
+		{
+			while (length > 0) {
+				int read = stream.Read (buffer, 0, System.Math.Min (buffer.Length, length));
+				dest_stream.Write (buffer, 0, read);
+				length -= read;
+			}
+		}
+
+		public static byte [] ComputeHash (string file)
+		{
+			if (!File.Exists (file))
+				return Empty<byte>.Array;
+
+			const int buffer_size = 8192;
+
+			var sha1 = new SHA1Managed ();
+
+			using (var stream = new FileStream (file, FileMode.Open, FileAccess.Read, FileShare.Read)) {
+
+				var buffer = new byte [buffer_size];
+
+				using (var crypto_stream = new CryptoStream (Stream.Null, sha1, CryptoStreamMode.Write))
+					CopyStreamChunk (stream, crypto_stream, buffer, (int) stream.Length);
+			}
+
+			return sha1.Hash;
+		}
+	}
+
+	static partial class Mixin {
+
+		public static RSA CreateRSA (this StrongNameKeyPair key_pair)
+		{
+			byte [] key;
+			string key_container;
+
+			if (!TryGetKeyContainer (key_pair, out key, out key_container))
+				return CryptoConvert.FromCapiKeyBlob (key);
+
+			var parameters = new CspParameters {
+				Flags = CspProviderFlags.UseMachineKeyStore,
+				KeyContainerName = key_container,
+				KeyNumber = 2,
+			};
+
+			return new RSACryptoServiceProvider (parameters);
+		}
+
+		static bool TryGetKeyContainer (ISerializable key_pair, out byte [] key, out string key_container)
+		{
+			var info = new SerializationInfo (typeof (StrongNameKeyPair), new FormatterConverter ());
+			key_pair.GetObjectData (info, new StreamingContext ());
+
+			key = (byte []) info.GetValue ("_keyPairArray", typeof (byte []));
+			key_container = info.GetString ("_keyPairContainer");
+			return key_container != null;
+		}
+	}
+}
+
+#endif
+
+#endif
diff --git a/src/Mono/Type.cs b/src/Mono/Type.cs
new file mode 100644
index 00000000..fd53f81b
--- /dev/null
+++ b/src/Mono/Type.cs
@@ -0,0 +1,137 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Reflection;
+
+#if NET_CORE
+using System.Collections.Generic;
+#endif
+
+namespace Mono {
+
+#if NET_CORE
+	enum TypeCode {
+		Empty = 0,
+		Object = 1,
+		DBNull = 2,
+		Boolean = 3,
+		Char = 4,
+		SByte = 5,
+		Byte = 6,
+		Int16 = 7,
+		UInt16 = 8,
+		Int32 = 9,
+		UInt32 = 10,
+		Int64 = 11,
+		UInt64 = 12,
+		Single = 13,
+		Double = 14,
+		Decimal = 15,
+		DateTime = 16,
+		String = 18
+	}
+#endif
+
+	static class TypeExtensions {
+
+#if NET_CORE
+		private static readonly Dictionary<Type, TypeCode> TypeCodeMap = new Dictionary<Type, TypeCode>
+		{
+			{ typeof (bool), TypeCode.Boolean },
+			{ typeof (char), TypeCode.Char },
+			{ typeof (sbyte), TypeCode.SByte },
+			{ typeof (byte), TypeCode.Byte },
+			{ typeof (short), TypeCode.Int16 },
+			{ typeof (ushort), TypeCode.UInt16 },
+			{ typeof (int), TypeCode.Int32 },
+			{ typeof (uint), TypeCode.UInt32 },
+			{ typeof (long), TypeCode.Int64 },
+			{ typeof (ulong), TypeCode.UInt64 },
+			{ typeof (float), TypeCode.Single },
+			{ typeof (double), TypeCode.Double },
+			{ typeof (decimal), TypeCode.Decimal },
+			{ typeof (DateTime), TypeCode.DateTime },
+			{ typeof (string), TypeCode.String },
+		};
+#endif
+
+		public static TypeCode GetTypeCode (this Type type)
+		{
+#if NET_CORE
+			if (type == null)
+				return TypeCode.Empty;
+
+			TypeCode code;
+			if (!TypeCodeMap.TryGetValue (type, out code))
+				return TypeCode.Object;
+
+			return code;
+#else
+			return Type.GetTypeCode (type);
+#endif
+		}
+
+		public static Assembly Assembly (this Type type)
+		{
+#if NET_CORE
+			return type.GetTypeInfo ().Assembly;
+#else
+			return type.Assembly;
+#endif
+		}
+
+		public static MethodBase DeclaringMethod (this Type type)
+		{
+#if NET_CORE
+			return type.GetTypeInfo ().DeclaringMethod;
+#else
+			return type.DeclaringMethod;
+#endif
+		}
+
+		public static Type [] GetGenericArguments (this Type type)
+		{
+#if NET_CORE
+			var info = type.GetTypeInfo ();
+			return info.IsGenericTypeDefinition ? info.GenericTypeParameters : info.GenericTypeArguments;
+#else
+			return type.GetGenericArguments ();
+#endif
+		}
+
+		public static bool IsGenericType (this Type type)
+		{
+#if NET_CORE
+			return type.GetTypeInfo ().IsGenericType;
+#else
+			return type.IsGenericType;
+#endif
+		}
+
+		public static bool IsGenericTypeDefinition (this Type type)
+		{
+#if NET_CORE
+			return type.GetTypeInfo ().IsGenericTypeDefinition;
+#else
+			return type.IsGenericTypeDefinition;
+#endif
+		}
+
+		public static bool IsValueType (this Type type)
+		{
+#if NET_CORE
+			return type.GetTypeInfo ().IsValueType;
+#else
+			return type.IsValueType;
+#endif
+		}
+	}
+}
diff --git a/src/Newtonsoft.Json/Bson/BsonBinaryType.cs b/src/Newtonsoft.Json/Bson/BsonBinaryType.cs
new file mode 100644
index 00000000..638039fa
--- /dev/null
+++ b/src/Newtonsoft.Json/Bson/BsonBinaryType.cs
@@ -0,0 +1,44 @@
+#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 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/src/Newtonsoft.Json/Bson/BsonBinaryWriter.cs b/src/Newtonsoft.Json/Bson/BsonBinaryWriter.cs
new file mode 100644
index 00000000..815bbe11
--- /dev/null
+++ b/src/Newtonsoft.Json/Bson/BsonBinaryWriter.cs
@@ -0,0 +1,328 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Bson/BsonObjectId.cs b/src/Newtonsoft.Json/Bson/BsonObjectId.cs
new file mode 100644
index 00000000..4c57e7f9
--- /dev/null
+++ b/src/Newtonsoft.Json/Bson/BsonObjectId.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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Bson/BsonReader.cs b/src/Newtonsoft.Json/Bson/BsonReader.cs
new file mode 100644
index 00000000..fe8a2481
--- /dev/null
+++ b/src/Newtonsoft.Json/Bson/BsonReader.cs
@@ -0,0 +1,834 @@
+#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 Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+using Newtonsoft.Json.Linq;
+
+namespace 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/src/Newtonsoft.Json/Bson/BsonToken.cs b/src/Newtonsoft.Json/Bson/BsonToken.cs
new file mode 100644
index 00000000..631584c9
--- /dev/null
+++ b/src/Newtonsoft.Json/Bson/BsonToken.cs
@@ -0,0 +1,166 @@
+#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;
+
+namespace 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/src/Newtonsoft.Json/Bson/BsonType.cs b/src/Newtonsoft.Json/Bson/BsonType.cs
new file mode 100644
index 00000000..e1192985
--- /dev/null
+++ b/src/Newtonsoft.Json/Bson/BsonType.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
+
+namespace 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/src/Newtonsoft.Json/Bson/BsonWriter.cs b/src/Newtonsoft.Json/Bson/BsonWriter.cs
new file mode 100644
index 00000000..3d1c0a15
--- /dev/null
+++ b/src/Newtonsoft.Json/Bson/BsonWriter.cs
@@ -0,0 +1,537 @@
+#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 Newtonsoft.Json.Utilities;
+using Newtonsoft.Json.Linq;
+using System.Globalization;
+
+namespace 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/src/Newtonsoft.Json/ConstructorHandling.cs b/src/Newtonsoft.Json/ConstructorHandling.cs
new file mode 100644
index 00000000..e710744c
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Converters/BinaryConverter.cs b/src/Newtonsoft.Json/Converters/BinaryConverter.cs
new file mode 100644
index 00000000..83f0717b
--- /dev/null
+++ b/src/Newtonsoft.Json/Converters/BinaryConverter.cs
@@ -0,0 +1,208 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Collections.Generic;
+#if HAVE_ADO_NET
+using System.Data.SqlTypes;
+#endif
+
+namespace 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());
+                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);
+
+                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/src/Newtonsoft.Json/Converters/BsonObjectIdConverter.cs b/src/Newtonsoft.Json/Converters/BsonObjectIdConverter.cs
new file mode 100644
index 00000000..5571c37f
--- /dev/null
+++ b/src/Newtonsoft.Json/Converters/BsonObjectIdConverter.cs
@@ -0,0 +1,91 @@
+#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 Newtonsoft.Json.Bson;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Converters/CustomCreationConverter.cs b/src/Newtonsoft.Json/Converters/CustomCreationConverter.cs
new file mode 100644
index 00000000..8f54c0c6
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Converters/DataSetConverter.cs b/src/Newtonsoft.Json/Converters/DataSetConverter.cs
new file mode 100644
index 00000000..7605f9c4
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Serialization;
+
+namespace 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/src/Newtonsoft.Json/Converters/DataTableConverter.cs b/src/Newtonsoft.Json/Converters/DataTableConverter.cs
new file mode 100644
index 00000000..5a7f6886
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using System;
+using System.Data;
+using Newtonsoft.Json.Serialization;
+
+namespace 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/src/Newtonsoft.Json/Converters/DateTimeConverterBase.cs b/src/Newtonsoft.Json/Converters/DateTimeConverterBase.cs
new file mode 100644
index 00000000..076d639b
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs b/src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs
new file mode 100644
index 00000000..d850db9c
--- /dev/null
+++ b/src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs
@@ -0,0 +1,280 @@
+#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 Newtonsoft.Json.Linq;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+using Newtonsoft.Json.Serialization;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace 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 List<UnionCase> Cases;
+            public FSharpFunction TagReader { get; set; }
+        }
+
+        internal class UnionCase
+        {
+            public int Tag;
+            public string Name;
+            public PropertyInfo[] Fields;
+            public FSharpFunction FieldReader;
+            public FSharpFunction 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.GetUnionCases(null, t, null);
+
+            object caseInfo = cases.First();
+
+            Type unionType = (Type)FSharpUtils.GetUnionCaseInfoDeclaringType(caseInfo);
+            return unionType;
+        }
+
+        private static Union CreateUnion(Type t)
+        {
+            Union u = new Union();
+
+            u.TagReader = (FSharpFunction)FSharpUtils.PreComputeUnionTagReader(null, t, null);
+            u.Cases = new List<UnionCase>();
+
+            object[] cases = (object[])FSharpUtils.GetUnionCases(null, t, null);
+
+            foreach (object unionCaseInfo in cases)
+            {
+                UnionCase unionCase = new UnionCase();
+                unionCase.Tag = (int)FSharpUtils.GetUnionCaseInfoTag(unionCaseInfo);
+                unionCase.Name = (string)FSharpUtils.GetUnionCaseInfoName(unionCaseInfo);
+                unionCase.Fields = (PropertyInfo[])FSharpUtils.GetUnionCaseInfoFields(unionCaseInfo);
+                unionCase.FieldReader = (FSharpFunction)FSharpUtils.PreComputeUnionReader(null, unionCaseInfo, null);
+                unionCase.Constructor = (FSharpFunction)FSharpUtils.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)
+        {
+            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.IsUnion(null, objectType, null);
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Converters/EntityKeyMemberConverter.cs b/src/Newtonsoft.Json/Converters/EntityKeyMemberConverter.cs
new file mode 100644
index 00000000..aeeb87a0
--- /dev/null
+++ b/src/Newtonsoft.Json/Converters/EntityKeyMemberConverter.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_ENTITY_FRAMEWORK
+using System;
+using Newtonsoft.Json.Serialization;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace 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)
+        {
+            EnsureReflectionObject(value.GetType());
+
+            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);
+
+            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/src/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs b/src/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs
new file mode 100644
index 00000000..c946692b
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Converters/IsoDateTimeConverter.cs b/src/Newtonsoft.Json/Converters/IsoDateTimeConverter.cs
new file mode 100644
index 00000000..5a2e9322
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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 = (string.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 (string.IsNullOrEmpty(dateText) && nullable)
+            {
+                return null;
+            }
+
+#if HAVE_DATE_TIME_OFFSET
+            if (t == typeof(DateTimeOffset))
+            {
+                if (!string.IsNullOrEmpty(_dateTimeFormat))
+                {
+                    return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
+                }
+                else
+                {
+                    return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles);
+                }
+            }
+#endif
+
+            if (!string.IsNullOrEmpty(_dateTimeFormat))
+            {
+                return DateTime.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
+            }
+            else
+            {
+                return DateTime.Parse(dateText, Culture, _dateTimeStyles);
+            }
+        }
+    }
+}
diff --git a/src/Newtonsoft.Json/Converters/JavaScriptDateTimeConverter.cs b/src/Newtonsoft.Json/Converters/JavaScriptDateTimeConverter.cs
new file mode 100644
index 00000000..24194b76
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Converters/KeyValuePairConverter.cs b/src/Newtonsoft.Json/Converters/KeyValuePairConverter.cs
new file mode 100644
index 00000000..2d419703
--- /dev/null
+++ b/src/Newtonsoft.Json/Converters/KeyValuePairConverter.cs
@@ -0,0 +1,153 @@
+#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 Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+using System.Reflection;
+
+namespace 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)
+        {
+            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/src/Newtonsoft.Json/Converters/RegexConverter.cs b/src/Newtonsoft.Json/Converters/RegexConverter.cs
new file mode 100644
index 00000000..719a06ad
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Bson;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Converters/StringEnumConverter.cs b/src/Newtonsoft.Json/Converters/StringEnumConverter.cs
new file mode 100644
index 00000000..6639235e
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using Newtonsoft.Json.Serialization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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 (enumText == string.Empty && 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/src/Newtonsoft.Json/Converters/UnixDateTimeConverter.cs b/src/Newtonsoft.Json/Converters/UnixDateTimeConverter.cs
new file mode 100644
index 00000000..c5b03bb5
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Converters/VersionConverter.cs b/src/Newtonsoft.Json/Converters/VersionConverter.cs
new file mode 100644
index 00000000..df52718f
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Converters/XmlNodeConverter.cs b/src/Newtonsoft.Json/Converters/XmlNodeConverter.cs
new file mode 100644
index 00000000..6e7ba059
--- /dev/null
+++ b/src/Newtonsoft.Json/Converters/XmlNodeConverter.cs
@@ -0,0 +1,2217 @@
+#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 Newtonsoft.Json.Serialization;
+#if HAVE_XLINQ
+using System.Xml.Linq;
+#endif
+using Newtonsoft.Json.Utilities;
+using System.Runtime.CompilerServices;
+
+namespace 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;
+
+        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 (!string.IsNullOrEmpty(namespaceUri) && namespaceUri != ParentNode?.NamespaceUri)
+            {
+                if (string.IsNullOrEmpty(GetPrefixOfNamespace(namespaceUri)))
+                {
+                    bool namespaceDeclared = false;
+
+                    if (Element.HasAttributes)
+                    {
+                        foreach (XAttribute attribute in Element.Attributes())
+                        {
+                            if (attribute.Name.LocalName == "xmlns" && string.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 (!string.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;
+
+                                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 (!string.IsNullOrEmpty(declaration.Version))
+                    {
+                        writer.WritePropertyName("@version");
+                        writer.WriteValue(declaration.Version);
+                    }
+                    if (!string.IsNullOrEmpty(declaration.Encoding))
+                    {
+                        writer.WritePropertyName("@encoding");
+                        writer.WriteValue(declaration.Encoding);
+                    }
+                    if (!string.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 (!string.IsNullOrEmpty(documentType.Name))
+                    {
+                        writer.WritePropertyName("@name");
+                        writer.WriteValue(documentType.Name);
+                    }
+                    if (!string.IsNullOrEmpty(documentType.Public))
+                    {
+                        writer.WritePropertyName("@public");
+                        writer.WriteValue(documentType.Public);
+                    }
+                    if (!string.IsNullOrEmpty(documentType.System))
+                    {
+                        writer.WritePropertyName("@system");
+                        writer.WriteValue(documentType.System);
+                    }
+                    if (!string.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 (!string.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 (!string.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 (string.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 = (!string.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 = (!string.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 (!string.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 = string.IsNullOrEmpty(elementPrefix) ? manager.DefaultNamespace : manager.LookupNamespace(elementPrefix);
+
+            IXmlElement element = (!string.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 = string.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, 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/src/Newtonsoft.Json/DateFormatHandling.cs b/src/Newtonsoft.Json/DateFormatHandling.cs
new file mode 100644
index 00000000..5c79ec90
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/DateParseHandling.cs b/src/Newtonsoft.Json/DateParseHandling.cs
new file mode 100644
index 00000000..481098c8
--- /dev/null
+++ b/src/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 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="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="DateTimeOffset"/>.
+        /// </summary>
+        DateTimeOffset = 2
+#endif
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/DateTimeZoneHandling.cs b/src/Newtonsoft.Json/DateTimeZoneHandling.cs
new file mode 100644
index 00000000..9877d6e7
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/DefaultJsonNameTable.cs b/src/Newtonsoft.Json/DefaultJsonNameTable.cs
new file mode 100644
index 00000000..4b9618a9
--- /dev/null
+++ b/src/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 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))
+                {
+                    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/src/Newtonsoft.Json/DefaultValueHandling.cs b/src/Newtonsoft.Json/DefaultValueHandling.cs
new file mode 100644
index 00000000..4b5312b8
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Dynamic.snk b/src/Newtonsoft.Json/Dynamic.snk
new file mode 100644
index 00000000..2225208a
Binary files /dev/null and b/src/Newtonsoft.Json/Dynamic.snk differ
diff --git a/src/Newtonsoft.Json/FloatFormatHandling.cs b/src/Newtonsoft.Json/FloatFormatHandling.cs
new file mode 100644
index 00000000..9b6bd4c1
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/FloatParseHandling.cs b/src/Newtonsoft.Json/FloatParseHandling.cs
new file mode 100644
index 00000000..30583944
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/FormatterAssemblyStyle.cs b/src/Newtonsoft.Json/FormatterAssemblyStyle.cs
new file mode 100644
index 00000000..d03a2691
--- /dev/null
+++ b/src/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/src/Newtonsoft.Json/Formatting.cs b/src/Newtonsoft.Json/Formatting.cs
new file mode 100644
index 00000000..9438e63b
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/IArrayPool.cs b/src/Newtonsoft.Json/IArrayPool.cs
new file mode 100644
index 00000000..15717f05
--- /dev/null
+++ b/src/Newtonsoft.Json/IArrayPool.cs
@@ -0,0 +1,22 @@
+namespace 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/src/Newtonsoft.Json/IJsonLineInfo.cs b/src/Newtonsoft.Json/IJsonLineInfo.cs
new file mode 100644
index 00000000..e261c7d4
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonArrayAttribute.cs b/src/Newtonsoft.Json/JsonArrayAttribute.cs
new file mode 100644
index 00000000..96221a7a
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonConstructorAttribute.cs b/src/Newtonsoft.Json/JsonConstructorAttribute.cs
new file mode 100644
index 00000000..cd5d1bb8
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonContainerAttribute.cs b/src/Newtonsoft.Json/JsonContainerAttribute.cs
new file mode 100644
index 00000000..e5ef292d
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Serialization;
+
+namespace 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/src/Newtonsoft.Json/JsonConvert.cs b/src/Newtonsoft.Json/JsonConvert.cs
new file mode 100644
index 00000000..356e06ec
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonConvert.cs
@@ -0,0 +1,1084 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+using System.Xml;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Serialization;
+using System.Text;
+using System.Diagnostics;
+#if HAVE_XLINQ
+using System.Xml.Linq;
+
+#endif
+
+namespace 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 Serialization.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/src/Newtonsoft.Json/JsonConverter.cs b/src/Newtonsoft.Json/JsonConverter.cs
new file mode 100644
index 00000000..2ac14e50
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonConverter.cs
@@ -0,0 +1,147 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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/src/Newtonsoft.Json/JsonConverterAttribute.cs b/src/Newtonsoft.Json/JsonConverterAttribute.cs
new file mode 100644
index 00000000..2c09128c
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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/src/Newtonsoft.Json/JsonConverterCollection.cs b/src/Newtonsoft.Json/JsonConverterCollection.cs
new file mode 100644
index 00000000..b2c04927
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonDictionaryAttribute.cs b/src/Newtonsoft.Json/JsonDictionaryAttribute.cs
new file mode 100644
index 00000000..7ddf4118
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonException.cs b/src/Newtonsoft.Json/JsonException.cs
new file mode 100644
index 00000000..a5fb5775
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/JsonExtensionDataAttribute.cs b/src/Newtonsoft.Json/JsonExtensionDataAttribute.cs
new file mode 100644
index 00000000..6bc15b7f
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonExtensionDataAttribute.cs
@@ -0,0 +1,37 @@
+using System;
+
+namespace 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/src/Newtonsoft.Json/JsonIgnoreAttribute.cs b/src/Newtonsoft.Json/JsonIgnoreAttribute.cs
new file mode 100644
index 00000000..8229299f
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonNameTable.cs b/src/Newtonsoft.Json/JsonNameTable.cs
new file mode 100644
index 00000000..b7937618
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonNameTable.cs
@@ -0,0 +1,17 @@
+namespace 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/src/Newtonsoft.Json/JsonObjectAttribute.cs b/src/Newtonsoft.Json/JsonObjectAttribute.cs
new file mode 100644
index 00000000..a5c35e42
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonObjectAttribute.cs
@@ -0,0 +1,100 @@
+#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 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;
+        
+        // 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 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/src/Newtonsoft.Json/JsonPosition.cs b/src/Newtonsoft.Json/JsonPosition.cs
new file mode 100644
index 00000000..b301993e
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/JsonPropertyAttribute.cs b/src/Newtonsoft.Json/JsonPropertyAttribute.cs
new file mode 100644
index 00000000..ec6532fa
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Serialization;
+
+namespace 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/src/Newtonsoft.Json/JsonReader.Async.cs b/src/Newtonsoft.Json/JsonReader.Async.cs
new file mode 100644
index 00000000..e61e933a
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/JsonReader.cs b/src/Newtonsoft.Json/JsonReader.cs
new file mode 100644
index 00000000..f827c278
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonReader.cs
@@ -0,0 +1,1276 @@
+#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 Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+
+namespace 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"/>.
+        /// </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;
+
+            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 (string.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 (string.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 (string.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 (string.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:
+                    string s = (string)Value;
+                    return ReadDateTimeString(s);
+            }
+
+            throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
+        }
+
+        internal DateTime? ReadDateTimeString(string s)
+        {
+            if (string.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 (string.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/src/Newtonsoft.Json/JsonReaderException.cs b/src/Newtonsoft.Json/JsonReaderException.cs
new file mode 100644
index 00000000..f73107ba
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/JsonRequiredAttribute.cs b/src/Newtonsoft.Json/JsonRequiredAttribute.cs
new file mode 100644
index 00000000..bc1b6b52
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonSerializationException.cs b/src/Newtonsoft.Json/JsonSerializationException.cs
new file mode 100644
index 00000000..308b799b
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonSerializer.cs b/src/Newtonsoft.Json/JsonSerializer.cs
new file mode 100644
index 00000000..d3e1d5ec
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonSerializer.cs
@@ -0,0 +1,1229 @@
+#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 Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+using System.Runtime.Serialization;
+using ErrorEventArgs = Newtonsoft.Json.Serialization.ErrorEventArgs;
+
+namespace 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 == null)
+                {
+                    return null;
+                }
+
+                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>null</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="StringReader"/>
+        /// 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/src/Newtonsoft.Json/JsonSerializerSettings.cs b/src/Newtonsoft.Json/JsonSerializerSettings.cs
new file mode 100644
index 00000000..6067c6ed
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonSerializerSettings.cs
@@ -0,0 +1,455 @@
+#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 Newtonsoft.Json.Serialization;
+using System.Runtime.Serialization;
+using System.Diagnostics;
+
+namespace 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 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
+                    : (Serialization.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 Serialization.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>null</c>.
+        /// </summary>
+        public int? MaxDepth
+        {
+            get => _maxDepth;
+            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/src/Newtonsoft.Json/JsonTextReader.Async.cs b/src/Newtonsoft.Json/JsonTextReader.Async.cs
new file mode 100644
index 00000000..bb18359a
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonTextReader.Async.cs
@@ -0,0 +1,1768 @@
+#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 Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+
+namespace 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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            // 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)
+        {
+            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)
+        {
+            // 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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            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();
+
+            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();
+
+            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();
+
+            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();
+            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/src/Newtonsoft.Json/JsonTextReader.cs b/src/Newtonsoft.Json/JsonTextReader.cs
new file mode 100644
index 00000000..948ce346
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonTextReader.cs
@@ -0,0 +1,2599 @@
+#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;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using Newtonsoft.Json.Utilities;
+
+namespace 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';
+        private const int MaximumJavascriptIntegerCharacterLength = 380;
+
+#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)
+        {
+            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()
+        {
+            // 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)
+        {
+            // 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);
+
+            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();
+
+            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();
+            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();
+
+            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();
+
+            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();
+
+            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()
+        {
+            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()
+        {
+            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)
+        {
+            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)
+        {
+            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)
+        {
+            if (writeToPosition > lastWritePosition)
+            {
+                _stringBuffer.Append(_arrayPool, _chars, lastWritePosition, writeToPosition - lastWritePosition);
+            }
+
+            _stringBuffer.Append(_arrayPool, writeChar);
+        }
+
+        private char ConvertUnicode(bool enoughChars)
+        {
+            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()
+        {
+            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)
+        {
+            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()
+        {
+            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()
+        {
+            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()
+        {
+            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)
+        {
+            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()
+        {
+            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()
+        {
+            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()
+        {
+            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();
+
+            char firstChar = _chars[_charPos];
+            int initialPosition = _charPos;
+
+            ReadNumberIntoBuffer();
+
+            ParseReadNumber(readType, firstChar, initialPosition);
+        }
+
+        private void ParseReadNumber(ReadType readType, char firstChar, int initialPosition)
+        { 
+            // 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)
+        {
+            // 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)
+        {
+            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)
+        {
+            // 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)
+        {
+            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/src/Newtonsoft.Json/JsonTextWriter.Async.cs b/src/Newtonsoft.Json/JsonTextWriter.Async.cs
new file mode 100644
index 00000000..1b98a3f6
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonTextWriter.Async.cs
@@ -0,0 +1,1357 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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();
+
+            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)
+        {
+            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 (string.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 (string.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, 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/src/Newtonsoft.Json/JsonTextWriter.cs b/src/Newtonsoft.Json/JsonTextWriter.cs
new file mode 100644
index 00000000..6b7abd91
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonTextWriter.cs
@@ -0,0 +1,915 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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 (string.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();
+
+            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 (string.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();
+
+            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 = null;
+
+#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();
+
+            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();
+
+            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/src/Newtonsoft.Json/JsonToken.cs b/src/Newtonsoft.Json/JsonToken.cs
new file mode 100644
index 00000000..92632e38
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/JsonValidatingReader.cs b/src/Newtonsoft.Json/JsonValidatingReader.cs
new file mode 100644
index 00000000..34cc3ae6
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonValidatingReader.cs
@@ -0,0 +1,1023 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Schema;
+using Newtonsoft.Json.Utilities;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.IO;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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/src/Newtonsoft.Json/JsonWriter.Async.cs b/src/Newtonsoft.Json/JsonWriter.Async.cs
new file mode 100644
index 00000000..4a9c0f7d
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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 (initialDepth < CalculateWriteTokenFinalDepth(reader))
+            {
+                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/src/Newtonsoft.Json/JsonWriter.cs b/src/Newtonsoft.Json/JsonWriter.cs
new file mode 100644
index 00000000..c253585b
--- /dev/null
+++ b/src/Newtonsoft.Json/JsonWriter.cs
@@ -0,0 +1,1781 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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[][] StateArrayTempate = 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 = StateArrayTempate.ToList();
+            State[] errorStates = StateArrayTempate[0];
+            State[] valueStates = StateArrayTempate[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:
+                    ValidationUtils.ArgumentNotNull(value, nameof(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 (initialDepth < CalculateWriteTokenFinalDepth(reader))
+            {
+                throw JsonWriterException.Create(this, "Unexpected end when reading token.", null);
+            }
+        }
+
+        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/src/Newtonsoft.Json/JsonWriterException.cs b/src/Newtonsoft.Json/JsonWriterException.cs
new file mode 100644
index 00000000..4312b6ba
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/CommentHandling.cs b/src/Newtonsoft.Json/Linq/CommentHandling.cs
new file mode 100644
index 00000000..579235c5
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/DuplicatePropertyNameHandling.cs b/src/Newtonsoft.Json/Linq/DuplicatePropertyNameHandling.cs
new file mode 100644
index 00000000..43e27fc8
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/Extensions.cs b/src/Newtonsoft.Json/Linq/Extensions.cs
new file mode 100644
index 00000000..43b70d4b
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/Extensions.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.Collections.Generic;
+using Newtonsoft.Json.Utilities;
+using System.Globalization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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)
+            {
+                return default;
+            }
+
+            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)
+                    {
+                        return default;
+                    }
+
+                    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/src/Newtonsoft.Json/Linq/IJEnumerable.cs b/src/Newtonsoft.Json/Linq/IJEnumerable.cs
new file mode 100644
index 00000000..133a7f6f
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/JArray.Async.cs b/src/Newtonsoft.Json/Linq/JArray.Async.cs
new file mode 100644
index 00000000..ef6bdf52
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Linq/JArray.cs b/src/Newtonsoft.Json/Linq/JArray.cs
new file mode 100644
index 00000000..270027e8
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JArray.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
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Newtonsoft.Json.Utilities;
+using System.IO;
+using System.Globalization;
+
+namespace 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)
+        {
+            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/src/Newtonsoft.Json/Linq/JConstructor.Async.cs b/src/Newtonsoft.Json/Linq/JConstructor.Async.cs
new file mode 100644
index 00000000..d24b81f8
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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, 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/src/Newtonsoft.Json/Linq/JConstructor.cs b/src/Newtonsoft.Json/Linq/JConstructor.cs
new file mode 100644
index 00000000..759008fd
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JConstructor.cs
@@ -0,0 +1,245 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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)
+        {
+            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() ^ 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/src/Newtonsoft.Json/Linq/JContainer.Async.cs b/src/Newtonsoft.Json/Linq/JContainer.Async.cs
new file mode 100644
index 00000000..324c62a1
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JContainer.Async.cs
@@ -0,0 +1,169 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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;
+                }
+
+                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();
+                        }
+                        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/src/Newtonsoft.Json/Linq/JContainer.cs b/src/Newtonsoft.Json/Linq/JContainer.cs
new file mode 100644
index 00000000..05b8e62b
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JContainer.cs
@@ -0,0 +1,1203 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Collections;
+using System.Globalization;
+using System.ComponentModel;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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)
+            {
+                AddInternal(i, child, false);
+                i++;
+            }
+        }
+
+        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>()
+        {
+            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(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 void 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
+        }
+
+        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)
+        {
+            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)
+            {
+                // null will get turned into a JValue of type null
+                if (v1.Type == JTokenType.Null && newValue == null)
+                {
+                    return true;
+                }
+
+                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)
+        {
+            AddInternal(ChildrenTokens.Count, content, false);
+        }
+
+        internal void AddAndSkipParentCheck(JToken token)
+        {
+            AddInternal(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)
+        {
+            AddInternal(0, content, false);
+        }
+
+        internal void AddInternal(int index, object content, bool skipParentCheck)
+        {
+            if (IsMultiContent(content))
+            {
+                IEnumerable enumerable = (IEnumerable)content;
+
+                int multiIndex = index;
+                foreach (object c in enumerable)
+                {
+                    AddInternal(multiIndex, c, skipParentCheck);
+                    multiIndex++;
+                }
+            }
+            else
+            {
+                JToken item = CreateFromContent(content);
+
+                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, new JsonMergeSettings());
+        }
+
+        /// <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;
+                }
+
+                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);
+            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)
+            {
+                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:
+                    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/src/Newtonsoft.Json/Linq/JEnumerable.cs b/src/Newtonsoft.Json/Linq/JEnumerable.cs
new file mode 100644
index 00000000..93bbe1a7
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using Newtonsoft.Json.Utilities;
+using System.Collections;
+
+namespace 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/src/Newtonsoft.Json/Linq/JObject.Async.cs b/src/Newtonsoft.Json/Linq/JObject.Async.cs
new file mode 100644
index 00000000..21eb02b7
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Linq/JObject.cs b/src/Newtonsoft.Json/Linq/JObject.cs
new file mode 100644
index 00000000..5bb9b4ab
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JObject.cs
@@ -0,0 +1,849 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace 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)
+        {
+            return _properties.IndexOfReference(item);
+        }
+
+        internal override void 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;
+            }
+
+            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);
+
+                return property?.Value;
+            }
+            set
+            {
+                JProperty property = Property(propertyName);
+                if (property != null)
+                {
+                    property.Value = value;
+                }
+                else
+                {
+#if HAVE_INOTIFY_PROPERTY_CHANGING
+                    OnPropertyChanging(propertyName);
+#endif
+                    Add(new JProperty(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 != null && 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, 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);
+            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, out JToken value)
+        {
+            JProperty property = Property(propertyName);
+            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);
+            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)
+        {
+            PropertyDescriptorCollection descriptors = new PropertyDescriptorCollection(null);
+
+            foreach (KeyValuePair<string, JToken> propertyValue in this)
+            {
+                descriptors.Add(new JPropertyDescriptor(propertyValue.Key));
+            }
+
+            return descriptors;
+        }
+
+        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/src/Newtonsoft.Json/Linq/JProperty.Async.cs b/src/Newtonsoft.Json/Linq/JProperty.Async.cs
new file mode 100644
index 00000000..9083a985
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Linq/JProperty.cs b/src/Newtonsoft.Json/Linq/JProperty.cs
new file mode 100644
index 00000000..ab938a9b
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JProperty.cs
@@ -0,0 +1,385 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+using System.Globalization;
+
+namespace 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 => (index == 0) ? _token : null;
+                set
+                {
+                    if (index == 0)
+                    {
+                        _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)
+        {
+            return _content.IndexOf(item);
+        }
+
+        internal override void InsertItem(int index, JToken item, bool skipParentCheck)
+        {
+            // don't add comments to JProperty
+            if (item != null && item.Type == JTokenType.Comment)
+            {
+                return;
+            }
+
+            if (Value != null)
+            {
+                throw new JsonException("{0} cannot have multiple values.".FormatWith(CultureInfo.InvariantCulture, typeof(JProperty)));
+            }
+
+            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/src/Newtonsoft.Json/Linq/JPropertyDescriptor.cs b/src/Newtonsoft.Json/Linq/JPropertyDescriptor.cs
new file mode 100644
index 00000000..08858c03
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/JPropertyKeyedCollection.cs b/src/Newtonsoft.Json/Linq/JPropertyKeyedCollection.cs
new file mode 100644
index 00000000..435e4573
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JPropertyKeyedCollection.cs
@@ -0,0 +1,282 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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, 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/src/Newtonsoft.Json/Linq/JRaw.Async.cs b/src/Newtonsoft.Json/Linq/JRaw.Async.cs
new file mode 100644
index 00000000..efb4f618
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/JRaw.cs b/src/Newtonsoft.Json/Linq/JRaw.cs
new file mode 100644
index 00000000..9acc240f
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/JToken.Async.cs b/src/Newtonsoft.Json/Linq/JToken.Async.cs
new file mode 100644
index 00000000..1d89e0fd
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Linq/JToken.cs b/src/Newtonsoft.Json/Linq/JToken.cs
new file mode 100644
index 00000000..05f641c1
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JToken.cs
@@ -0,0 +1,2695 @@
+#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 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 Newtonsoft.Json.Utilities;
+using System.Diagnostics;
+using System.Globalization;
+using System.Collections;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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.AddInternal(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.AddInternal(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()
+        {
+            for (JToken o = Parent.First; o != this; 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>
+        /// <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 JPath expression. Selects the token that matches the object path.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JPath expression.
+        /// </param>
+        /// <returns>A <see cref="JToken"/>, or <c>null</c>.</returns>
+        public JToken SelectToken(string path)
+        {
+            return SelectToken(path, false);
+        }
+
+        /// <summary>
+        /// Selects a <see cref="JToken"/> using a JPath expression. Selects the token that matches the object path.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JPath 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)
+        {
+            JPath p = new JPath(path);
+
+            JToken token = null;
+            foreach (JToken t in p.Evaluate(this, this, errorWhenNoMatch))
+            {
+                if (token != null)
+                {
+                    throw new JsonException("Path returned multiple tokens.");
+                }
+
+                token = t;
+            }
+
+            return token;
+        }
+
+        /// <summary>
+        /// Selects a collection of elements using a JPath expression.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JPath 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, false);
+        }
+
+        /// <summary>
+        /// Selects a collection of elements using a JPath expression.
+        /// </summary>
+        /// <param name="path">
+        /// A <see cref="String"/> that contains a JPath 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)
+        {
+            JPath p = new JPath(path);
+            return p.Evaluate(this, this, errorWhenNoMatch);
+        }
+
+#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;
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Linq/JTokenEqualityComparer.cs b/src/Newtonsoft.Json/Linq/JTokenEqualityComparer.cs
new file mode 100644
index 00000000..2930896d
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/JTokenReader.cs b/src/Newtonsoft.Json/Linq/JTokenReader.cs
new file mode 100644
index 00000000..7a97705c
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JTokenReader.cs
@@ -0,0 +1,339 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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);
+                }
+            }
+
+            _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 (!string.IsNullOrEmpty(_initialPath))
+                {
+                    if (string.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/src/Newtonsoft.Json/Linq/JTokenType.cs b/src/Newtonsoft.Json/Linq/JTokenType.cs
new file mode 100644
index 00000000..36918733
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/JTokenWriter.Async.cs b/src/Newtonsoft.Json/Linq/JTokenWriter.Async.cs
new file mode 100644
index 00000000..1dbed28a
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Linq/JTokenWriter.cs b/src/Newtonsoft.Json/Linq/JTokenWriter.cs
new file mode 100644
index 00000000..3c823017
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JTokenWriter.cs
@@ -0,0 +1,532 @@
+#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;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+using Newtonsoft.Json.Utilities;
+
+namespace 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)
+            {
+                _parent.Add(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/src/Newtonsoft.Json/Linq/JValue.Async.cs b/src/Newtonsoft.Json/Linq/JValue.Async.cs
new file mode 100644
index 00000000..91402d10
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Linq/JValue.cs b/src/Newtonsoft.Json/Linq/JValue.cs
new file mode 100644
index 00000000..85e2473f
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JValue.cs
@@ -0,0 +1,1175 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+#if HAVE_DYNAMIC
+using System.Dynamic;
+using System.Linq.Expressions;
+#endif
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+
+namespace 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)
+        {
+        }
+
+        /// <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[];
+                    Debug.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)
+        {
+            return Equals(obj as JValue);
+        }
+
+        /// <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>
+        /// <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, 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, 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/src/Newtonsoft.Json/Linq/JsonLoadSettings.cs b/src/Newtonsoft.Json/Linq/JsonLoadSettings.cs
new file mode 100644
index 00000000..64aba4c1
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonLoadSettings.cs
@@ -0,0 +1,81 @@
+using System;
+
+namespace 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/src/Newtonsoft.Json/Linq/JsonMergeSettings.cs b/src/Newtonsoft.Json/Linq/JsonMergeSettings.cs
new file mode 100644
index 00000000..4de8fff6
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/JsonPath/ArrayIndexFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/ArrayIndexFilter.cs
new file mode 100644
index 00000000..c6cb1e88
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/ArrayIndexFilter.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ArrayIndexFilter : PathFilter
+    {
+        public int? Index { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            foreach (JToken t in current)
+            {
+                if (Index != null)
+                {
+                    JToken v = GetTokenIndex(t, errorWhenNoMatch, 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 (errorWhenNoMatch)
+                        {
+                            throw new JsonException("Index * not valid on {0}.".FormatWith(CultureInfo.InvariantCulture, t.GetType().Name));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Linq/JsonPath/ArrayMultipleIndexFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/ArrayMultipleIndexFilter.cs
new file mode 100644
index 00000000..170bfc47
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/ArrayMultipleIndexFilter.cs
@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ArrayMultipleIndexFilter : PathFilter
+    {
+        public List<int> Indexes { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            foreach (JToken t in current)
+            {
+                foreach (int i in Indexes)
+                {
+                    JToken v = GetTokenIndex(t, errorWhenNoMatch, i);
+
+                    if (v != null)
+                    {
+                        yield return v;
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Linq/JsonPath/ArraySliceFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/ArraySliceFilter.cs
new file mode 100644
index 00000000..e6ee0b7b
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/ArraySliceFilter.cs
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace 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, bool errorWhenNoMatch)
+        {
+            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 (errorWhenNoMatch)
+                        {
+                            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 (errorWhenNoMatch)
+                    {
+                        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/src/Newtonsoft.Json/Linq/JsonPath/FieldFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/FieldFilter.cs
new file mode 100644
index 00000000..6298909a
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/FieldFilter.cs
@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class FieldFilter : PathFilter
+    {
+        public string Name { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            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 (errorWhenNoMatch)
+                        {
+                            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 (errorWhenNoMatch)
+                    {
+                        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/src/Newtonsoft.Json/Linq/JsonPath/FieldMultipleFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/FieldMultipleFilter.cs
new file mode 100644
index 00000000..3d46708e
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/FieldMultipleFilter.cs
@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Globalization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class FieldMultipleFilter : PathFilter
+    {
+        public List<string> Names { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            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 (errorWhenNoMatch)
+                        {
+                            throw new JsonException("Property '{0}' does not exist on JObject.".FormatWith(CultureInfo.InvariantCulture, name));
+                        }
+                    }
+                }
+                else
+                {
+                    if (errorWhenNoMatch)
+                    {
+                        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/src/Newtonsoft.Json/Linq/JsonPath/JPath.cs b/src/Newtonsoft.Json/Linq/JsonPath/JPath.cs
new file mode 100644
index 00000000..b61ec4c7
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/JPath.cs
@@ -0,0 +1,903 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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));
+                        _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 {Name = member} : new FieldFilter {Name = 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 = 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 = expression
+                };
+            }
+            else
+            {
+                return new QueryScanFilter
+                {
+                    Expression = expression
+                };
+            }
+        }
+
+        private bool TryParseExpression(out List<PathFilter> expressionPath)
+        {
+            if (_expression[_currentIndex] == '$')
+            {
+                expressionPath = new List<PathFilter>();
+                expressionPath.Add(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 var 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
+                {
+                    Left = left,
+                    Operator = op,
+                    Right = 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 { Operator = 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 { Operator = 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;
+            foreach (char c in s)
+            {
+                if (currentPosition < _expression.Length && _expression[currentPosition] == c)
+                {
+                    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 { Names = fields }
+                            : (PathFilter)new FieldMultipleFilter { Names = 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, bool errorWhenNoMatch)
+        {
+            return Evaluate(Filters, root, t, errorWhenNoMatch);
+        }
+
+        internal static IEnumerable<JToken> Evaluate(List<PathFilter> filters, JToken root, JToken t, bool errorWhenNoMatch)
+        {
+            IEnumerable<JToken> current = new[] { t };
+            foreach (PathFilter filter in filters)
+            {
+                current = filter.ExecuteFilter(root, current, errorWhenNoMatch);
+            }
+
+            return current;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Linq/JsonPath/PathFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/PathFilter.cs
new file mode 100644
index 00000000..6ea77c55
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/PathFilter.cs
@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal abstract class PathFilter
+    {
+        public abstract IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch);
+
+        protected static JToken GetTokenIndex(JToken t, bool errorWhenNoMatch, int index)
+        {
+
+            if (t is JArray a)
+            {
+                if (a.Count <= index)
+                {
+                    if (errorWhenNoMatch)
+                    {
+                        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 (errorWhenNoMatch)
+                    {
+                        throw new JsonException("Index {0} outside the bounds of JConstructor.".FormatWith(CultureInfo.InvariantCulture, index));
+                    }
+
+                    return null;
+                }
+
+                return c[index];
+            }
+            else
+            {
+                if (errorWhenNoMatch)
+                {
+                    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/src/Newtonsoft.Json/Linq/JsonPath/QueryExpression.cs b/src/Newtonsoft.Json/Linq/JsonPath/QueryExpression.cs
new file mode 100644
index 00000000..a65bcbfb
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/QueryExpression.cs
@@ -0,0 +1,306 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Diagnostics;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using Newtonsoft.Json.Utilities;
+
+namespace 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
+    {
+        public QueryOperator Operator { get; set; }
+
+        public abstract bool IsMatch(JToken root, JToken t);
+    }
+
+    internal class CompositeExpression : QueryExpression
+    {
+        public List<QueryExpression> Expressions { get; set; }
+
+        public CompositeExpression()
+        {
+            Expressions = new List<QueryExpression>();
+        }
+
+        public override bool IsMatch(JToken root, JToken t)
+        {
+            switch (Operator)
+            {
+                case QueryOperator.And:
+                    foreach (QueryExpression e in Expressions)
+                    {
+                        if (!e.IsMatch(root, t))
+                        {
+                            return false;
+                        }
+                    }
+                    return true;
+                case QueryOperator.Or:
+                    foreach (QueryExpression e in Expressions)
+                    {
+                        if (e.IsMatch(root, t))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+
+    internal class BooleanQueryExpression : QueryExpression
+    {
+        public object Left { get; set; }
+        public object Right { get; set; }
+
+        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, false);
+            }
+
+            return CollectionUtils.ArrayEmpty<JToken>();
+        }
+
+        public override bool IsMatch(JToken root, JToken t)
+        {
+            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))
+                            {
+                                return true;
+                            }
+                        }
+                    } while (leftResults.MoveNext());
+                }
+            }
+
+            return false;
+        }
+
+        private bool MatchTokens(JToken leftResult, JToken rightResult)
+        {
+            if (leftResult is JValue leftValue && rightResult is JValue rightValue)
+            {
+                switch (Operator)
+                {
+                    case QueryOperator.RegexEquals:
+                        if (RegexEquals(leftValue, rightValue))
+                        {
+                            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)
+        {
+            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);
+
+            return Regex.IsMatch((string)input.Value, patternText, MiscellaneousUtils.GetRegexOptions(optionsText));
+        }
+
+        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)
+        {
+            Debug.Assert(value != null);
+            Debug.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/src/Newtonsoft.Json/Linq/JsonPath/QueryFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/QueryFilter.cs
new file mode 100644
index 00000000..775acd80
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/QueryFilter.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class QueryFilter : PathFilter
+    {
+        public QueryExpression Expression { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            foreach (JToken t in current)
+            {
+                foreach (JToken v in t)
+                {
+                    if (Expression.IsMatch(root, v))
+                    {
+                        yield return v;
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Linq/JsonPath/QueryScanFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/QueryScanFilter.cs
new file mode 100644
index 00000000..027d0210
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/QueryScanFilter.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class QueryScanFilter : PathFilter
+    {
+        public QueryExpression Expression { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            foreach (JToken t in current)
+            {
+                if (t is JContainer c)
+                {
+                    foreach (JToken d in c.DescendantsAndSelf())
+                    {
+                        if (Expression.IsMatch(root, d))
+                        {
+                            yield return d;
+                        }
+                    }
+                }
+                else
+                {
+                    if (Expression.IsMatch(root, t))
+                    {
+                        yield return t;
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Linq/JsonPath/RootFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/RootFilter.cs
new file mode 100644
index 00000000..00f5b725
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/RootFilter.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace 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, bool errorWhenNoMatch)
+        {
+            return new[] { root };
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Linq/JsonPath/ScanFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/ScanFilter.cs
new file mode 100644
index 00000000..073edd9d
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/ScanFilter.cs
@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ScanFilter : PathFilter
+    {
+        public string Name { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            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/src/Newtonsoft.Json/Linq/JsonPath/ScanMultipleFilter.cs b/src/Newtonsoft.Json/Linq/JsonPath/ScanMultipleFilter.cs
new file mode 100644
index 00000000..934b2965
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/JsonPath/ScanMultipleFilter.cs
@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+
+namespace Newtonsoft.Json.Linq.JsonPath
+{
+    internal class ScanMultipleFilter : PathFilter
+    {
+        public List<string> Names { get; set; }
+
+        public override IEnumerable<JToken> ExecuteFilter(JToken root, IEnumerable<JToken> current, bool errorWhenNoMatch)
+        {
+            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/src/Newtonsoft.Json/Linq/LineInfoHandling.cs b/src/Newtonsoft.Json/Linq/LineInfoHandling.cs
new file mode 100644
index 00000000..7fbdeebb
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Linq/MergeArrayHandling.cs b/src/Newtonsoft.Json/Linq/MergeArrayHandling.cs
new file mode 100644
index 00000000..5e7fadf1
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/MergeArrayHandling.cs
@@ -0,0 +1,20 @@
+namespace 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/src/Newtonsoft.Json/Linq/MergeNullValueHandling.cs b/src/Newtonsoft.Json/Linq/MergeNullValueHandling.cs
new file mode 100644
index 00000000..30d3d845
--- /dev/null
+++ b/src/Newtonsoft.Json/Linq/MergeNullValueHandling.cs
@@ -0,0 +1,21 @@
+using System;
+
+namespace 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/src/Newtonsoft.Json/MemberSerialization.cs b/src/Newtonsoft.Json/MemberSerialization.cs
new file mode 100644
index 00000000..b3fd7d9e
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Serialization;
+
+namespace 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/src/Newtonsoft.Json/MetadataPropertyHandling.cs b/src/Newtonsoft.Json/MetadataPropertyHandling.cs
new file mode 100644
index 00000000..5bdacd87
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/MissingMemberHandling.cs b/src/Newtonsoft.Json/MissingMemberHandling.cs
new file mode 100644
index 00000000..4e35081b
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Newtonsoft.Json.csproj b/src/Newtonsoft.Json/Newtonsoft.Json.csproj
new file mode 100644
index 00000000..2c20b8c4
--- /dev/null
+++ b/src/Newtonsoft.Json/Newtonsoft.Json.csproj
@@ -0,0 +1,94 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">net45;net40;net35;net20;netstandard1.0;netstandard1.3;netstandard2.0;portable-net45+win8+wpa81+wp8;portable-net40+win8+wpa81+wp8+sl5</TargetFrameworks>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'!=''">$(LibraryFrameworks)</TargetFrameworks>
+    <LangVersion>latest</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>Newtonsoft.Json</PackageId>
+    <PackageTags>json</PackageTags>
+    <PackageIconUrl>https://www.newtonsoft.com/content/images/nugeticon.png</PackageIconUrl>
+    <PackageProjectUrl>https://www.newtonsoft.com/json</PackageProjectUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl> 
+    <RootNamespace>Newtonsoft.Json</RootNamespace>
+    <AssemblyName>Newtonsoft.Json</AssemblyName>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <MinClientVersion>2.12</MinClientVersion>
+    <!-- including PDB files in NuGet for source link because symbolsource.org does not support portable PDBs -->
+    <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder> 
+  </PropertyGroup>
+  <ItemGroup>
+    <None Remove="**\*.orig" />
+    <None Include="..\..\LICENSE.md" Pack="true" PackagePath="LICENSE.md" />
+  </ItemGroup>
+  <ItemGroup> 
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0-beta-63127-02" 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_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="4.3.0" />
+    <PackageReference Include="System.ComponentModel.TypeConverter" Version="4.3.0" />
+    <PackageReference Include="System.Runtime.Serialization.Primitives" Version="4.3.0" />
+  </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;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard1.3'">
+    <PackageReference Include="System.Runtime.Serialization.Formatters" Version="4.3.0" />
+    <PackageReference Include="System.Xml.XmlDocument" Version="4.3.0" />
+  </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;$(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;$(AdditionalConstants)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'portable-net40+win8+wpa81+wp8+sl5'">
+    <AssemblyTitle>Json.NET Portable .NET 4.0</AssemblyTitle>
+    <DefineConstants>PORTABLE40;HAVE_CHAR_TO_LOWER_WITH_CULTURE;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DB_NULL_TYPE_CODE;HAVE_FAST_REVERSE;HAVE_FSHARP_TYPES;HAVE_FULL_REFLECTION;HAVE_GUID_TRY_PARSE;HAVE_ICONVERTIBLE;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;HAVE_ISET;HAVE_LINQ;HAVE_MEMORY_BARRIER;HAVE_OBSOLETE_FORMATTER_ASSEMBLY_STYLE;HAVE_SECURITY_SAFE_CRITICAL_ATTRIBUTE;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_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;$(AdditionalConstants)</DefineConstants>
+    <TargetFrameworkIdentifier>.NETPortable</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>Profile328</TargetFrameworkProfile>
+    <NugetTargetMoniker>.NETPortable,Version=v0.0,Profile=Profile328</NugetTargetMoniker>
+    <LanguageTargets>$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets</LanguageTargets>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'portable-net45+win8+wpa81+wp8'">
+    <AssemblyTitle>Json.NET Portable</AssemblyTitle>
+    <DefineConstants>PORTABLE;HAVE_ASYNC;HAVE_COVARIANT_GENERICS;HAVE_DATA_CONTRACTS;HAVE_DATE_TIME_OFFSET;HAVE_DYNAMIC;HAVE_EXPRESSIONS;HAVE_FAST_REVERSE;HAVE_FSHARP_TYPES;HAVE_GUID_TRY_PARSE;HAVE_IGNORE_DATA_MEMBER_ATTRIBUTE;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_VARIANT_TYPE_PARAMETERS;HAVE_VERSION_TRY_PARSE;HAVE_XLINQ;HAVE_INOTIFY_COLLECTION_CHANGED;HAVE_OBSOLETE_FORMATTER_ASSEMBLY_STYLE;$(AdditionalConstants)</DefineConstants>
+    <TargetFrameworkIdentifier>.NETPortable</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkProfile>Profile259</TargetFrameworkProfile>
+    <NugetTargetMoniker>.NETPortable,Version=v0.0,Profile=Profile259</NugetTargetMoniker>
+    <LanguageTargets>$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets</LanguageTargets>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Newtonsoft.Json.ruleset b/src/Newtonsoft.Json/Newtonsoft.Json.ruleset
new file mode 100644
index 00000000..17596c23
--- /dev/null
+++ b/src/Newtonsoft.Json/Newtonsoft.Json.ruleset
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RuleSet Name="Newtonsoft.Json.ruleset" ToolsVersion="12.0">
+  <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
+    <Rule Id="CA1304" Action="Error" />
+    <Rule Id="CA1305" Action="Error" />
+    <Rule Id="CA1307" Action="Error" />
+    <Rule Id="CA1308" Action="Error" />
+    <Rule Id="CA1309" Action="Error" />
+    <Rule Id="CA1804" Action="Warning" />
+    <Rule Id="CA1811" Action="Warning" />
+    <Rule Id="CA1812" Action="Warning" />
+    <Rule Id="CA1823" Action="Warning" />
+    <Rule Id="CA1903" Action="Error" />
+  </Rules>
+</RuleSet>
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/NullValueHandling.cs b/src/Newtonsoft.Json/NullValueHandling.cs
new file mode 100644
index 00000000..8a88c163
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/ObjectCreationHandling.cs b/src/Newtonsoft.Json/ObjectCreationHandling.cs
new file mode 100644
index 00000000..cc53b142
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/PreserveReferencesHandling.cs b/src/Newtonsoft.Json/PreserveReferencesHandling.cs
new file mode 100644
index 00000000..bb6f7ae8
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/ReferenceLoopHandling.cs b/src/Newtonsoft.Json/ReferenceLoopHandling.cs
new file mode 100644
index 00000000..bfa5133f
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Required.cs b/src/Newtonsoft.Json/Required.cs
new file mode 100644
index 00000000..47c91e13
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Schema/Extensions.cs b/src/Newtonsoft.Json/Schema/Extensions.cs
new file mode 100644
index 00000000..4b9d2db7
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/Extensions.cs
@@ -0,0 +1,137 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Schema/JsonSchema.cs b/src/Newtonsoft.Json/Schema/JsonSchema.cs
new file mode 100644
index 00000000..f8d0a174
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchema.cs
@@ -0,0 +1,353 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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; }
+
+        private readonly string _internalId = Guid.NewGuid().ToString("N");
+
+        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/src/Newtonsoft.Json/Schema/JsonSchemaBuilder.cs b/src/Newtonsoft.Json/Schema/JsonSchemaBuilder.cs
new file mode 100644
index 00000000..310ef70a
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaBuilder.cs
@@ -0,0 +1,487 @@
+#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 Newtonsoft.Json.Serialization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+using Newtonsoft.Json.Linq;
+
+namespace 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 (!string.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/src/Newtonsoft.Json/Schema/JsonSchemaConstants.cs b/src/Newtonsoft.Json/Schema/JsonSchemaConstants.cs
new file mode 100644
index 00000000..ab41d34e
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaConstants.cs
@@ -0,0 +1,80 @@
+#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 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/src/Newtonsoft.Json/Schema/JsonSchemaException.cs b/src/Newtonsoft.Json/Schema/JsonSchemaException.cs
new file mode 100644
index 00000000..b1b53628
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaException.cs
@@ -0,0 +1,113 @@
+#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 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/src/Newtonsoft.Json/Schema/JsonSchemaGenerator.cs b/src/Newtonsoft.Json/Schema/JsonSchemaGenerator.cs
new file mode 100644
index 00000000..ba8245b0
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaGenerator.cs
@@ -0,0 +1,502 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+using Newtonsoft.Json.Serialization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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 (!string.IsNullOrEmpty(containerAttribute?.Title))
+            {
+                return containerAttribute.Title;
+            }
+
+            return null;
+        }
+
+        private string GetDescription(Type type)
+        {
+            JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(type);
+
+            if (!string.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 (!string.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 (!string.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/src/Newtonsoft.Json/Schema/JsonSchemaModel.cs b/src/Newtonsoft.Json/Schema/JsonSchemaModel.cs
new file mode 100644
index 00000000..af01626d
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaModel.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
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Schema/JsonSchemaModelBuilder.cs b/src/Newtonsoft.Json/Schema/JsonSchemaModelBuilder.cs
new file mode 100644
index 00000000..648206a7
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaModelBuilder.cs
@@ -0,0 +1,211 @@
+#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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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/src/Newtonsoft.Json/Schema/JsonSchemaNode.cs b/src/Newtonsoft.Json/Schema/JsonSchemaNode.cs
new file mode 100644
index 00000000..a01a47db
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaNode.cs
@@ -0,0 +1,85 @@
+#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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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/src/Newtonsoft.Json/Schema/JsonSchemaNodeCollection.cs b/src/Newtonsoft.Json/Schema/JsonSchemaNodeCollection.cs
new file mode 100644
index 00000000..db45fac4
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaNodeCollection.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.ObjectModel;
+
+namespace 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/src/Newtonsoft.Json/Schema/JsonSchemaResolver.cs b/src/Newtonsoft.Json/Schema/JsonSchemaResolver.cs
new file mode 100644
index 00000000..4780d4b2
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaResolver.cs
@@ -0,0 +1,79 @@
+#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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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/src/Newtonsoft.Json/Schema/JsonSchemaType.cs b/src/Newtonsoft.Json/Schema/JsonSchemaType.cs
new file mode 100644
index 00000000..31ad683a
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaType.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;
+
+namespace 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/src/Newtonsoft.Json/Schema/JsonSchemaWriter.cs b/src/Newtonsoft.Json/Schema/JsonSchemaWriter.cs
new file mode 100644
index 00000000..c17f7a6f
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/JsonSchemaWriter.cs
@@ -0,0 +1,258 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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/src/Newtonsoft.Json/Schema/UndefinedSchemaIdHandling.cs b/src/Newtonsoft.Json/Schema/UndefinedSchemaIdHandling.cs
new file mode 100644
index 00000000..0f6aa4ba
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/UndefinedSchemaIdHandling.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 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/src/Newtonsoft.Json/Schema/ValidationEventArgs.cs b/src/Newtonsoft.Json/Schema/ValidationEventArgs.cs
new file mode 100644
index 00000000..5d69c1fb
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/ValidationEventArgs.cs
@@ -0,0 +1,68 @@
+#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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Schema/ValidationEventHandler.cs b/src/Newtonsoft.Json/Schema/ValidationEventHandler.cs
new file mode 100644
index 00000000..a287e8b4
--- /dev/null
+++ b/src/Newtonsoft.Json/Schema/ValidationEventHandler.cs
@@ -0,0 +1,40 @@
+#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 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/src/Newtonsoft.Json/Serialization/CachedAttributeGetter.cs b/src/Newtonsoft.Json/Serialization/CachedAttributeGetter.cs
new file mode 100644
index 00000000..0645631d
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Serialization/CamelCaseNamingStrategy.cs b/src/Newtonsoft.Json/Serialization/CamelCaseNamingStrategy.cs
new file mode 100644
index 00000000..0280c833
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Serialization/CamelCasePropertyNamesContractResolver.cs b/src/Newtonsoft.Json/Serialization/CamelCasePropertyNamesContractResolver.cs
new file mode 100644
index 00000000..c0107cfd
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs b/src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs
new file mode 100644
index 00000000..78664d50
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs
@@ -0,0 +1,1722 @@
+#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 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 Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Utilities;
+using Newtonsoft.Json.Linq;
+using System.Runtime.CompilerServices;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+using Newtonsoft.Json.Serialization;
+
+namespace 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);
+
+            IEnumerable<MemberInfo> allMembers = ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)
+                .Where(FilterMembers);
+
+            List<MemberInfo> serializableMembers = new List<MemberInfo>();
+
+            if (memberSerialization != MemberSerialization.Fields)
+            {
+#if HAVE_DATA_CONTRACTS
+                DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType);
+#endif
+
+#pragma warning disable 618
+                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));
+
+            Serialization.Func<string, string> extensionDataNameResolver = null;
+
+            JsonObjectAttribute attribute = JsonTypeReflector.GetCachedAttribute<JsonObjectAttribute>(contract.NonNullableUnderlyingType);
+            if (attribute != null)
+            {
+                contract.ItemRequired = attribute._itemRequired;
+                contract.ItemNullValueHandling = attribute._itemNullValueHandling;
+
+                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;
+            }
+
+            Serialization.Func<object, object> getExtensionDataDictionary = JsonTypeReflector.ReflectionDelegateFactory.CreateGet<object>(member);
+
+            if (extensionDataAttribute.ReadData)
+            {
+                Serialization.Action<object, object> setExtensionDataDictionary = (ReflectionUtils.CanSetMemberValue(member, true, false))
+                 ? JsonTypeReflector.ReflectionDelegateFactory.CreateSet<object>(member)
+                 : null;
+                Serialization.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)
+            {
+                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 Serialization.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;
+            }
+
+            Serialization.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/src/Newtonsoft.Json/Serialization/DefaultNamingStrategy.cs b/src/Newtonsoft.Json/Serialization/DefaultNamingStrategy.cs
new file mode 100644
index 00000000..0f60780b
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/DefaultNamingStrategy.cs
@@ -0,0 +1,18 @@
+namespace 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/src/Newtonsoft.Json/Serialization/DefaultReferenceResolver.cs b/src/Newtonsoft.Json/Serialization/DefaultReferenceResolver.cs
new file mode 100644
index 00000000..83e0f484
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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/src/Newtonsoft.Json/Serialization/DefaultSerializationBinder.cs b/src/Newtonsoft.Json/Serialization/DefaultSerializationBinder.cs
new file mode 100644
index 00000000..90af8033
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using System.Collections.Generic;
+
+namespace 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/src/Newtonsoft.Json/Serialization/DiagnosticsTraceWriter.cs b/src/Newtonsoft.Json/Serialization/DiagnosticsTraceWriter.cs
new file mode 100644
index 00000000..0f8b8fbf
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/DiagnosticsTraceWriter.cs
@@ -0,0 +1,79 @@
+#if HAVE_TRACE_WRITER
+using System;
+using System.Diagnostics;
+using DiagnosticsTrace = System.Diagnostics.Trace;
+
+namespace 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/src/Newtonsoft.Json/Serialization/DynamicValueProvider.cs b/src/Newtonsoft.Json/Serialization/DynamicValueProvider.cs
new file mode 100644
index 00000000..8d8d9e02
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+using System.Text;
+using System.Reflection;
+using Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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 Serialization.Func<object, object> _getter;
+        private Serialization.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/src/Newtonsoft.Json/Serialization/ErrorContext.cs b/src/Newtonsoft.Json/Serialization/ErrorContext.cs
new file mode 100644
index 00000000..366064a0
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/ErrorEventArgs.cs b/src/Newtonsoft.Json/Serialization/ErrorEventArgs.cs
new file mode 100644
index 00000000..1b16c607
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/ExpressionValueProvider.cs b/src/Newtonsoft.Json/Serialization/ExpressionValueProvider.cs
new file mode 100644
index 00000000..8c4788e6
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+using System.Text;
+using System.Reflection;
+using Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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 Serialization.Func<object, object> _getter;
+        private Serialization.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/src/Newtonsoft.Json/Serialization/FormatterConverter.cs b/src/Newtonsoft.Json/Serialization/FormatterConverter.cs
new file mode 100644
index 00000000..3247d254
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/FormatterConverter.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using Newtonsoft.Json.Utilities;
+
+#if HAVE_BINARY_SERIALIZATION && !HAVE_BINARY_FORMATTER
+
+namespace 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/src/Newtonsoft.Json/Serialization/IAttributeProvider.cs b/src/Newtonsoft.Json/Serialization/IAttributeProvider.cs
new file mode 100644
index 00000000..b3517b74
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/IContractResolver.cs b/src/Newtonsoft.Json/Serialization/IContractResolver.cs
new file mode 100644
index 00000000..49a8ee8f
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/IReferenceResolver.cs b/src/Newtonsoft.Json/Serialization/IReferenceResolver.cs
new file mode 100644
index 00000000..f5ce5bf0
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/ISerializationBinder.cs b/src/Newtonsoft.Json/Serialization/ISerializationBinder.cs
new file mode 100644
index 00000000..bf70891b
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/ITraceWriter.cs b/src/Newtonsoft.Json/Serialization/ITraceWriter.cs
new file mode 100644
index 00000000..ac0b166e
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/ITraceWriter.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace 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/src/Newtonsoft.Json/Serialization/IValueProvider.cs b/src/Newtonsoft.Json/Serialization/IValueProvider.cs
new file mode 100644
index 00000000..921724f8
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/JsonArrayContract.cs b/src/Newtonsoft.Json/Serialization/JsonArrayContract.cs
new file mode 100644
index 00000000..e712267f
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonArrayContract.cs
@@ -0,0 +1,319 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Collections;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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 Serialization.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)
+                {
+                    _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;
+            IsArray = CreatedType.IsArray;
+
+            bool canDeserialize;
+
+            Type tempCollectionType;
+            if (IsArray)
+            {
+                CollectionItemType = ReflectionUtils.GetCollectionItemType(UnderlyingType);
+                IsReadOnlyOrFixedSize = true;
+                _genericCollectionDefinitionType = typeof(List<>).MakeGenericType(CollectionItemType);
+
+                canDeserialize = true;
+                IsMultidimensionalArray = (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 (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)
+            {
+                _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.CreateSeq(CollectionItemType);
+            }
+        }
+#endif
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Serialization/JsonContainerContract.cs b/src/Newtonsoft.Json/Serialization/JsonContainerContract.cs
new file mode 100644
index 00000000..f1e7796b
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using System.Collections;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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/src/Newtonsoft.Json/Serialization/JsonContract.cs b/src/Newtonsoft.Json/Serialization/JsonContract.cs
new file mode 100644
index 00000000..358fb44a
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonContract.cs
@@ -0,0 +1,325 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+
+namespace 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 IList<SerializationCallback> _onDeserializingCallbacks;
+        private IList<SerializationCallback> _onSerializedCallbacks;
+        private IList<SerializationCallback> _onSerializingCallbacks;
+        private IList<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
+            {
+                _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 Serialization.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 = 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/src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs b/src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs
new file mode 100644
index 00000000..4a4268fd
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs
@@ -0,0 +1,245 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Collections;
+
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace 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 Serialization.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 Serialization.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)
+                {
+                    _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(underlyingType, typeof(IDictionary<,>), out _genericCollectionDefinitionType))
+            {
+                keyType = _genericCollectionDefinitionType.GetGenericArguments()[0];
+                valueType = _genericCollectionDefinitionType.GetGenericArguments()[1];
+
+                if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IDictionary<,>)))
+                {
+                    CreatedType = typeof(Dictionary<,>).MakeGenericType(keyType, valueType);
+                }
+                else if (underlyingType.IsGenericType())
+                {
+                    // ConcurrentDictionary<,> + IDictionary setter + null value = error
+                    // wrap to use generic setter
+                    // https://github.com/JamesNK/Newtonsoft.Json/issues/1582
+                    Type typeDefinition = underlyingType.GetGenericTypeDefinition();
+                    if (typeDefinition.FullName == JsonTypeReflector.ConcurrentDictionaryTypeName)
+                    {
+                        ShouldCreateWrapper = true;
+                    }
+                }
+
+#if HAVE_READ_ONLY_COLLECTIONS
+                IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyDictionary<,>));
+#endif
+
+            }
+#if HAVE_READ_ONLY_COLLECTIONS
+            else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IReadOnlyDictionary<,>), out _genericCollectionDefinitionType))
+            {
+                keyType = _genericCollectionDefinitionType.GetGenericArguments()[0];
+                valueType = _genericCollectionDefinitionType.GetGenericArguments()[1];
+
+                if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IReadOnlyDictionary<,>)))
+                {
+                    CreatedType = typeof(ReadOnlyDictionary<,>).MakeGenericType(keyType, valueType);
+                }
+
+                IsReadOnlyOrFixedSize = true;
+            }
+#endif
+            else
+            {
+                ReflectionUtils.GetDictionaryKeyValueTypes(UnderlyingType, out keyType, out valueType);
+
+                if (UnderlyingType == 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 && underlyingType.Name == FSharpUtils.FSharpMapTypeName)
+                {
+                    FSharpUtils.EnsureInitialized(underlyingType.Assembly());
+                    _parameterizedCreator = FSharpUtils.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 (ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract(
+                underlyingType,
+                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/src/Newtonsoft.Json/Serialization/JsonDynamicContract.cs b/src/Newtonsoft.Json/Serialization/JsonDynamicContract.cs
new file mode 100644
index 00000000..5233d91a
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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 Serialization.Func<string, string> PropertyNameResolver { get; set; }
+
+        private readonly ThreadSafeStore<string, CallSite<Serialization.Func<CallSite, object, object>>> _callSiteGetters =
+            new ThreadSafeStore<string, CallSite<Serialization.Func<CallSite, object, object>>>(CreateCallSiteGetter);
+
+        private readonly ThreadSafeStore<string, CallSite<Serialization.Func<CallSite, object, object, object>>> _callSiteSetters =
+            new ThreadSafeStore<string, CallSite<Serialization.Func<CallSite, object, object, object>>>(CreateCallSiteSetter);
+
+        private static CallSite<Serialization.Func<CallSite, object, object>> CreateCallSiteGetter(string name)
+        {
+            GetMemberBinder getMemberBinder = (GetMemberBinder)DynamicUtils.BinderWrapper.GetMember(name, typeof(DynamicUtils));
+
+            return CallSite<Serialization.Func<CallSite, object, object>>.Create(new NoThrowGetBinderMember(getMemberBinder));
+        }
+
+        private static CallSite<Serialization.Func<CallSite, object, object, object>> CreateCallSiteSetter(string name)
+        {
+            SetMemberBinder binder = (SetMemberBinder)DynamicUtils.BinderWrapper.SetMember(name, typeof(DynamicUtils));
+
+            return CallSite<Serialization.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<Serialization.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<Serialization.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/src/Newtonsoft.Json/Serialization/JsonFormatterConverter.cs b/src/Newtonsoft.Json/Serialization/JsonFormatterConverter.cs
new file mode 100644
index 00000000..52f61ae2
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonFormatterConverter.cs
@@ -0,0 +1,160 @@
+#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 Newtonsoft.Json.Utilities;
+using Newtonsoft.Json.Linq;
+
+namespace 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));
+
+            if (value is JValue v)
+            {
+                value = v.Value;
+            }
+
+            return System.Convert.ChangeType(value, 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/src/Newtonsoft.Json/Serialization/JsonISerializableContract.cs b/src/Newtonsoft.Json/Serialization/JsonISerializableContract.cs
new file mode 100644
index 00000000..f78181f4
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/JsonLinqContract.cs b/src/Newtonsoft.Json/Serialization/JsonLinqContract.cs
new file mode 100644
index 00000000..c91b3f00
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/JsonObjectContract.cs b/src/Newtonsoft.Json/Serialization/JsonObjectContract.cs
new file mode 100644
index 00000000..7f9e26c2
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonObjectContract.cs
@@ -0,0 +1,193 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+
+namespace 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 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 Serialization.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/src/Newtonsoft.Json/Serialization/JsonPrimitiveContract.cs b/src/Newtonsoft.Json/Serialization/JsonPrimitiveContract.cs
new file mode 100644
index 00000000..6d662de5
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Serialization/JsonProperty.cs b/src/Newtonsoft.Json/Serialization/JsonProperty.cs
new file mode 100644
index 00000000..281a0270
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonProperty.cs
@@ -0,0 +1,318 @@
+#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 Newtonsoft.Json.Utilities;
+
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace 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 Serialization.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;
+        }
+
+        /// <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)
+        {
+            if (_skipPropertyNameEscape)
+            {
+                writer.WritePropertyName(PropertyName, false);
+            }
+            else
+            {
+                writer.WritePropertyName(PropertyName);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Serialization/JsonPropertyCollection.cs b/src/Newtonsoft.Json/Serialization/JsonPropertyCollection.cs
new file mode 100644
index 00000000..9bb5a5cf
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonPropertyCollection.cs
@@ -0,0 +1,185 @@
+#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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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)
+        {
+            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, 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/src/Newtonsoft.Json/Serialization/JsonSerializerInternalBase.cs b/src/Newtonsoft.Json/Serialization/JsonSerializerInternalBase.cs
new file mode 100644
index 00000000..73d8670b
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs b/src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs
new file mode 100644
index 00000000..6ad8abee
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs
@@ -0,0 +1,2603 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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 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;
+            }
+
+            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 string.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)
+            {
+                JsonConverter matchingConverter;
+                if (contract.Converter != null)
+                {
+                    // class attribute converter
+                    converter = contract.Converter;
+                }
+                else if ((matchingConverter = Serializer.GetMatchingConverter(contract.UnderlyingType)) != null)
+                {
+                    // 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);
+            }
+
+            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;
+
+                JToken refToken = current[JsonTypeReflector.RefPropertyName];
+                if (refToken != null)
+                {
+                    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);
+                    }
+
+                    JToken property = refToken.Parent;
+                    JToken additionalContent = null;
+                    if (property.Next != null)
+                    {
+                        additionalContent = property.Next;
+                    }
+                    else if (property.Previous != null)
+                    {
+                        additionalContent = property.Previous;
+                    }
+
+                    string reference = (string)refToken;
+
+                    if (reference != null)
+                    {
+                        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 = GetContractSafe(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);
+            }
+
+            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;
+            }
+
+            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 && target != null && 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 = GetContractSafe(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 = GetContractSafe(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 = 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)
+        {
+            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;
+        }
+
+#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 string Name;
+            public JsonProperty Property;
+            public JsonProperty ConstructorProperty;
+            public PropertyPresence? Presence;
+            public object Value;
+            public bool Used;
+        }
+
+        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 = property,
+                                Name = property.PropertyName,
+                                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)
+                            {
+                                IList createdObjectCollectionWrapper = (propertyArrayContract.ShouldCreateWrapper) ? propertyArrayContract.CreateWrapper(createdObjectCollection) : (IList)createdObjectCollection;
+                                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
+                        {
+                            Name = memberName,
+                            ConstructorProperty = contract.CreatorParameters.GetClosestMatchProperty(memberName),
+                            Property = contract.Properties.GetClosestMatchProperty(memberName)
+                        };
+                        propertyValues.Add(creatorPropertyContext);
+
+                        JsonProperty property = creatorPropertyContext.ConstructorProperty ?? creatorPropertyContext.Property;
+                        if (property != null && !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 (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 (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/src/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs b/src/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs
new file mode 100644
index 00000000..9ce79c69
--- /dev/null
+++ b/src/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs
@@ -0,0 +1,1223 @@
+#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 Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Utilities;
+using System.Runtime.Serialization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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 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;
+            }
+
+            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;
+            }
+            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 || 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, 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
+
+            type = value as Type;
+            if (type != null)
+            {
+                s = type.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 = GetContractSafe(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, 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);
+                        }
+                    }
+
+                    return true;
+                }
+            }
+
+            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)
+        {
+            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);
+        }
+
+        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/src/Newtonsoft.Json/Serialization/JsonSerializerProxy.cs b/src/Newtonsoft.Json/Serialization/JsonSerializerProxy.cs
new file mode 100644
index 00000000..a5ff8c05
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using System.Runtime.Serialization;
+
+namespace 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/src/Newtonsoft.Json/Serialization/JsonStringContract.cs b/src/Newtonsoft.Json/Serialization/JsonStringContract.cs
new file mode 100644
index 00000000..be096bc5
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs b/src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs
new file mode 100644
index 00000000..bee03617
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Runtime.Serialization;
+
+namespace 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, Serialization.Func<object[], object>> CreatorCache = 
+            new ThreadSafeStore<Type, Serialization.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)
+            {
+                Serialization.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)
+        {
+            Serialization.Func<object[], object> converterCreator = CreatorCache.Get(converterType);
+            return (JsonConverter)converterCreator(args);
+        }
+
+        public static NamingStrategy CreateNamingStrategyInstance(Type namingStrategyType, object[] args)
+        {
+            Serialization.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 Serialization.Func<object[], object> GetCreator(Type type)
+        {
+            Serialization.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/src/Newtonsoft.Json/Serialization/MemoryTraceWriter.cs b/src/Newtonsoft.Json/Serialization/MemoryTraceWriter.cs
new file mode 100644
index 00000000..6816b656
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/NamingStrategy.cs b/src/Newtonsoft.Json/Serialization/NamingStrategy.cs
new file mode 100644
index 00000000..461bad93
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/ObjectConstructor.cs b/src/Newtonsoft.Json/Serialization/ObjectConstructor.cs
new file mode 100644
index 00000000..380674fe
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/OnErrorAttribute.cs b/src/Newtonsoft.Json/Serialization/OnErrorAttribute.cs
new file mode 100644
index 00000000..cb33296e
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/ReflectionAttributeProvider.cs b/src/Newtonsoft.Json/Serialization/ReflectionAttributeProvider.cs
new file mode 100644
index 00000000..f98f9884
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Serialization/ReflectionValueProvider.cs b/src/Newtonsoft.Json/Serialization/ReflectionValueProvider.cs
new file mode 100644
index 00000000..9c3a657a
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace 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/src/Newtonsoft.Json/Serialization/SerializationBinderAdapter.cs b/src/Newtonsoft.Json/Serialization/SerializationBinderAdapter.cs
new file mode 100644
index 00000000..033692c4
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/SnakeCaseNamingStrategy.cs b/src/Newtonsoft.Json/Serialization/SnakeCaseNamingStrategy.cs
new file mode 100644
index 00000000..f2210793
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities;
+
+namespace 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/src/Newtonsoft.Json/Serialization/TraceJsonReader.cs b/src/Newtonsoft.Json/Serialization/TraceJsonReader.cs
new file mode 100644
index 00000000..5dbbd5de
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Serialization/TraceJsonWriter.cs b/src/Newtonsoft.Json/Serialization/TraceJsonWriter.cs
new file mode 100644
index 00000000..95d9ebae
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/SerializationBinder.cs b/src/Newtonsoft.Json/SerializationBinder.cs
new file mode 100644
index 00000000..b3e480f0
--- /dev/null
+++ b/src/Newtonsoft.Json/SerializationBinder.cs
@@ -0,0 +1,36 @@
+
+#if (DOTNET || PORTABLE40 || PORTABLE)
+using System;
+using System.Reflection;
+
+namespace 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/src/Newtonsoft.Json/StringEscapeHandling.cs b/src/Newtonsoft.Json/StringEscapeHandling.cs
new file mode 100644
index 00000000..4016eb6e
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/TraceLevel.cs b/src/Newtonsoft.Json/TraceLevel.cs
new file mode 100644
index 00000000..f86958a5
--- /dev/null
+++ b/src/Newtonsoft.Json/TraceLevel.cs
@@ -0,0 +1,39 @@
+
+#if !HAVE_TRACE_WRITER
+using Newtonsoft.Json.Serialization;
+
+namespace 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/src/Newtonsoft.Json/TypeNameAssemblyFormatHandling.cs b/src/Newtonsoft.Json/TypeNameAssemblyFormatHandling.cs
new file mode 100644
index 00000000..3d21dcff
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/TypeNameHandling.cs b/src/Newtonsoft.Json/TypeNameHandling.cs
new file mode 100644
index 00000000..2357299e
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/AsyncUtils.cs b/src/Newtonsoft.Json/Utilities/AsyncUtils.cs
new file mode 100644
index 00000000..49cbad97
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/AsyncUtils.cs
@@ -0,0 +1,108 @@
+#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 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)
+        {
+            Debug.Assert(cancellationToken.IsCancellationRequested);
+            return new Task(() => {}, cancellationToken);
+        }
+
+        public static Task<T> FromCanceled<T>(this CancellationToken cancellationToken)
+        {
+            Debug.Assert(cancellationToken.IsCancellationRequested);
+            return new Task<T>(() => default, cancellationToken);
+        }
+
+        // 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)
+        {
+            Debug.Assert(writer != null);
+            return cancellationToken.IsCancellationRequested ? FromCanceled(cancellationToken) : writer.WriteAsync(value);
+        }
+
+        public static Task WriteAsync(this TextWriter writer, string value, CancellationToken cancellationToken)
+        {
+            Debug.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)
+        {
+            Debug.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)
+        {
+            Debug.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/src/Newtonsoft.Json/Utilities/Base64Encoder.cs b/src/Newtonsoft.Json/Utilities/Base64Encoder.cs
new file mode 100644
index 00000000..b65465ea
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/BidirectionalDictionary.cs b/src/Newtonsoft.Json/Utilities/BidirectionalDictionary.cs
new file mode 100644
index 00000000..3ee3c596
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/CollectionUtils.cs b/src/Newtonsoft.Json/Utilities/CollectionUtils.cs
new file mode 100644
index 00000000..f61870d0
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/CollectionUtils.cs
@@ -0,0 +1,389 @@
+#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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Globalization;
+#if HAVE_METHOD_IMPL_ATTRIBUTE
+using System.Runtime.CompilerServices;
+#endif
+using Newtonsoft.Json.Serialization;
+
+namespace 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, Serialization.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;
+        }
+
+        // 4.6 has Array.Empty<T> to return a cached empty array. Lacking that in other
+        // frameworks, Enumerable.Empty<T> happens to be implemented as a cached empty
+        // array in all versions (in .NET Core the same instance as Array.Empty<T>).
+        // This includes the internal Linq bridge for 2.0.
+        // Since this method is simple and only 11 bytes long in a release build it's
+        // pretty much guaranteed to be inlined, giving us fast access of that cached
+        // array. With 4.5 and up we use AggressiveInlining just to be sure, so it's
+        // effectively the same as calling Array.Empty<T> even when not available.
+#if HAVE_METHOD_IMPL_ATTRIBUTE
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#endif
+        public static T[] ArrayEmpty<T>()
+        {
+            T[] array = Enumerable.Empty<T>() as T[];
+            Debug.Assert(array != null);
+            // Defensively guard against a version of Linq where Enumerable.Empty<T> doesn't
+            // return an array, but throw in debug versions so a better strategy can be
+            // used if that ever happens.
+            return array ?? new T[0];
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Utilities/CollectionWrapper.cs b/src/Newtonsoft.Json/Utilities/CollectionWrapper.cs
new file mode 100644
index 00000000..a1696670
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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/src/Newtonsoft.Json/Utilities/ConvertUtils.cs b/src/Newtonsoft.Json/Utilities/ConvertUtils.cs
new file mode 100644
index 00000000..ef82aa8a
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/ConvertUtils.cs
@@ -0,0 +1,1569 @@
+#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;
+#if HAVE_BIG_INTEGER
+using System.Numerics;
+#endif
+#if !HAVE_GUID_TRY_PARSE
+using System.Text;
+using System.Text.RegularExpressions;
+#endif
+using Newtonsoft.Json.Serialization;
+using System.Reflection;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+#if HAVE_ADO_NET
+using System.Data.SqlTypes;
+
+#endif
+
+namespace 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; set; }
+        public PrimitiveTypeCode TypeCode { get; set; }
+    }
+
+    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 { Type = typeof(object), TypeCode = PrimitiveTypeCode.Empty },
+            new TypeInformation { Type = typeof(object), TypeCode = PrimitiveTypeCode.Object },
+            new TypeInformation { Type = typeof(object), TypeCode = PrimitiveTypeCode.DBNull },
+            new TypeInformation { Type = typeof(bool), TypeCode = PrimitiveTypeCode.Boolean },
+            new TypeInformation { Type = typeof(char), TypeCode = PrimitiveTypeCode.Char },
+            new TypeInformation { Type = typeof(sbyte), TypeCode = PrimitiveTypeCode.SByte },
+            new TypeInformation { Type = typeof(byte), TypeCode = PrimitiveTypeCode.Byte },
+            new TypeInformation { Type = typeof(short), TypeCode = PrimitiveTypeCode.Int16 },
+            new TypeInformation { Type = typeof(ushort), TypeCode = PrimitiveTypeCode.UInt16 },
+            new TypeInformation { Type = typeof(int), TypeCode = PrimitiveTypeCode.Int32 },
+            new TypeInformation { Type = typeof(uint), TypeCode = PrimitiveTypeCode.UInt32 },
+            new TypeInformation { Type = typeof(long), TypeCode = PrimitiveTypeCode.Int64 },
+            new TypeInformation { Type = typeof(ulong), TypeCode = PrimitiveTypeCode.UInt64 },
+            new TypeInformation { Type = typeof(float), TypeCode = PrimitiveTypeCode.Single },
+            new TypeInformation { Type = typeof(double), TypeCode = PrimitiveTypeCode.Double },
+            new TypeInformation { Type = typeof(decimal), TypeCode = PrimitiveTypeCode.Decimal },
+            new TypeInformation { Type = typeof(DateTime), TypeCode = PrimitiveTypeCode.DateTime },
+            new TypeInformation { Type = typeof(object), TypeCode = PrimitiveTypeCode.Empty }, // no 17 in TypeCode for some reason
+            new TypeInformation { Type = typeof(string), TypeCode = 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>, Serialization.Func<object, object>> CastConverters =
+            new ThreadSafeStore<StructMultiKey<Type, Type>, Serialization.Func<object, object>>(CreateCastConverter);
+
+        private static Serialization.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)
+        {
+            Type valueType = value?.GetType();
+
+            if (value != null)
+            {
+                if (targetType.IsAssignableFrom(valueType))
+                {
+                    return value;
+                }
+
+                Serialization.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, 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/src/Newtonsoft.Json/Utilities/DateTimeParser.cs b/src/Newtonsoft.Json/Utilities/DateTimeParser.cs
new file mode 100644
index 00000000..9addb98e
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/DateTimeUtils.cs b/src/Newtonsoft.Json/Utilities/DateTimeUtils.cs
new file mode 100644
index 00000000..34e65a34
--- /dev/null
+++ b/src/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 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 universialTicks = ToUniversalTicks(dateTime, offset);
+
+            return UniversialTicksToJavaScriptTicks(universialTicks);
+        }
+
+        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 UniversialTicksToJavaScriptTicks(ticks);
+        }
+
+        private static long UniversialTicksToJavaScriptTicks(long universialTicks)
+        {
+            long javaScriptTicks = (universialTicks - 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 (!string.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 (!string.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 (!string.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 (!string.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 (string.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 (string.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;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Utilities/DictionaryWrapper.cs b/src/Newtonsoft.Json/Utilities/DictionaryWrapper.cs
new file mode 100644
index 00000000..78cea5e2
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/DictionaryWrapper.cs
@@ -0,0 +1,698 @@
+#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;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace 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
+
+        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);
+            }
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            if (_dictionary != null)
+            {
+                if (!_dictionary.Contains(key))
+                {
+                    value = default;
+                    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
+                {
+                    _genericDictionary[(TKey)key] = (TValue)value;
+                }
+            }
+        }
+
+        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/src/Newtonsoft.Json/Utilities/DynamicProxy.cs b/src/Newtonsoft.Json/Utilities/DynamicProxy.cs
new file mode 100644
index 00000000..caeb9194
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/DynamicProxyMetaObject.cs b/src/Newtonsoft.Json/Utilities/DynamicProxyMetaObject.cs
new file mode 100644
index 00000000..56b55656
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs b/src/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.cs
new file mode 100644
index 00000000..78a78924
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/DynamicReflectionDelegateFactory.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
+
+#if HAVE_REFLECTION_EMIT
+using System;
+using System.Collections.Generic;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+using System.Reflection;
+using System.Reflection.Emit;
+using Newtonsoft.Json.Serialization;
+using System.Globalization;
+
+namespace 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));
+
+            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(OpCodes.Ldloca_S, 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(OpCodes.Ldloca_S, 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(OpCodes.Ldloca_S, localVariable);
+                    generator.Emit(OpCodes.Initobj, parameterType);
+                    generator.Emit(OpCodes.Ldloc_S, 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 Serialization.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 (Serialization.Func<T>)dynamicMethod.CreateDelegate(typeof(Serialization.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 Serialization.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 (Serialization.Func<T, object>)dynamicMethod.CreateDelegate(typeof(Serialization.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 Serialization.Func<T, object> CreateGet<T>(FieldInfo fieldInfo)
+        {
+            if (fieldInfo.IsLiteral)
+            {
+                object constantValue = fieldInfo.GetValue(null);
+                Serialization.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 (Serialization.Func<T, object>)dynamicMethod.CreateDelegate(typeof(Serialization.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 Serialization.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 (Serialization.Action<T, object>)dynamicMethod.CreateDelegate(typeof(Serialization.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 Serialization.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 (Serialization.Action<T, object>)dynamicMethod.CreateDelegate(typeof(Serialization.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/src/Newtonsoft.Json/Utilities/DynamicUtils.cs b/src/Newtonsoft.Json/Utilities/DynamicUtils.cs
new file mode 100644
index 00000000..5822ba08
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/DynamicUtils.cs
@@ -0,0 +1,210 @@
+#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 Newtonsoft.Json.Serialization;
+
+namespace 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();
+                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();
+                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/src/Newtonsoft.Json/Utilities/EnumInfo.cs b/src/Newtonsoft.Json/Utilities/EnumInfo.cs
new file mode 100644
index 00000000..59eebea0
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/EnumUtils.cs b/src/Newtonsoft.Json/Utilities/EnumUtils.cs
new file mode 100644
index 00000000..729670be
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/EnumUtils.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.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.Serialization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+using System.Text;
+using Newtonsoft.Json.Serialization;
+
+namespace 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];
+
+            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
+                resolvedName = f.GetCustomAttributes(typeof(EnumMemberAttribute), true)
+                         .Cast<EnumMemberAttribute>()
+                         .Select(a => a.Value)
+                         .SingleOrDefault() ?? f.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;
+#endif
+
+                resolvedNames[i] = key.Value2 != null
+                    ? key.Value2.GetPropertyName(resolvedName, false)
+                    : 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, out string name)
+        {
+            return TryToString(enumType, value, camelCase ? _camelCaseNamingStrategy : null, out name);
+        }
+
+        public static bool TryToString(Type enumType, object value, NamingStrategy namingStrategy, 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/src/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs b/src/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs
new file mode 100644
index 00000000..22723fe4
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/ExpressionReflectionDelegateFactory.cs
@@ -0,0 +1,383 @@
+#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 Newtonsoft.Json.Serialization;
+
+namespace 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;
+        }
+
+        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 {Value = argExpression, Variable = variable, IsOut = 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 Serialization.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(Serialization.Func<T>), expression);
+
+                Serialization.Func<T> compiled = (Serialization.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 Serialization.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.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(Serialization.Func<T, object>), resultExpression, parameterExpression);
+
+            Serialization.Func<T, object> compiled = (Serialization.Func<T, object>)lambdaExpression.Compile();
+            return compiled;
+        }
+
+        public override Serialization.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));
+
+            Serialization.Func<T, object> compiled = Expression.Lambda<Serialization.Func<T, object>>(fieldExpression, sourceParameter).Compile();
+            return compiled;
+        }
+
+        public override Serialization.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(Serialization.Action<T, object>), assignExpression, sourceParameterExpression, valueParameterExpression);
+
+            Serialization.Action<T, object> compiled = (Serialization.Action<T, object>)lambdaExpression.Compile();
+            return compiled;
+        }
+
+        public override Serialization.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);
+
+            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(Serialization.Action<T, object>), setExpression, instanceParameter, valueParameter);
+
+            Serialization.Action<T, object> compiled = (Serialization.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/src/Newtonsoft.Json/Utilities/FSharpUtils.cs b/src/Newtonsoft.Json/Utilities/FSharpUtils.cs
new file mode 100644
index 00000000..5ff9ead9
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/FSharpUtils.cs
@@ -0,0 +1,195 @@
+#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 Newtonsoft.Json.Serialization;
+
+namespace 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 static class FSharpUtils
+    {
+        private static readonly object Lock = new object();
+
+        private static bool _initialized;
+        private static MethodInfo _ofSeq;
+        private static Type _mapType;
+
+        public static Assembly FSharpCoreAssembly { get; private set; }
+        public static MethodCall<object, object> IsUnion { get; private set; }
+        public static MethodCall<object, object> GetUnionCases { get; private set; }
+        public static MethodCall<object, object> PreComputeUnionTagReader { get; private set; }
+        public static MethodCall<object, object> PreComputeUnionReader { get; private set; }
+        public static MethodCall<object, object> PreComputeUnionConstructor { get; private set; }
+        public static Serialization.Func<object, object> GetUnionCaseInfoDeclaringType { get; private set; }
+        public static Serialization.Func<object, object> GetUnionCaseInfoName { get; private set; }
+        public static Serialization.Func<object, object> GetUnionCaseInfoTag { get; private set; }
+        public static 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 (!_initialized)
+            {
+                lock (Lock)
+                {
+                    if (!_initialized)
+                    {
+                        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");
+
+#if HAVE_MEMORY_BARRIER
+                        Thread.MemoryBarrier();
+#endif
+                        _initialized = true;
+                    }
+                }
+            }
+        }
+
+        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 static ObjectConstructor<object> CreateSeq(Type t)
+        {
+            MethodInfo seqType = _ofSeq.MakeGenericMethod(t);
+
+            return JsonTypeReflector.ReflectionDelegateFactory.CreateParameterizedConstructor(seqType);
+        }
+
+        public static ObjectConstructor<object> CreateMap(Type keyType, Type valueType)
+        {
+            MethodInfo creatorDefinition = typeof(FSharpUtils).GetMethod("BuildMapCreator");
+
+            MethodInfo creatorGeneric = creatorDefinition.MakeGenericMethod(keyType, valueType);
+
+            return (ObjectConstructor<object>)creatorGeneric.Invoke(null, null);
+        }
+
+        public static 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/src/Newtonsoft.Json/Utilities/ILGeneratorExtensions.cs b/src/Newtonsoft.Json/Utilities/ILGeneratorExtensions.cs
new file mode 100644
index 00000000..d9c49eae
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs b/src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs
new file mode 100644
index 00000000..5d60beb9
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs
@@ -0,0 +1,181 @@
+#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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+using System.Text;
+using Newtonsoft.Json.Serialization;
+
+namespace 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, ImmutableSortedSetGenericTypeName, ImmutableSortedSetTypeName),
+            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, ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryTypeName),
+            new ImmutableCollectionTypeInfo(ImmutableDictionaryGenericTypeName, ImmutableDictionaryGenericTypeName, ImmutableDictionaryTypeName)
+        };
+
+        internal static bool TryBuildImmutableForArrayContract(Type underlyingType, Type collectionItemType, out Type createdType, 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, out Type createdType, 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/src/Newtonsoft.Json/Utilities/JavaScriptUtils.cs b/src/Newtonsoft.Json/Utilities/JavaScriptUtils.cs
new file mode 100644
index 00000000..adde262f
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/JavaScriptUtils.cs
@@ -0,0 +1,653 @@
+#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;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace 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;
+            }
+
+            foreach (char c in s)
+            {
+                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 (!string.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);
+
+                        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)
+                                {
+                                    Debug.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);
+                        }
+                    }
+
+                    Debug.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 (string.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 (!string.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 (!string.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, 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, 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/src/Newtonsoft.Json/Utilities/JsonTokenUtils.cs b/src/Newtonsoft.Json/Utilities/JsonTokenUtils.cs
new file mode 100644
index 00000000..7e02baa2
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs b/src/Newtonsoft.Json/Utilities/LateBoundReflectionDelegateFactory.cs
new file mode 100644
index 00000000..817004b1
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Serialization;
+using System.Reflection;
+
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace 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 Serialization.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 Serialization.Func<T, object> CreateGet<T>(PropertyInfo propertyInfo)
+        {
+            ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
+
+            return o => propertyInfo.GetValue(o, null);
+        }
+
+        public override Serialization.Func<T, object> CreateGet<T>(FieldInfo fieldInfo)
+        {
+            ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
+
+            return o => fieldInfo.GetValue(o);
+        }
+
+        public override Serialization.Action<T, object> CreateSet<T>(FieldInfo fieldInfo)
+        {
+            ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
+
+            return (o, v) => fieldInfo.SetValue(o, v);
+        }
+
+        public override Serialization.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/src/Newtonsoft.Json/Utilities/LinqBridge.cs b/src/Newtonsoft.Json/Utilities/LinqBridge.cs
new file mode 100644
index 00000000..c00efaad
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/LinqBridge.cs
@@ -0,0 +1,3071 @@
+
+#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 Newtonsoft.Json.Serialization;
+
+namespace 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,
+      Serialization.Func<TSource, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      return WhereYield(source, predicate);
+    }
+
+    private static IEnumerable<TSource> WhereYield<TSource>(
+      IEnumerable<TSource> source,
+      Serialization.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,
+      Serialization.Func<TSource, int, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      return WhereYield(source, predicate);
+    }
+
+    private static IEnumerable<TSource> WhereYield<TSource>(
+      IEnumerable<TSource> source,
+      Serialization.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,
+      Serialization.Func<TSource, TResult> selector)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(selector, "selector");
+
+      return SelectYield(source, selector);
+    }
+
+    private static IEnumerable<TResult> SelectYield<TSource, TResult>(
+      IEnumerable<TSource> source,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.Func<TSource, IEnumerable<TCollection>> collectionSelector,
+      Serialization.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,
+      Serialization.Func<TSource, int, IEnumerable<TCollection>> collectionSelector,
+      Serialization.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,
+      Serialization.Func<TSource, int, IEnumerable<TCollection>> collectionSelector,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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 Serialization.Func<T> Default = () => default(T);
+      public static readonly Serialization.Func<T> Undefined = () => { throw new InvalidOperationException(); };
+    }
+
+    /// <summary>
+    /// Base implementation of First operator.
+    /// </summary>
+
+    private static TSource FirstImpl<TSource>(
+      this IEnumerable<TSource> source,
+      Serialization.Func<TSource> empty)
+    {
+      CheckNotNull(source, "source");
+      Debug.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.Func<TSource, int, bool> predicate)
+    {
+      CheckNotNull(source, "source");
+      CheckNotNull(predicate, "predicate");
+
+      return SkipWhileYield(source, predicate);
+    }
+
+    private static IEnumerable<TSource> SkipWhileYield<TSource>(
+      IEnumerable<TSource> source,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.Func<TSource, TElement> elementSelector,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.Func<TSource, TElement> elementSelector,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.Func<TAccumulate, TSource, TAccumulate> func,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.Func<TSource, TSource, bool> lesser)
+    {
+      CheckNotNull(source, "source");
+      Debug.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, Serialization.Func<TSource?, TSource?, bool> lesser) where TSource : struct
+    {
+      CheckNotNull(source, "source");
+      Debug.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,
+      Serialization.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,
+      Serialization.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)
+    {
+      Debug.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.Func<TSource, TKey> keySelector,
+      Serialization.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,
+      Serialization.Func<TOuter, TKey> outerKeySelector,
+      Serialization.Func<TInner, TKey> innerKeySelector,
+      Serialization.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,
+      Serialization.Func<TOuter, TKey> outerKeySelector,
+      Serialization.Func<TInner, TKey> innerKeySelector,
+      Serialization.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,
+      Serialization.Func<TOuter, TKey> outerKeySelector,
+      Serialization.Func<TInner, TKey> innerKeySelector,
+      Serialization.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,
+      Serialization.Func<TOuter, TKey> outerKeySelector,
+      Serialization.Func<TInner, TKey> innerKeySelector,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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,
+      Serialization.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>(
+      Serialization.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>(
+      Serialization.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,
+                             Serialization.Func<T, K> keySelector, IComparer<K> comparer, bool descending) :
+                               this(source, null, keySelector, comparer, descending)
+    {
+    }
+
+    private OrderedEnumerable(IEnumerable<T> source, List<Comparison<T>> comparisons,
+                              Serialization.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>(
+      Serialization.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 Serialization.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 Serialization.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 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/src/Newtonsoft.Json/Utilities/MathUtils.cs b/src/Newtonsoft.Json/Utilities/MathUtils.cs
new file mode 100644
index 00000000..2818483e
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/MethodBinder.cs b/src/Newtonsoft.Json/Utilities/MethodBinder.cs
new file mode 100644
index 00000000..17d5c627
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+
+namespace 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/src/Newtonsoft.Json/Utilities/MethodCall.cs b/src/Newtonsoft.Json/Utilities/MethodCall.cs
new file mode 100644
index 00000000..8b16e28f
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities
+{
+    internal delegate TResult MethodCall<T, TResult>(T target, params object[] args);
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Utilities/MiscellaneousUtils.cs b/src/Newtonsoft.Json/Utilities/MiscellaneousUtils.cs
new file mode 100644
index 00000000..399e500d
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/MiscellaneousUtils.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
+
+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;
+
+namespace Newtonsoft.Json.Utilities
+{
+    internal delegate T Creator<T>();
+
+    internal static class MiscellaneousUtils
+    {
+        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;
+            foreach (char c in optionsText)
+            {
+                switch (c)
+                {
+                    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/src/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs b/src/Newtonsoft.Json/Utilities/ReflectionDelegateFactory.cs
new file mode 100644
index 00000000..eeedc03b
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Serialization;
+
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+
+namespace Newtonsoft.Json.Utilities
+{
+    internal abstract class ReflectionDelegateFactory
+    {
+        public Serialization.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 Serialization.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 Serialization.Func<T> CreateDefaultConstructor<T>(Type type);
+        public abstract Serialization.Func<T, object> CreateGet<T>(PropertyInfo propertyInfo);
+        public abstract Serialization.Func<T, object> CreateGet<T>(FieldInfo fieldInfo);
+        public abstract Serialization.Action<T, object> CreateSet<T>(FieldInfo fieldInfo);
+        public abstract Serialization.Action<T, object> CreateSet<T>(PropertyInfo propertyInfo);
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/Utilities/ReflectionObject.cs b/src/Newtonsoft.Json/Utilities/ReflectionObject.cs
new file mode 100644
index 00000000..a3009d6f
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Globalization;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace Newtonsoft.Json.Utilities
+{
+    internal class ReflectionMember
+    {
+        public Type MemberType { get; set; }
+        public Serialization.Func<object, object> Getter { get; set; }
+        public Serialization.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)
+        {
+            Serialization.Func<object, object> getter = Members[member].Getter;
+            return getter(target);
+        }
+
+        public void SetValue(object target, string member, object value)
+        {
+            Serialization.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))
+                {
+                    Serialization.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/src/Newtonsoft.Json/Utilities/ReflectionUtils.cs b/src/Newtonsoft.Json/Utilities/ReflectionUtils.cs
new file mode 100644
index 00000000..c4ed506e
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/ReflectionUtils.cs
@@ -0,0 +1,1092 @@
+#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;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using Newtonsoft.Json.Serialization;
+
+namespace 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)
+        {
+            if (property.GetGetMethod() != null && property.GetGetMethod().IsPublic)
+            {
+                return true;
+            }
+            if (property.GetSetMethod() != null && property.GetSetMethod().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, 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);
+        }
+    }
+}
diff --git a/src/Newtonsoft.Json/Utilities/StringBuffer.cs b/src/Newtonsoft.Json/Utilities/StringBuffer.cs
new file mode 100644
index 00000000..8c9dcf47
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/StringReference.cs b/src/Newtonsoft.Json/Utilities/StringReference.cs
new file mode 100644
index 00000000..44591d11
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/StringUtils.cs b/src/Newtonsoft.Json/Utilities/StringUtils.cs
new file mode 100644
index 00000000..4ed03c93
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/StringUtils.cs
@@ -0,0 +1,344 @@
+#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;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using Newtonsoft.Json.Serialization;
+
+namespace 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 string FormatWith(this string format, IFormatProvider provider, object arg0)
+        {
+            return format.FormatWith(provider, new[] { arg0 });
+        }
+
+        public static string FormatWith(this string format, IFormatProvider provider, object arg0, object arg1)
+        {
+            return format.FormatWith(provider, new[] { arg0, arg1 });
+        }
+
+        public static string FormatWith(this string format, IFormatProvider provider, object arg0, object arg1, object arg2)
+        {
+            return format.FormatWith(provider, new[] { 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[] { 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, Serialization.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 (string.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_STRING_WITH_CULTURE
+            c = char.ToLower(c, CultureInfo.InvariantCulture);
+#else
+            c = char.ToLowerInvariant(c);
+#endif
+            return c;
+        }
+
+        internal enum SnakeCaseState
+        {
+            Start,
+            Lower,
+            Upper,
+            NewWord
+        }
+
+        public static string ToSnakeCase(string s)
+        {
+            if (string.IsNullOrEmpty(s))
+            {
+                return s;
+            }
+
+            StringBuilder sb = new StringBuilder();
+            SnakeCaseState state = SnakeCaseState.Start;
+
+            for (int i = 0; i < s.Length; i++)
+            {
+                if (s[i] == ' ')
+                {
+                    if (state != SnakeCaseState.Start)
+                    {
+                        state = SnakeCaseState.NewWord;
+                    }
+                }
+                else if (char.IsUpper(s[i]))
+                {
+                    switch (state)
+                    {
+                        case SnakeCaseState.Upper:
+                            bool hasNext = (i + 1 < s.Length);
+                            if (i > 0 && hasNext)
+                            {
+                                char nextChar = s[i + 1];
+                                if (!char.IsUpper(nextChar) && nextChar != '_')
+                                {
+                                    sb.Append('_');
+                                }
+                            }
+                            break;
+                        case SnakeCaseState.Lower:
+                        case SnakeCaseState.NewWord:
+                            sb.Append('_');
+                            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 = SnakeCaseState.Upper;
+                }
+                else if (s[i] == '_')
+                {
+                    sb.Append('_');
+                    state = SnakeCaseState.Start;
+                }
+                else
+                {
+                    if (state == SnakeCaseState.NewWord)
+                    {
+                        sb.Append('_');
+                    }
+
+                    sb.Append(s[i]);
+                    state = SnakeCaseState.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/src/Newtonsoft.Json/Utilities/StructMultiKey.cs b/src/Newtonsoft.Json/Utilities/StructMultiKey.cs
new file mode 100644
index 00000000..10428aaa
--- /dev/null
+++ b/src/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 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/src/Newtonsoft.Json/Utilities/ThreadSafeStore.cs b/src/Newtonsoft.Json/Utilities/ThreadSafeStore.cs
new file mode 100644
index 00000000..6b618efe
--- /dev/null
+++ b/src/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 Newtonsoft.Json.Utilities.LinqBridge;
+#endif
+#if HAVE_CONCURRENT_DICTIONARY
+using System.Collections.Concurrent;
+#endif
+using System.Threading;
+using Newtonsoft.Json.Serialization;
+
+namespace 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 Serialization.Func<TKey, TValue> _creator;
+
+        public ThreadSafeStore(Serialization.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/src/Newtonsoft.Json/Utilities/TypeExtensions.cs b/src/Newtonsoft.Json/Utilities/TypeExtensions.cs
new file mode 100644
index 00000000..64608081
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/TypeExtensions.cs
@@ -0,0 +1,632 @@
+#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;
+#if !HAVE_LINQ
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+
+namespace 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, 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/src/Newtonsoft.Json/Utilities/ValidationUtils.cs b/src/Newtonsoft.Json/Utilities/ValidationUtils.cs
new file mode 100644
index 00000000..845ba3ea
--- /dev/null
+++ b/src/Newtonsoft.Json/Utilities/ValidationUtils.cs
@@ -0,0 +1,40 @@
+#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 Newtonsoft.Json.Utilities
+{
+    internal static class ValidationUtils
+    {
+        public static void ArgumentNotNull(object value, string parameterName)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(parameterName);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Newtonsoft.Json/WriteState.cs b/src/Newtonsoft.Json/WriteState.cs
new file mode 100644
index 00000000..adf3ab00
--- /dev/null
+++ b/src/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 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/src/Options/ModOptionsCheckbox.cs b/src/Options/ModOptionsCheckbox.cs
new file mode 100644
index 00000000..aa0bfd81
--- /dev/null
+++ b/src/Options/ModOptionsCheckbox.cs
@@ -0,0 +1,34 @@
+using StardewValley.Menus;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Xna.Framework.Input;
+
+namespace SMDroid.Options
+{
+    public class ModOptionsCheckbox : OptionsCheckbox
+    {
+        Action<bool> onChanged;
+        public ModOptionsCheckbox(string label, int whichOption, Action<bool> onChanged, int x = -1, int y = -1) : base(label, whichOption, x, y)
+        {
+            this.onChanged = onChanged;
+        }
+        public override void receiveLeftClick(int x, int y)
+        {
+            base.receiveLeftClick(x, y);
+            this.onChanged(this.isChecked);
+        }
+        public override void receiveKeyPress(Keys key)
+        {
+            base.receiveKeyPress(key);
+            this.onChanged(this.isChecked);
+        }
+        public override void leftClickHeld(int x, int y)
+        {
+            base.leftClickHeld(x, y);
+            this.onChanged(this.isChecked);
+        }
+    }
+}
diff --git a/src/Options/ModOptionsSlider.cs b/src/Options/ModOptionsSlider.cs
new file mode 100644
index 00000000..41524be4
--- /dev/null
+++ b/src/Options/ModOptionsSlider.cs
@@ -0,0 +1,34 @@
+using StardewValley.Menus;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Xna.Framework.Input;
+
+namespace SMDroid.Options
+{
+    public class ModOptionsSlider : OptionsSlider
+    {
+        Action<int> onChanged;
+        public ModOptionsSlider(string label, int whichOption, Action<int> onChanged, int x = -1, int y = -1) : base(label, whichOption, x, y)
+        {
+            this.onChanged = onChanged;
+        }
+        public override void receiveLeftClick(int x, int y)
+        {
+            base.receiveLeftClick(x, y);
+            this.onChanged(this.value);
+        }
+        public override void receiveKeyPress(Keys key)
+        {
+            base.receiveKeyPress(key);
+            this.onChanged(this.value);
+        }
+        public override void leftClickHeld(int x, int y)
+        {
+            base.leftClickHeld(x, y);
+            this.onChanged(this.value);
+        }
+    }
+}
diff --git a/src/Properties/AssemblyInfo.cs b/src/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..4cb475e1
--- /dev/null
+++ b/src/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("Mod")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Mod")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+//将 ComVisible 设置为 false 将使此程序集中的类型
+//对 COM 组件不可见。  如果需要从 COM 访问此程序集中的类型，
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("23b6885e-0282-435b-a854-d49abf1391d6")]
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值，
+// 方法是按如下所示使用“*”: :
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/SMAPI.Installer/Enums/ScriptAction.cs b/src/SMAPI.Installer/Enums/ScriptAction.cs
deleted file mode 100644
index e62b2a7c..00000000
--- a/src/SMAPI.Installer/Enums/ScriptAction.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace StardewModdingApi.Installer.Enums
-{
-    /// <summary>The action to perform.</summary>
-    internal enum ScriptAction
-    {
-        /// <summary>Install SMAPI to the game directory.</summary>
-        Install,
-
-        /// <summary>Remove SMAPI from the game directory.</summary>
-        Uninstall
-    }
-}
\ No newline at end of file
diff --git a/src/SMAPI.Installer/Framework/InstallerPaths.cs b/src/SMAPI.Installer/Framework/InstallerPaths.cs
deleted file mode 100644
index e5396018..00000000
--- a/src/SMAPI.Installer/Framework/InstallerPaths.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-using System.IO;
-
-namespace StardewModdingAPI.Installer.Framework
-{
-    /// <summary>Manages paths for the SMAPI installer.</summary>
-    internal class InstallerPaths
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The directory path containing the files to copy into the game folder.</summary>
-        public DirectoryInfo BundleDir { get; }
-
-        /// <summary>The directory containing the installed game.</summary>
-        public DirectoryInfo GameDir { get; }
-
-        /// <summary>The directory into which to install mods.</summary>
-        public DirectoryInfo ModsDir { get; }
-
-        /// <summary>The full path to directory path containing the files to copy into the game folder.</summary>
-        public string BundlePath => this.BundleDir.FullName;
-
-        /// <summary>The full path to the directory containing the installed game.</summary>
-        public string GamePath => this.GameDir.FullName;
-
-        /// <summary>The full path to the directory into which to install mods.</summary>
-        public string ModsPath => this.ModsDir.FullName;
-
-        /// <summary>The full path to SMAPI's internal configuration file.</summary>
-        public string ApiConfigPath { get; }
-
-        /// <summary>The full path to the installed SMAPI executable file.</summary>
-        public string ExecutablePath { get; }
-
-        /// <summary>The full path to the vanilla game launcher on Linux/Mac.</summary>
-        public string UnixLauncherPath { get; }
-
-        /// <summary>The full path to the installed SMAPI launcher on Linux/Mac before it's renamed.</summary>
-        public string UnixSmapiLauncherPath { get; }
-
-        /// <summary>The full path to the vanilla game launcher on Linux/Mac after SMAPI is installed.</summary>
-        public string UnixBackupLauncherPath { get; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="bundleDir">The directory path containing the files to copy into the game folder.</param>
-        /// <param name="gameDir">The directory path for the installed game.</param>
-        /// <param name="gameExecutableName">The name of the game's executable file for the current platform.</param>
-        public InstallerPaths(DirectoryInfo bundleDir, DirectoryInfo gameDir, string gameExecutableName)
-        {
-            this.BundleDir = bundleDir;
-            this.GameDir = gameDir;
-            this.ModsDir = new DirectoryInfo(Path.Combine(gameDir.FullName, "Mods"));
-
-            this.ExecutablePath = Path.Combine(gameDir.FullName, gameExecutableName);
-            this.UnixLauncherPath = Path.Combine(gameDir.FullName, "StardewValley");
-            this.UnixSmapiLauncherPath = Path.Combine(gameDir.FullName, "StardewModdingAPI");
-            this.UnixBackupLauncherPath = Path.Combine(gameDir.FullName, "StardewValley-original");
-            this.ApiConfigPath = Path.Combine(gameDir.FullName, "smapi-internal", "StardewModdingAPI.config.json");
-        }
-    }
-}
diff --git a/src/SMAPI.Installer/InteractiveInstaller.cs b/src/SMAPI.Installer/InteractiveInstaller.cs
deleted file mode 100644
index 7148b1d9..00000000
--- a/src/SMAPI.Installer/InteractiveInstaller.cs
+++ /dev/null
@@ -1,992 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using Microsoft.Win32;
-using StardewModdingApi.Installer.Enums;
-using StardewModdingAPI.Installer.Framework;
-using StardewModdingAPI.Internal;
-using StardewModdingAPI.Internal.ConsoleWriting;
-using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Toolkit.Framework.ModScanning;
-using StardewModdingAPI.Toolkit.Utilities;
-#if !SMAPI_FOR_WINDOWS
-using System.Diagnostics;
-#endif
-
-namespace StardewModdingApi.Installer
-{
-    /// <summary>Interactively performs the install and uninstall logic.</summary>
-    internal class InteractiveInstaller
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The absolute path to the directory containing the files to copy into the game folder.</summary>
-        private readonly string BundlePath;
-
-        /// <summary>The <see cref="Environment.OSVersion"/> value that represents Windows 7.</summary>
-        private readonly Version Windows7Version = new Version(6, 1);
-
-        /// <summary>The mod IDs which the installer should allow as bundled mods.</summary>
-        private readonly string[] BundledModIDs = new[]
-        {
-            "SMAPI.SaveBackup",
-            "SMAPI.ConsoleCommands"
-        };
-
-        /// <summary>The default file paths where Stardew Valley can be installed.</summary>
-        /// <param name="platform">The target platform.</param>
-        /// <remarks>Derived from the crossplatform mod config: https://github.com/Pathoschild/Stardew.ModBuildConfig. </remarks>
-        private IEnumerable<string> GetDefaultInstallPaths(Platform platform)
-        {
-            switch (platform)
-            {
-                case Platform.Linux:
-                case Platform.Mac:
-                    {
-                        string home = Environment.GetEnvironmentVariable("HOME");
-
-                        // Linux
-                        yield return $"{home}/GOG Games/Stardew Valley/game";
-                        yield return Directory.Exists($"{home}/.steam/steam/steamapps/common/Stardew Valley")
-                            ? $"{home}/.steam/steam/steamapps/common/Stardew Valley"
-                            : $"{home}/.local/share/Steam/steamapps/common/Stardew Valley";
-
-                        // Mac
-                        yield return "/Applications/Stardew Valley.app/Contents/MacOS";
-                        yield return $"{home}/Library/Application Support/Steam/steamapps/common/Stardew Valley/Contents/MacOS";
-                    }
-                    break;
-
-                case Platform.Windows:
-                    {
-                        // Windows
-                        foreach (string programFiles in new[] { @"C:\Program Files", @"C:\Program Files (x86)" })
-                        {
-                            yield return $@"{programFiles}\GalaxyClient\Games\Stardew Valley";
-                            yield return $@"{programFiles}\GOG Galaxy\Games\Stardew Valley";
-                            yield return $@"{programFiles}\Steam\steamapps\common\Stardew Valley";
-                        }
-
-                        // Windows registry
-                        IDictionary<string, string> registryKeys = new Dictionary<string, string>
-                        {
-                            [@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Steam App 413150"] = "InstallLocation", // Steam
-                            [@"SOFTWARE\WOW6432Node\GOG.com\Games\1453375253"] = "PATH", // GOG on 64-bit Windows
-                        };
-                        foreach (var pair in registryKeys)
-                        {
-                            string path = this.GetLocalMachineRegistryValue(pair.Key, pair.Value);
-                            if (!string.IsNullOrWhiteSpace(path))
-                                yield return path;
-                        }
-
-                        // via Steam library path
-                        string steampath = this.GetCurrentUserRegistryValue(@"Software\Valve\Steam", "SteamPath");
-                        if (steampath != null)
-                            yield return Path.Combine(steampath.Replace('/', '\\'), @"steamapps\common\Stardew Valley");
-                    }
-                    break;
-
-                default:
-                    throw new InvalidOperationException($"Unknown platform '{platform}'.");
-            }
-        }
-
-        /// <summary>Get the absolute file or folder paths to remove when uninstalling SMAPI.</summary>
-        /// <param name="installDir">The folder for Stardew Valley and SMAPI.</param>
-        /// <param name="modsDir">The folder for SMAPI mods.</param>
-        private IEnumerable<string> GetUninstallPaths(DirectoryInfo installDir, DirectoryInfo modsDir)
-        {
-            string GetInstallPath(string path) => Path.Combine(installDir.FullName, path);
-
-            // current files
-            yield return GetInstallPath("libgdiplus.dylib");           // Linux/Mac only
-            yield return GetInstallPath("StardewModdingAPI");          // Linux/Mac only
-            yield return GetInstallPath("StardewModdingAPI.exe");
-            yield return GetInstallPath("StardewModdingAPI.exe.config");
-            yield return GetInstallPath("StardewModdingAPI.exe.mdb");  // Linux/Mac only
-            yield return GetInstallPath("StardewModdingAPI.pdb");      // Windows only
-            yield return GetInstallPath("StardewModdingAPI.xml");
-            yield return GetInstallPath("smapi-internal");
-
-            // obsolete
-            yield return GetInstallPath(Path.Combine("Mods", ".cache"));     // 1.3-1.4
-            yield return GetInstallPath(Path.Combine("Mods", "TrainerMod")); // *–2.0 (renamed to ConsoleCommands)
-            yield return GetInstallPath("Mono.Cecil.Rocks.dll");             // 1.3–1.8
-            yield return GetInstallPath("StardewModdingAPI-settings.json");  // 1.0-1.4
-            yield return GetInstallPath("StardewModdingAPI.AssemblyRewriters.dll"); // 1.3-2.5.5
-            yield return GetInstallPath("0Harmony.dll");                    // moved in 2.8
-            yield return GetInstallPath("0Harmony.pdb");                    // moved in 2.8
-            yield return GetInstallPath("Mono.Cecil.dll");                  // moved in 2.8
-            yield return GetInstallPath("Newtonsoft.Json.dll");             // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.config.json");   // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.crash.marker");  // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.metadata.json"); // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.update.marker"); // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.Toolkit.dll");   // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.Toolkit.pdb");   // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.Toolkit.xml");   // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.Toolkit.CoreInterfaces.dll"); // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.Toolkit.CoreInterfaces.pdb"); // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.Toolkit.CoreInterfaces.xml"); // moved in 2.8
-            yield return GetInstallPath("StardewModdingAPI.xml");             // moved in 2.8
-            yield return GetInstallPath("System.Numerics.dll");               // moved in 2.8
-            yield return GetInstallPath("System.Runtime.Caching.dll");        // moved in 2.8
-            yield return GetInstallPath("System.ValueTuple.dll");             // moved in 2.8
-            yield return GetInstallPath("steam_appid.txt");                   // moved in 2.8
-
-            if (modsDir.Exists)
-            {
-                foreach (DirectoryInfo modDir in modsDir.EnumerateDirectories())
-                    yield return Path.Combine(modDir.FullName, ".cache"); // 1.4–1.7
-            }
-            yield return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "StardewValley", "ErrorLogs"); // remove old log files
-        }
-
-        /// <summary>Handles writing color-coded text to the console.</summary>
-        private ColorfulConsoleWriter ConsoleWriter;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="bundlePath">The absolute path to the directory containing the files to copy into the game folder.</param>
-        public InteractiveInstaller(string bundlePath)
-        {
-            this.BundlePath = bundlePath;
-            this.ConsoleWriter = new ColorfulConsoleWriter(EnvironmentUtility.DetectPlatform(), MonitorColorScheme.AutoDetect);
-        }
-
-        /// <summary>Run the install or uninstall script.</summary>
-        /// <param name="args">The command line arguments.</param>
-        /// <remarks>
-        /// Initialisation flow:
-        ///     1. Collect information (mainly OS and install path) and validate it.
-        ///     2. Ask the user whether to install or uninstall.
-        ///
-        /// Uninstall logic:
-        ///     1. On Linux/Mac: if a backup of the launcher exists, delete the launcher and restore the backup.
-        ///     2. Delete all files and folders in the game directory matching one of the values returned by <see cref="GetUninstallPaths"/>.
-        ///
-        /// Install flow:
-        ///     1. Run the uninstall flow.
-        ///     2. Copy the SMAPI files from package/Windows or package/Mono into the game directory.
-        ///     3. On Linux/Mac: back up the game launcher and replace it with the SMAPI launcher. (This isn't possible on Windows, so the user needs to configure it manually.)
-        ///     4. Create the 'Mods' directory.
-        ///     5. Copy the bundled mods into the 'Mods' directory (deleting any existing versions).
-        ///     6. Move any mods from app data into game's mods directory.
-        /// </remarks>
-        public void Run(string[] args)
-        {
-            /*********
-            ** Step 1: initial setup
-            *********/
-            /****
-            ** Get platform & set window title
-            ****/
-            Platform platform = EnvironmentUtility.DetectPlatform();
-            Console.Title = $"SMAPI {this.GetDisplayVersion(this.GetType().Assembly.GetName().Version)} installer on {platform} {EnvironmentUtility.GetFriendlyPlatformName(platform)}";
-            Console.WriteLine();
-
-            /****
-            ** Check if correct installer
-            ****/
-#if SMAPI_FOR_WINDOWS
-            if (platform == Platform.Linux || platform == Platform.Mac)
-            {
-                this.PrintError($"This is the installer for Windows. Run the 'install on {platform}.{(platform == Platform.Linux ? "sh" : "command")}' file instead.");
-                Console.ReadLine();
-                return;
-            }
-#else
-            if (platform == Platform.Windows)
-            {
-                this.PrintError($"This is the installer for Linux/Mac. Run the 'install on Windows.exe' file instead.");
-                Console.ReadLine();
-                return;
-            }
-#endif
-
-            /****
-            ** Check Windows dependencies
-            ****/
-            if (platform == Platform.Windows)
-            {
-                // .NET Framework 4.5+
-                if (!this.HasNetFramework45(platform))
-                {
-                    this.PrintError(Environment.OSVersion.Version >= this.Windows7Version
-                            ? "Please install the latest version of .NET Framework before installing SMAPI." // Windows 7+
-                            : "Please install .NET Framework 4.5 before installing SMAPI." // Windows Vista or earlier
-                    );
-                    this.PrintError("See the download page at https://www.microsoft.com/net/download/framework for details.");
-                    Console.ReadLine();
-                    return;
-                }
-                if (!this.HasXna(platform))
-                {
-                    this.PrintError("You don't seem to have XNA Framework installed. Please run the game at least once before installing SMAPI, so it can perform its first-time setup.");
-                    Console.ReadLine();
-                    return;
-                }
-            }
-
-            /****
-            ** read command-line arguments
-            ****/
-            // get action from CLI
-            bool installArg = args.Contains("--install");
-            bool uninstallArg = args.Contains("--uninstall");
-            if (installArg && uninstallArg)
-            {
-                this.PrintError("You can't specify both --install and --uninstall command-line flags.");
-                Console.ReadLine();
-                return;
-            }
-
-            // get game path from CLI
-            string gamePathArg = null;
-            {
-                int pathIndex = Array.LastIndexOf(args, "--game-path") + 1;
-                if (pathIndex >= 1 && args.Length >= pathIndex)
-                    gamePathArg = args[pathIndex];
-            }
-
-
-            /*********
-            ** Step 2: choose a theme (can't auto-detect on Linux/Mac)
-            *********/
-            MonitorColorScheme scheme = MonitorColorScheme.AutoDetect;
-            if (platform == Platform.Linux || platform == Platform.Mac)
-            {
-                /****
-                ** print header
-                ****/
-                this.PrintPlain("Hi there! I'll help you install or remove SMAPI. Just a few questions first.");
-                this.PrintPlain("----------------------------------------------------------------------------");
-                Console.WriteLine();
-
-                /****
-                ** show theme selector
-                ****/
-                // get theme writers
-                var lightBackgroundWriter = new ColorfulConsoleWriter(EnvironmentUtility.DetectPlatform(), MonitorColorScheme.LightBackground);
-                var darkDarkgroundWriter = new ColorfulConsoleWriter(EnvironmentUtility.DetectPlatform(), MonitorColorScheme.DarkBackground);
-
-                // print question
-                this.PrintPlain("Which text looks more readable?");
-                Console.WriteLine();
-                Console.Write("   [1] ");
-                lightBackgroundWriter.WriteLine("Dark text on light background", ConsoleLogLevel.Info);
-                Console.Write("   [2] ");
-                darkDarkgroundWriter.WriteLine("Light text on dark background", ConsoleLogLevel.Info);
-                Console.WriteLine();
-
-                // handle choice
-                string choice = this.InteractivelyChoose("Type 1 or 2, then press enter.", new[] { "1", "2" });
-                switch (choice)
-                {
-                    case "1":
-                        scheme = MonitorColorScheme.LightBackground;
-                        this.ConsoleWriter = lightBackgroundWriter;
-                        break;
-                    case "2":
-                        scheme = MonitorColorScheme.DarkBackground;
-                        this.ConsoleWriter = darkDarkgroundWriter;
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected action key '{choice}'.");
-                }
-            }
-            Console.Clear();
-
-
-            /*********
-            ** Step 3: find game folder
-            *********/
-            InstallerPaths paths;
-            {
-                /****
-                ** print header
-                ****/
-                this.PrintInfo("Hi there! I'll help you install or remove SMAPI. Just a few questions first.");
-                this.PrintDebug($"Color scheme: {this.GetDisplayText(scheme)}");
-                this.PrintDebug("----------------------------------------------------------------------------");
-                Console.WriteLine();
-
-                /****
-                ** collect details
-                ****/
-                // get game path
-                this.PrintInfo("Where is your game folder?");
-                DirectoryInfo installDir = this.InteractivelyGetInstallPath(platform, gamePathArg);
-                if (installDir == null)
-                {
-                    this.PrintError("Failed finding your game path.");
-                    Console.ReadLine();
-                    return;
-                }
-
-                // get folders
-                DirectoryInfo bundleDir = new DirectoryInfo(this.BundlePath);
-                paths = new InstallerPaths(bundleDir, installDir, EnvironmentUtility.GetExecutableName(platform));
-            }
-            Console.Clear();
-
-
-            /*********
-            ** Step 4: validate assumptions
-            *********/
-            if (!File.Exists(paths.ExecutablePath))
-            {
-                this.PrintError("The detected game install path doesn't contain a Stardew Valley executable.");
-                Console.ReadLine();
-                return;
-            }
-
-
-            /*********
-            ** Step 5: ask what to do
-            *********/
-            ScriptAction action;
-            {
-                /****
-                ** print header
-                ****/
-                this.PrintInfo("Hi there! I'll help you install or remove SMAPI. Just one question first.");
-                this.PrintDebug($"Game path: {paths.GamePath}");
-                this.PrintDebug($"Color scheme: {this.GetDisplayText(scheme)}");
-                this.PrintDebug("----------------------------------------------------------------------------");
-                Console.WriteLine();
-
-                /****
-                ** ask what to do
-                ****/
-                if (installArg)
-                    action = ScriptAction.Install;
-                else if (uninstallArg)
-                    action = ScriptAction.Uninstall;
-                else
-                {
-                    this.PrintInfo("What do you want to do?");
-                    Console.WriteLine();
-                    this.PrintInfo("[1] Install SMAPI.");
-                    this.PrintInfo("[2] Uninstall SMAPI.");
-                    Console.WriteLine();
-
-                    string choice = this.InteractivelyChoose("Type 1 or 2, then press enter.", new[] { "1", "2" });
-                    switch (choice)
-                    {
-                        case "1":
-                            action = ScriptAction.Install;
-                            break;
-                        case "2":
-                            action = ScriptAction.Uninstall;
-                            break;
-                        default:
-                            throw new InvalidOperationException($"Unexpected action key '{choice}'.");
-                    }
-                }
-            }
-            Console.Clear();
-
-
-            /*********
-            ** Step 6: apply
-            *********/
-            {
-                /****
-                ** print header
-                ****/
-                this.PrintInfo($"That's all I need! I'll {action.ToString().ToLower()} SMAPI now.");
-                this.PrintDebug($"Game path: {paths.GamePath}");
-                this.PrintDebug($"Color scheme: {this.GetDisplayText(scheme)}");
-                this.PrintDebug("----------------------------------------------------------------------------");
-                Console.WriteLine();
-
-                /****
-                ** Always uninstall old files
-                ****/
-                // restore game launcher
-                if (platform.IsMono() && File.Exists(paths.UnixBackupLauncherPath))
-                {
-                    this.PrintDebug("Removing SMAPI launcher...");
-                    this.InteractivelyDelete(paths.UnixLauncherPath);
-                    File.Move(paths.UnixBackupLauncherPath, paths.UnixLauncherPath);
-                }
-
-                // remove old files
-                string[] removePaths = this.GetUninstallPaths(paths.GameDir, paths.ModsDir)
-                    .Where(path => Directory.Exists(path) || File.Exists(path))
-                    .ToArray();
-                if (removePaths.Any())
-                {
-                    this.PrintDebug(action == ScriptAction.Install ? "Removing previous SMAPI files..." : "Removing SMAPI files...");
-                    foreach (string path in removePaths)
-                        this.InteractivelyDelete(path);
-                }
-
-                /****
-                ** Install new files
-                ****/
-                if (action == ScriptAction.Install)
-                {
-                    // copy SMAPI files to game dir
-                    this.PrintDebug("Adding SMAPI files...");
-                    foreach (FileSystemInfo sourceEntry in paths.BundleDir.EnumerateFileSystemInfos().Where(this.ShouldCopy))
-                    {
-                        this.InteractivelyDelete(Path.Combine(paths.GameDir.FullName, sourceEntry.Name));
-                        this.RecursiveCopy(sourceEntry, paths.GameDir);
-                    }
-
-                    // replace mod launcher (if possible)
-                    if (platform.IsMono())
-                    {
-                        this.PrintDebug("Safely replacing game launcher...");
-
-                        // back up & remove current launcher
-                        if (File.Exists(paths.UnixLauncherPath))
-                        {
-                            if (!File.Exists(paths.UnixBackupLauncherPath))
-                                File.Move(paths.UnixLauncherPath, paths.UnixBackupLauncherPath);
-                            else
-                                this.InteractivelyDelete(paths.UnixLauncherPath);
-                        }
-
-                        // add new launcher
-                        File.Move(paths.UnixSmapiLauncherPath, paths.UnixLauncherPath);
-
-                        // mark file executable
-                        // (MSBuild doesn't keep permission flags for files zipped in a build task.)
-                        // (Note: exclude from Windows build because antivirus apps can flag the process start code as suspicious.)
-#if !SMAPI_FOR_WINDOWS
-                        new Process
-                        {
-                            StartInfo = new ProcessStartInfo
-                            {
-                                FileName = "chmod",
-                                Arguments = $"755 \"{paths.UnixLauncherPath}\"",
-                                CreateNoWindow = true
-                            }
-                        }.Start();
-#endif
-                    }
-
-                    // create mods directory (if needed)
-                    if (!paths.ModsDir.Exists)
-                    {
-                        this.PrintDebug("Creating mods directory...");
-                        paths.ModsDir.Create();
-                    }
-
-                    // add or replace bundled mods
-                    DirectoryInfo bundledModsDir = new DirectoryInfo(Path.Combine(paths.BundlePath, "Mods"));
-                    if (bundledModsDir.Exists && bundledModsDir.EnumerateDirectories().Any())
-                    {
-                        this.PrintDebug("Adding bundled mods...");
-
-                        ModToolkit toolkit = new ModToolkit();
-                        ModFolder[] targetMods = toolkit.GetModFolders(paths.ModsPath).ToArray();
-                        foreach (ModFolder sourceMod in toolkit.GetModFolders(bundledModsDir.FullName))
-                        {
-                            // validate source mod
-                            if (sourceMod.Manifest == null)
-                            {
-                                this.PrintWarning($"   ignored invalid bundled mod {sourceMod.DisplayName}: {sourceMod.ManifestParseError}");
-                                continue;
-                            }
-                            if (!this.BundledModIDs.Contains(sourceMod.Manifest.UniqueID))
-                            {
-                                this.PrintWarning($"   ignored unknown '{sourceMod.DisplayName}' mod in the installer folder. To add mods, put them here instead: {paths.ModsPath}");
-                                continue;
-                            }
-
-                            // find target folder
-                            ModFolder targetMod = targetMods.FirstOrDefault(p => p.Manifest?.UniqueID?.Equals(sourceMod.Manifest.UniqueID, StringComparison.InvariantCultureIgnoreCase) == true);
-                            DirectoryInfo defaultTargetFolder = new DirectoryInfo(Path.Combine(paths.ModsPath, sourceMod.Directory.Name));
-                            DirectoryInfo targetFolder = targetMod?.Directory ?? defaultTargetFolder;
-                            this.PrintDebug(targetFolder.FullName == defaultTargetFolder.FullName
-                                ? $"   adding {sourceMod.Manifest.Name}..."
-                                : $"   adding {sourceMod.Manifest.Name} to {Path.Combine(paths.ModsDir.Name, PathUtilities.GetRelativePath(paths.ModsPath, targetFolder.FullName))}..."
-                            );
-
-                            // remove existing folder
-                            if (targetFolder.Exists)
-                                this.InteractivelyDelete(targetFolder.FullName);
-
-                            // copy files
-                            this.RecursiveCopy(sourceMod.Directory, paths.ModsDir, filter: this.ShouldCopy);
-                        }
-                    }
-
-                    // set SMAPI's color scheme if defined
-                    if (scheme != MonitorColorScheme.AutoDetect)
-                    {
-                        string text = File
-                            .ReadAllText(paths.ApiConfigPath)
-                            .Replace(@"""ColorScheme"": ""AutoDetect""", $@"""ColorScheme"": ""{scheme}""");
-                        File.WriteAllText(paths.ApiConfigPath, text);
-                    }
-
-                    // remove obsolete appdata mods
-                    this.InteractivelyRemoveAppDataMods(paths.ModsDir, bundledModsDir);
-                }
-            }
-            Console.WriteLine();
-            Console.WriteLine();
-
-
-            /*********
-            ** Step 7: final instructions
-            *********/
-            if (platform == Platform.Windows)
-            {
-                if (action == ScriptAction.Install)
-                {
-                    this.PrintSuccess("SMAPI is installed! If you use Steam, set your launch options to enable achievements (see smapi.io/install):");
-                    this.PrintSuccess($"    \"{Path.Combine(paths.GamePath, "StardewModdingAPI.exe")}\" %command%");
-                    Console.WriteLine();
-                    this.PrintSuccess("If you don't use Steam, launch StardewModdingAPI.exe in your game folder to play with mods.");
-                }
-                else
-                    this.PrintSuccess("SMAPI is removed! If you configured Steam to launch SMAPI, don't forget to clear your launch options.");
-            }
-            else
-            {
-                this.PrintSuccess(action == ScriptAction.Install
-                    ? "SMAPI is installed! Launch the game the same way as before to play with mods."
-                    : "SMAPI is removed! Launch the game the same way as before to play without mods."
-                );
-            }
-
-            Console.ReadKey();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the display text for an assembly version.</summary>
-        /// <param name="version">The assembly version.</param>
-        private string GetDisplayVersion(Version version)
-        {
-            string str = $"{version.Major}.{version.Minor}";
-            if (version.Build != 0)
-                str += $".{version.Build}";
-            return str;
-        }
-
-        /// <summary>Get the display text for a color scheme.</summary>
-        /// <param name="scheme">The color scheme.</param>
-        private string GetDisplayText(MonitorColorScheme scheme)
-        {
-            switch (scheme)
-            {
-                case MonitorColorScheme.AutoDetect:
-                    return "auto-detect";
-                case MonitorColorScheme.DarkBackground:
-                    return "light text on dark background";
-                case MonitorColorScheme.LightBackground:
-                    return "dark text on light background";
-                default:
-                    return scheme.ToString();
-            }
-        }
-
-        /// <summary>Get the value of a key in the Windows HKLM registry.</summary>
-        /// <param name="key">The full path of the registry key relative to HKLM.</param>
-        /// <param name="name">The name of the value.</param>
-        private string GetLocalMachineRegistryValue(string key, string name)
-        {
-            RegistryKey localMachine = Environment.Is64BitOperatingSystem ? RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64) : Registry.LocalMachine;
-            RegistryKey openKey = localMachine.OpenSubKey(key);
-            if (openKey == null)
-                return null;
-            using (openKey)
-                return (string)openKey.GetValue(name);
-        }
-
-        /// <summary>Get the value of a key in the Windows HKCU registry.</summary>
-        /// <param name="key">The full path of the registry key relative to HKCU.</param>
-        /// <param name="name">The name of the value.</param>
-        private string GetCurrentUserRegistryValue(string key, string name)
-        {
-            RegistryKey currentuser = Environment.Is64BitOperatingSystem ? RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Registry64) : Registry.CurrentUser;
-            RegistryKey openKey = currentuser.OpenSubKey(key);
-            if (openKey == null)
-                return null;
-            using (openKey)
-                return (string)openKey.GetValue(name);
-        }
-
-        /// <summary>Print a message without formatting.</summary>
-        /// <param name="text">The text to print.</param>
-        private void PrintPlain(string text) => Console.WriteLine(text);
-
-        /// <summary>Print a debug message.</summary>
-        /// <param name="text">The text to print.</param>
-        private void PrintDebug(string text) => this.ConsoleWriter.WriteLine(text, ConsoleLogLevel.Debug);
-
-        /// <summary>Print a debug message.</summary>
-        /// <param name="text">The text to print.</param>
-        private void PrintInfo(string text) => this.ConsoleWriter.WriteLine(text, ConsoleLogLevel.Info);
-
-        /// <summary>Print a warning message.</summary>
-        /// <param name="text">The text to print.</param>
-        private void PrintWarning(string text) => this.ConsoleWriter.WriteLine(text, ConsoleLogLevel.Warn);
-
-        /// <summary>Print a warning message.</summary>
-        /// <param name="text">The text to print.</param>
-        private void PrintError(string text) => this.ConsoleWriter.WriteLine(text, ConsoleLogLevel.Error);
-
-        /// <summary>Print a success message.</summary>
-        /// <param name="text">The text to print.</param>
-        private void PrintSuccess(string text) => this.ConsoleWriter.WriteLine(text, ConsoleLogLevel.Success);
-
-        /// <summary>Get whether the current system has .NET Framework 4.5 or later installed. This only applies on Windows.</summary>
-        /// <param name="platform">The current platform.</param>
-        /// <exception cref="NotSupportedException">The current platform is not Windows.</exception>
-        private bool HasNetFramework45(Platform platform)
-        {
-            switch (platform)
-            {
-                case Platform.Windows:
-                    using (RegistryKey versionKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full"))
-                        return versionKey?.GetValue("Release") != null; // .NET Framework 4.5+
-
-                default:
-                    throw new NotSupportedException("The installed .NET Framework version can only be checked on Windows.");
-            }
-        }
-
-        /// <summary>Get whether the current system has XNA Framework installed. This only applies on Windows.</summary>
-        /// <param name="platform">The current platform.</param>
-        /// <exception cref="NotSupportedException">The current platform is not Windows.</exception>
-        private bool HasXna(Platform platform)
-        {
-            switch (platform)
-            {
-                case Platform.Windows:
-                    using (RegistryKey key = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(@"SOFTWARE\Microsoft\XNA\Framework"))
-                        return key != null; // XNA Framework 4.0+
-
-                default:
-                    throw new NotSupportedException("The installed XNA Framework version can only be checked on Windows.");
-            }
-        }
-
-        /// <summary>Interactively delete a file or folder path, and block until deletion completes.</summary>
-        /// <param name="path">The file or folder path.</param>
-        private void InteractivelyDelete(string path)
-        {
-            while (true)
-            {
-                try
-                {
-                    this.ForceDelete(Directory.Exists(path) ? new DirectoryInfo(path) : (FileSystemInfo)new FileInfo(path));
-                    break;
-                }
-                catch (Exception ex)
-                {
-                    this.PrintError($"Oops! The installer couldn't delete {path}: [{ex.GetType().Name}] {ex.Message}.");
-                    this.PrintError("Try rebooting your computer and then run the installer again. If that doesn't work, try deleting it yourself then press any key to retry.");
-                    Console.ReadKey();
-                }
-            }
-        }
-
-        /// <summary>Recursively copy a directory or file.</summary>
-        /// <param name="source">The file or folder to copy.</param>
-        /// <param name="targetFolder">The folder to copy into.</param>
-        /// <param name="filter">A filter which matches directories and files to copy, or <c>null</c> to match all.</param>
-        private void RecursiveCopy(FileSystemInfo source, DirectoryInfo targetFolder, Func<FileSystemInfo, bool> filter = null)
-        {
-            if (filter != null && !filter(source))
-                return;
-
-            if (!targetFolder.Exists)
-                targetFolder.Create();
-
-            switch (source)
-            {
-                case FileInfo sourceFile:
-                    sourceFile.CopyTo(Path.Combine(targetFolder.FullName, sourceFile.Name));
-                    break;
-
-                case DirectoryInfo sourceDir:
-                    DirectoryInfo targetSubfolder = new DirectoryInfo(Path.Combine(targetFolder.FullName, sourceDir.Name));
-                    foreach (var entry in sourceDir.EnumerateFileSystemInfos())
-                        this.RecursiveCopy(entry, targetSubfolder, filter);
-                    break;
-
-                default:
-                    throw new NotSupportedException($"Unknown filesystem info type '{source.GetType().FullName}'.");
-            }
-        }
-
-        /// <summary>Delete a file or folder regardless of file permissions, and block until deletion completes.</summary>
-        /// <param name="entry">The file or folder to reset.</param>
-        /// <remarks>This method is mirred from <c>FileUtilities.ForceDelete</c> in the toolkit.</remarks>
-        private void ForceDelete(FileSystemInfo entry)
-        {
-            // ignore if already deleted
-            entry.Refresh();
-            if (!entry.Exists)
-                return;
-
-            // delete children
-            if (entry is DirectoryInfo folder)
-            {
-                foreach (FileSystemInfo child in folder.GetFileSystemInfos())
-                    this.ForceDelete(child);
-            }
-
-            // reset permissions & delete
-            entry.Attributes = FileAttributes.Normal;
-            entry.Delete();
-
-            // wait for deletion to finish
-            for (int i = 0; i < 10; i++)
-            {
-                entry.Refresh();
-                if (entry.Exists)
-                    Thread.Sleep(500);
-            }
-
-            // throw exception if deletion didn't happen before timeout
-            entry.Refresh();
-            if (entry.Exists)
-                throw new IOException($"Timed out trying to delete {entry.FullName}");
-        }
-
-        /// <summary>Interactively ask the user to choose a value.</summary>
-        /// <param name="print">A callback which prints a message to the console.</param>
-        /// <param name="message">The message to print.</param>
-        /// <param name="options">The allowed options (not case sensitive).</param>
-        /// <param name="indent">The indentation to prefix to output.</param>
-        private string InteractivelyChoose(string message, string[] options, string indent = "", Action<string> print = null)
-        {
-            print = print ?? this.PrintInfo;
-
-            while (true)
-            {
-                print(indent + message);
-                Console.Write(indent);
-                string input = Console.ReadLine()?.Trim().ToLowerInvariant();
-                if (!options.Contains(input))
-                {
-                    print($"{indent}That's not a valid option.");
-                    continue;
-                }
-                return input;
-            }
-        }
-
-        /// <summary>Interactively locate the game install path to update.</summary>
-        /// <param name="platform">The current platform.</param>
-        /// <param name="specifiedPath">The path specified as a command-line argument (if any), which should override automatic path detection.</param>
-        private DirectoryInfo InteractivelyGetInstallPath(Platform platform, string specifiedPath)
-        {
-            // get executable name
-            string executableFilename = EnvironmentUtility.GetExecutableName(platform);
-
-            // validate specified path
-            if (specifiedPath != null)
-            {
-                var dir = new DirectoryInfo(specifiedPath);
-                if (!dir.Exists)
-                {
-                    this.PrintError($"You specified --game-path \"{specifiedPath}\", but that folder doesn't exist.");
-                    return null;
-                }
-                if (!dir.EnumerateFiles(executableFilename).Any())
-                {
-                    this.PrintError($"You specified --game-path \"{specifiedPath}\", but that folder doesn't contain the Stardew Valley executable.");
-                    return null;
-                }
-                return dir;
-            }
-
-            // get installed paths
-            DirectoryInfo[] defaultPaths =
-                (
-                    from path in this.GetDefaultInstallPaths(platform).Distinct(StringComparer.InvariantCultureIgnoreCase)
-                    let dir = new DirectoryInfo(path)
-                    where dir.Exists && dir.EnumerateFiles(executableFilename).Any()
-                    select dir
-                )
-                .GroupBy(p => p.FullName, StringComparer.InvariantCultureIgnoreCase) // ignore duplicate paths
-                .Select(p => p.First())
-                .ToArray();
-
-            // choose where to install
-            if (defaultPaths.Any())
-            {
-                // only one path
-                if (defaultPaths.Length == 1)
-                    return defaultPaths.First();
-
-                // let user choose path
-                Console.WriteLine();
-                this.PrintInfo("Found multiple copies of the game:");
-                for (int i = 0; i < defaultPaths.Length; i++)
-                    this.PrintInfo($"[{i + 1}] {defaultPaths[i].FullName}");
-                Console.WriteLine();
-
-                string[] validOptions = Enumerable.Range(1, defaultPaths.Length).Select(p => p.ToString(CultureInfo.InvariantCulture)).ToArray();
-                string choice = this.InteractivelyChoose("Where do you want to add/remove SMAPI? Type the number next to your choice, then press enter.", validOptions);
-                int index = int.Parse(choice, CultureInfo.InvariantCulture) - 1;
-                return defaultPaths[index];
-            }
-
-            // ask user
-            this.PrintInfo("Oops, couldn't find the game automatically.");
-            while (true)
-            {
-                // get path from user
-                this.PrintInfo($"Type the file path to the game directory (the one containing '{executableFilename}'), then press enter.");
-                string path = Console.ReadLine()?.Trim();
-                if (string.IsNullOrWhiteSpace(path))
-                {
-                    this.PrintInfo("   You must specify a directory path to continue.");
-                    continue;
-                }
-
-                // normalise path
-                if (platform == Platform.Windows)
-                    path = path.Replace("\"", ""); // in Windows, quotes are used to escape spaces and aren't part of the file path
-                if (platform == Platform.Linux || platform == Platform.Mac)
-                    path = path.Replace("\\ ", " "); // in Linux/Mac, spaces in paths may be escaped if copied from the command line
-                if (path.StartsWith("~/"))
-                {
-                    string home = Environment.GetEnvironmentVariable("HOME") ?? Environment.GetEnvironmentVariable("USERPROFILE");
-                    path = Path.Combine(home, path.Substring(2));
-                }
-
-                // get directory
-                if (File.Exists(path))
-                    path = Path.GetDirectoryName(path);
-                DirectoryInfo directory = new DirectoryInfo(path);
-
-                // validate path
-                if (!directory.Exists)
-                {
-                    this.PrintInfo("   That directory doesn't seem to exist.");
-                    continue;
-                }
-                if (!directory.EnumerateFiles(executableFilename).Any())
-                {
-                    this.PrintInfo("   That directory doesn't contain a Stardew Valley executable.");
-                    continue;
-                }
-
-                // looks OK
-                this.PrintInfo("   OK!");
-                return directory;
-            }
-        }
-
-        /// <summary>Interactively move mods out of the appdata directory.</summary>
-        /// <param name="properModsDir">The directory which should contain all mods.</param>
-        /// <param name="packagedModsDir">The installer directory containing packaged mods.</param>
-        private void InteractivelyRemoveAppDataMods(DirectoryInfo properModsDir, DirectoryInfo packagedModsDir)
-        {
-            // get packaged mods to delete
-            string[] packagedModNames = packagedModsDir.GetDirectories().Select(p => p.Name).ToArray();
-
-            // get path
-            string appDataPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "StardewValley");
-            DirectoryInfo modDir = new DirectoryInfo(Path.Combine(appDataPath, "Mods"));
-
-            // check if migration needed
-            if (!modDir.Exists)
-                return;
-            this.PrintDebug($"Found an obsolete mod path: {modDir.FullName}");
-            this.PrintDebug("   Support for mods here was dropped in SMAPI 1.0 (it was never officially supported).");
-
-            // move mods if no conflicts (else warn)
-            foreach (FileSystemInfo entry in modDir.EnumerateFileSystemInfos().Where(this.ShouldCopy))
-            {
-                // get type
-                bool isDir = entry is DirectoryInfo;
-                if (!isDir && !(entry is FileInfo))
-                    continue; // should never happen
-
-                // delete packaged mods (newer version bundled into SMAPI)
-                if (isDir && packagedModNames.Contains(entry.Name, StringComparer.InvariantCultureIgnoreCase))
-                {
-                    this.PrintDebug($"   Deleting {entry.Name} because it's bundled into SMAPI...");
-                    this.InteractivelyDelete(entry.FullName);
-                    continue;
-                }
-
-                // check paths
-                string newPath = Path.Combine(properModsDir.FullName, entry.Name);
-                if (isDir ? Directory.Exists(newPath) : File.Exists(newPath))
-                {
-                    this.PrintWarning($"   Can't move {entry.Name} because it already exists in your game's mod directory.");
-                    continue;
-                }
-
-                // move into mods
-                this.PrintDebug($"   Moving {entry.Name} into the game's mod directory...");
-                this.Move(entry, newPath);
-            }
-
-            // delete if empty
-            if (modDir.EnumerateFileSystemInfos().Any())
-                this.PrintWarning("   You have files in this folder which couldn't be moved automatically. These will be ignored by SMAPI.");
-            else
-            {
-                this.PrintDebug("   Deleted empty directory.");
-                modDir.Delete(recursive: true);
-            }
-        }
-
-        /// <summary>Move a filesystem entry to a new parent directory.</summary>
-        /// <param name="entry">The filesystem entry to move.</param>
-        /// <param name="newPath">The destination path.</param>
-        /// <remarks>We can't use <see cref="FileInfo.MoveTo"/> or <see cref="DirectoryInfo.MoveTo"/>, because those don't work across partitions.</remarks>
-        private void Move(FileSystemInfo entry, string newPath)
-        {
-            // file
-            if (entry is FileInfo file)
-            {
-                file.CopyTo(newPath);
-                file.Delete();
-            }
-
-            // directory
-            else
-            {
-                Directory.CreateDirectory(newPath);
-
-                DirectoryInfo directory = (DirectoryInfo)entry;
-                foreach (FileSystemInfo child in directory.EnumerateFileSystemInfos().Where(this.ShouldCopy))
-                    this.Move(child, Path.Combine(newPath, child.Name));
-
-                directory.Delete(recursive: true);
-            }
-        }
-
-        /// <summary>Get whether a file or folder should be copied from the installer files.</summary>
-        /// <param name="entry">The file or folder info.</param>
-        private bool ShouldCopy(FileSystemInfo entry)
-        {
-            switch (entry.Name)
-            {
-                case "mcs":
-                    return false; // ignore Mac symlink
-                case "Mods":
-                    return false; // Mods folder handled separately
-                default:
-                    return true;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Installer/Program.cs b/src/SMAPI.Installer/Program.cs
deleted file mode 100644
index 3c4d8593..00000000
--- a/src/SMAPI.Installer/Program.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.IO.Compression;
-using System.Reflection;
-using StardewModdingAPI.Internal;
-using StardewModdingAPI.Toolkit.Utilities;
-
-namespace StardewModdingApi.Installer
-{
-    /// <summary>The entry point for SMAPI's install and uninstall console app.</summary>
-    internal class Program
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The absolute path of the installer folder.</summary>
-        [SuppressMessage("ReSharper", "AssignNullToNotNullAttribute", Justification = "The assembly location is never null in this context.")]
-        private static readonly string InstallerPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
-
-        /// <summary>The absolute path of the folder containing the unzipped installer files.</summary>
-        private static readonly string ExtractedBundlePath = Path.Combine(Path.GetTempPath(), $"SMAPI-installer-{Guid.NewGuid():N}");
-
-        /// <summary>The absolute path for referenced assemblies.</summary>
-        private static readonly string InternalFilesPath = Path.Combine(Program.ExtractedBundlePath, "smapi-internal");
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Run the install or uninstall script.</summary>
-        /// <param name="args">The command line arguments.</param>
-        public static void Main(string[] args)
-        {
-            // find install bundle
-            PlatformID platform = Environment.OSVersion.Platform;
-            FileInfo zipFile = new FileInfo(Path.Combine(Program.InstallerPath, $"{(platform == PlatformID.Win32NT ? "windows" : "unix")}-install.dat"));
-            if (!zipFile.Exists)
-            {
-                Console.WriteLine($"Oops! Some of the installer files are missing; try redownloading the installer. (Missing file: {zipFile.FullName})");
-                Console.ReadLine();
-                return;
-            }
-
-            // unzip bundle into temp folder
-            DirectoryInfo bundleDir = new DirectoryInfo(Program.ExtractedBundlePath);
-            Console.WriteLine("Extracting install files...");
-            ZipFile.ExtractToDirectory(zipFile.FullName, bundleDir.FullName);
-
-            // set up assembly resolution
-            AppDomain.CurrentDomain.AssemblyResolve += Program.CurrentDomain_AssemblyResolve;
-
-            // launch installer
-            var installer = new InteractiveInstaller(bundleDir.FullName);
-            installer.Run(args);
-        }
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Method called when assembly resolution fails, which may return a manually resolved assembly.</summary>
-        /// <param name="sender">The event sender.</param>
-        /// <param name="e">The event arguments.</param>
-        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs e)
-        {
-            try
-            {
-                AssemblyName name = new AssemblyName(e.Name);
-                foreach (FileInfo dll in new DirectoryInfo(Program.InternalFilesPath).EnumerateFiles("*.dll"))
-                {
-                    if (name.Name.Equals(AssemblyName.GetAssemblyName(dll.FullName).Name, StringComparison.InvariantCultureIgnoreCase))
-                        return Assembly.LoadFrom(dll.FullName);
-                }
-                return null;
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Error resolving assembly: {ex}");
-                return null;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Installer/Properties/AssemblyInfo.cs b/src/SMAPI.Installer/Properties/AssemblyInfo.cs
deleted file mode 100644
index 9838e5a0..00000000
--- a/src/SMAPI.Installer/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("SMAPI.Installer")]
-[assembly: AssemblyDescription("The SMAPI installer for players.")]
diff --git a/src/SMAPI.Installer/README.txt b/src/SMAPI.Installer/README.txt
deleted file mode 100644
index 79c90cc0..00000000
--- a/src/SMAPI.Installer/README.txt
+++ /dev/null
@@ -1,44 +0,0 @@
-     ___           ___           ___           ___        ___     
-    /  /\         /__/\         /  /\         /  /\      /  /\    
-   /  /:/_       |  |::\       /  /::\       /  /::\    /  /:/    
-  /  /:/ /\      |  |:|:\     /  /:/\:\     /  /:/\:\  /  /:/     
- /  /:/ /::\   __|__|:|\:\   /  /:/~/::\   /  /:/~/:/ /  /::\ ___ 
-/__/:/ /:/\:\ /__/::::| \:\ /__/:/ /:/\:\ /__/:/ /:/ /__/:/\:\  /\
-\  \:\/:/~/:/ \  \:\~~\__\/ \  \:\/:/__\/ \  \:\/:/  \__\/  \:\/:/
- \  \::/ /:/   \  \:\        \  \::/       \  \::/        \__\::/ 
-  \__\/ /:/     \  \:\        \  \:\        \  \:\        /  /:/  
-    /__/:/       \  \:\        \  \:\        \  \:\      /__/:/   
-    \__\/         \__\/         \__\/         \__\/      \__\/    
-
-
-SMAPI lets you run Stardew Valley with mods. Don't forget to download mods separately.
-
-
-Player's guide
---------------------------------
-See https://stardewvalleywiki.com/Modding:Player_Guide for help installing SMAPI, adding mods, etc.
-
-
-Manual install
---------------------------------
-THIS IS NOT RECOMMENDED FOR MOST PLAYERS. See instructions above instead.
-If you really want to install SMAPI manually, here's how.
-
-1. Unzip "internal/windows-install.dat" (on Windows) or "internal/unix-install.dat" (on Linux/Mac).
-   You can change '.dat' to '.zip', it's just a normal zip file renamed to prevent confusion.
-2. Copy the files from the folder you just unzipped into your game folder. The
-   `StardewModdingAPI.exe` file should be right next to the game's executable.
-3.
-  - Windows only: if you use Steam, see the install guide above to enable achievements and
-    overlay. Otherwise, just run StardewModdingAPI.exe in your game folder to play with mods.
-
-  - Linux/Mac only: rename the "StardewValley" file (no extension) to "StardewValley-original", and
-    "StardewModdingAPI" (no extension) to "StardewValley". Now just launch the game as usual to
-    play with mods.
-
-When installing on Linux or Mac:
-- Make sure Mono is installed (normally the installer checks for you). While it's not required,
-  many mods won't work correctly without it. (Specifically, mods which load PNG images may crash or
-  freeze the game.)
-- To configure the color scheme, edit the `smapi-internal/StardewModdingAPI.config.json` file and
-  see instructions there for the 'ColorScheme' setting.
diff --git a/src/SMAPI.Installer/StardewModdingAPI.Installer.csproj b/src/SMAPI.Installer/StardewModdingAPI.Installer.csproj
deleted file mode 100644
index 083044fb..00000000
--- a/src/SMAPI.Installer/StardewModdingAPI.Installer.csproj
+++ /dev/null
@@ -1,80 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
-    <ProjectGuid>{443DDF81-6AAF-420A-A610-3459F37E5575}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>StardewModdingAPI.Installer</RootNamespace>
-    <AssemblyName>StardewModdingAPI.Installer</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-    <PlatformTarget>x86</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>$(SolutionDir)\..\bin\Debug\Installer</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <PlatformTarget>x86</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>$(SolutionDir)\..\bin\Release\Installer</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.IO.Compression" />
-    <Reference Include="System.IO.Compression.FileSystem" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs">
-      <Link>Properties\GlobalAssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="Enums\ScriptAction.cs" />
-    <Compile Include="Framework\InstallerPaths.cs" />
-    <Compile Include="InteractiveInstaller.cs" />
-    <Compile Include="Program.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="README.txt">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="windows-exe-config.xml">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-    <None Include="windows-install.bat">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="unix-install.sh">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="unix-launcher.sh">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit\StardewModdingAPI.Toolkit.csproj">
-      <Project>{ea5cfd2e-9453-4d29-b80f-8e0ea23f4ac6}</Project>
-      <Name>StardewModdingAPI.Toolkit</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="..\SMAPI.Internal\SMAPI.Internal.projitems" Label="Shared" />
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\..\build\common.targets" />
-  <Import Project="..\..\build\prepare-install-package.targets" />
-</Project>
\ No newline at end of file
diff --git a/src/SMAPI.Installer/unix-install.sh b/src/SMAPI.Installer/unix-install.sh
deleted file mode 100644
index e3a5d8cc..00000000
--- a/src/SMAPI.Installer/unix-install.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-# Run the SMAPI installer through Mono on Linux or Mac.
-
-# Move to script's directory
-cd "`dirname "$0"`"
-
-# get cross-distro version of POSIX command
-COMMAND=""
-if command -v command >/dev/null 2>&1; then
-    COMMAND="command -v"
-elif type type >/dev/null 2>&1; then
-    COMMAND="type"
-fi
-
-# validate Mono & run installer
-if $COMMAND mono >/dev/null 2>&1; then
-    mono internal/unix-install.exe
-else
-   echo "Oops! Looks like Mono isn't installed. Please install Mono from https://mono-project.com, reboot, and run this installer again."
-   read
-fi
diff --git a/src/SMAPI.Installer/unix-launcher.sh b/src/SMAPI.Installer/unix-launcher.sh
deleted file mode 100644
index a98d527d..00000000
--- a/src/SMAPI.Installer/unix-launcher.sh
+++ /dev/null
@@ -1,97 +0,0 @@
-#!/bin/bash
-# MonoKickstart Shell Script
-# Written by Ethan "flibitijibibo" Lee
-# Modified for StardewModdingAPI by Viz and Pathoschild
-
-# Move to script's directory
-cd "`dirname "$0"`"
-
-# Get the system architecture
-UNAME=`uname`
-ARCH=`uname -m`
-
-# MonoKickstart picks the right libfolder, so just execute the right binary.
-if [ "$UNAME" == "Darwin" ]; then
-    # ... Except on OSX.
-    export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:./osx/
-
-    # El Capitan is a total idiot and wipes this variable out, making the
-    # Steam overlay disappear. This sidesteps "System Integrity Protection"
-    # and resets the variable with Valve's own variable (they provided this
-    # fix by the way, thanks Valve!). Note that you will need to update your
-    # launch configuration to the script location, NOT just the app location
-    # (i.e. Kick.app/Contents/MacOS/Kick, not just Kick.app).
-    # -flibit
-    if [ "$STEAM_DYLD_INSERT_LIBRARIES" != "" ] && [ "$DYLD_INSERT_LIBRARIES" == "" ]; then
-        export DYLD_INSERT_LIBRARIES="$STEAM_DYLD_INSERT_LIBRARIES"
-    fi
-
-    # this was here before
-    ln -sf mcs.bin.osx mcs
-
-    # fix "DllNotFoundException: libgdiplus.dylib" errors when loading images in SMAPI
-    if [ -f libgdiplus.dylib ]; then
-        rm libgdiplus.dylib
-    fi
-    if [ -f /Library/Frameworks/Mono.framework/Versions/Current/lib/libgdiplus.dylib ]; then
-        ln -s /Library/Frameworks/Mono.framework/Versions/Current/lib/libgdiplus.dylib libgdiplus.dylib
-    fi
-
-    # launch SMAPI
-    cp StardewValley.bin.osx StardewModdingAPI.bin.osx
-    open -a Terminal ./StardewModdingAPI.bin.osx $@
-else
-    # choose launcher
-    LAUNCHER=""
-    if [ "$ARCH" == "x86_64" ]; then
-        ln -sf mcs.bin.x86_64 mcs
-        cp StardewValley.bin.x86_64 StardewModdingAPI.bin.x86_64
-        LAUNCHER="./StardewModdingAPI.bin.x86_64 $@"
-    else
-        ln -sf mcs.bin.x86 mcs
-        cp StardewValley.bin.x86 StardewModdingAPI.bin.x86
-        LAUNCHER="./StardewModdingAPI.bin.x86 $@"
-    fi
-
-    # get cross-distro version of POSIX command
-    COMMAND=""
-    if command -v command 2>/dev/null; then
-        COMMAND="command -v"
-    elif type type 2>/dev/null; then
-        COMMAND="type"
-    fi
-
-    # open SMAPI in terminal
-    if $COMMAND xterm 2>/dev/null; then
-        xterm -e "$LAUNCHER"
-    elif $COMMAND x-terminal-emulator 2>/dev/null; then
-        # Terminator converts -e to -x when used through x-terminal-emulator for some reason (per
-        # `man terminator`), which causes an "unable to find shell" error. If x-terminal-emulator
-        # is mapped to Terminator, invoke it directly instead.
-        if [[ "$(readlink -e $(which x-terminal-emulator))" == *"/terminator" ]]; then
-            terminator -e "sh -c 'TERM=xterm $LAUNCHER'"
-        else
-            x-terminal-emulator -e "sh -c 'TERM=xterm $LAUNCHER'"
-        fi
-    elif $COMMAND xfce4-terminal 2>/dev/null; then
-        xfce4-terminal -e "sh -c 'TERM=xterm $LAUNCHER'"
-    elif $COMMAND gnome-terminal 2>/dev/null; then
-        gnome-terminal -e "sh -c 'TERM=xterm $LAUNCHER'"
-    elif $COMMAND konsole 2>/dev/null; then
-        konsole -p Environment=TERM=xterm -e "$LAUNCHER"
-    elif $COMMAND terminal 2>/dev/null; then
-        terminal -e "sh -c 'TERM=xterm $LAUNCHER'"
-    elif $COMMAND termite 2>/dev/null; then
-        termite -e "sh -c 'TERM=xterm $LAUNCHER'"
-    else
-        sh -c 'TERM=xterm $LAUNCHER'
-    fi
-
-    # some Linux users get error 127 (command not found) from the above block, even though
-    # `command -v` indicates the command is valid. As a fallback, launch SMAPI without a terminal when
-    # that happens and pass in an argument indicating SMAPI shouldn't try writing to the terminal
-    # (which can be slow if there is none).
-    if [ $? -eq 127 ]; then
-        $LAUNCHER --no-terminal
-    fi
-fi
diff --git a/src/SMAPI.Installer/windows-exe-config.xml b/src/SMAPI.Installer/windows-exe-config.xml
deleted file mode 100644
index 386c7f1a..00000000
--- a/src/SMAPI.Installer/windows-exe-config.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<configuration>
-    <runtime>
-        <loadFromRemoteSources enabled="true"/>
-    </runtime>
-</configuration>
diff --git a/src/SMAPI.Installer/windows-install.bat b/src/SMAPI.Installer/windows-install.bat
deleted file mode 100644
index d02dd4c6..00000000
--- a/src/SMAPI.Installer/windows-install.bat
+++ /dev/null
@@ -1,8 +0,0 @@
-@echo off
-echo %~dp0 | findstr /C:"%TEMP%" 1>nul
-if not errorlevel 1 (
-   echo Oops! It looks like you're running the installer from inside a zip file. Make sure you unzip the download first.
-   pause
-) else (
-   start /WAIT /B internal/windows-install.exe
-)
diff --git a/src/SMAPI.Internal/SMAPI.Internal.projitems b/src/SMAPI.Internal/SMAPI.Internal.projitems
deleted file mode 100644
index 54b12003..00000000
--- a/src/SMAPI.Internal/SMAPI.Internal.projitems
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
-    <HasSharedItems>true</HasSharedItems>
-    <SharedGUID>85208f8d-6fd1-4531-be05-7142490f59fe</SharedGUID>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration">
-    <Import_RootNamespace>SMAPI.Internal</Import_RootNamespace>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)ConsoleWriting\ColorfulConsoleWriter.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)EnvironmentUtility.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ConsoleWriting\LogLevel.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ConsoleWriting\MonitorColorScheme.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Platform.cs" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/SMAPI.Internal/StardewModdingAPI.Internal.shproj b/src/SMAPI.Internal/StardewModdingAPI.Internal.shproj
deleted file mode 100644
index a098828a..00000000
--- a/src/SMAPI.Internal/StardewModdingAPI.Internal.shproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>85208f8d-6fd1-4531-be05-7142490f59fe</ProjectGuid>
-    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
-  </PropertyGroup>
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
-  <PropertyGroup />
-  <Import Project="SMAPI.Internal.projitems" Label="Shared" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
-</Project>
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticResult.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticResult.cs
deleted file mode 100644
index 896c2cb8..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticResult.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-// <generated />
-using Microsoft.CodeAnalysis;
-using System;
-
-namespace SMAPI.ModBuildConfig.Analyzer.Tests.Framework
-{
-    /// <summary>
-    /// Location where the diagnostic appears, as determined by path, line number, and column number.
-    /// </summary>
-    public struct DiagnosticResultLocation
-    {
-        public DiagnosticResultLocation(string path, int line, int column)
-        {
-            if (line < -1)
-            {
-                throw new ArgumentOutOfRangeException(nameof(line), "line must be >= -1");
-            }
-
-            if (column < -1)
-            {
-                throw new ArgumentOutOfRangeException(nameof(column), "column must be >= -1");
-            }
-
-            this.Path = path;
-            this.Line = line;
-            this.Column = column;
-        }
-
-        public string Path { get; }
-        public int Line { get; }
-        public int Column { get; }
-    }
-
-    /// <summary>
-    /// Struct that stores information about a Diagnostic appearing in a source
-    /// </summary>
-    public struct DiagnosticResult
-    {
-        private DiagnosticResultLocation[] locations;
-
-        public DiagnosticResultLocation[] Locations
-        {
-            get
-            {
-                if (this.locations == null)
-                {
-                    this.locations = new DiagnosticResultLocation[] { };
-                }
-                return this.locations;
-            }
-
-            set
-            {
-                this.locations = value;
-            }
-        }
-
-        public DiagnosticSeverity Severity { get; set; }
-
-        public string Id { get; set; }
-
-        public string Message { get; set; }
-
-        public string Path
-        {
-            get
-            {
-                return this.Locations.Length > 0 ? this.Locations[0].Path : "";
-            }
-        }
-
-        public int Line
-        {
-            get
-            {
-                return this.Locations.Length > 0 ? this.Locations[0].Line : -1;
-            }
-        }
-
-        public int Column
-        {
-            get
-            {
-                return this.Locations.Length > 0 ? this.Locations[0].Column : -1;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticVerifier.Helper.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticVerifier.Helper.cs
deleted file mode 100644
index 0247288e..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticVerifier.Helper.cs
+++ /dev/null
@@ -1,173 +0,0 @@
-// <generated />
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Text;
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-
-namespace SMAPI.ModBuildConfig.Analyzer.Tests.Framework
-{
-    /// <summary>
-    /// Class for turning strings into documents and getting the diagnostics on them
-    /// All methods are static
-    /// </summary>
-    public abstract partial class DiagnosticVerifier
-    {
-        private static readonly MetadataReference CorlibReference = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
-        private static readonly MetadataReference SystemCoreReference = MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location);
-        private static readonly MetadataReference CSharpSymbolsReference = MetadataReference.CreateFromFile(typeof(CSharpCompilation).Assembly.Location);
-        private static readonly MetadataReference CodeAnalysisReference = MetadataReference.CreateFromFile(typeof(Compilation).Assembly.Location);
-        private static readonly MetadataReference SelfReference = MetadataReference.CreateFromFile(typeof(DiagnosticVerifier).Assembly.Location);
-
-        internal static string DefaultFilePathPrefix = "Test";
-        internal static string CSharpDefaultFileExt = "cs";
-        internal static string VisualBasicDefaultExt = "vb";
-        internal static string TestProjectName = "TestProject";
-
-        #region  Get Diagnostics
-
-        /// <summary>
-        /// Given classes in the form of strings, their language, and an IDiagnosticAnalyzer to apply to it, return the diagnostics found in the string after converting it to a document.
-        /// </summary>
-        /// <param name="sources">Classes in the form of strings</param>
-        /// <param name="language">The language the source classes are in</param>
-        /// <param name="analyzer">The analyzer to be run on the sources</param>
-        /// <returns>An IEnumerable of Diagnostics that surfaced in the source code, sorted by Location</returns>
-        private static Diagnostic[] GetSortedDiagnostics(string[] sources, string language, DiagnosticAnalyzer analyzer)
-        {
-            return GetSortedDiagnosticsFromDocuments(analyzer, GetDocuments(sources, language));
-        }
-
-        /// <summary>
-        /// Given an analyzer and a document to apply it to, run the analyzer and gather an array of diagnostics found in it.
-        /// The returned diagnostics are then ordered by location in the source document.
-        /// </summary>
-        /// <param name="analyzer">The analyzer to run on the documents</param>
-        /// <param name="documents">The Documents that the analyzer will be run on</param>
-        /// <returns>An IEnumerable of Diagnostics that surfaced in the source code, sorted by Location</returns>
-        protected static Diagnostic[] GetSortedDiagnosticsFromDocuments(DiagnosticAnalyzer analyzer, Document[] documents)
-        {
-            var projects = new HashSet<Project>();
-            foreach (var document in documents)
-            {
-                projects.Add(document.Project);
-            }
-
-            var diagnostics = new List<Diagnostic>();
-            foreach (var project in projects)
-            {
-                var compilationWithAnalyzers = project.GetCompilationAsync().Result.WithAnalyzers(ImmutableArray.Create(analyzer));
-                var diags = compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().Result;
-                foreach (var diag in diags)
-                {
-                    if (diag.Location == Location.None || diag.Location.IsInMetadata)
-                    {
-                        diagnostics.Add(diag);
-                    }
-                    else
-                    {
-                        for (int i = 0; i < documents.Length; i++)
-                        {
-                            var document = documents[i];
-                            var tree = document.GetSyntaxTreeAsync().Result;
-                            if (tree == diag.Location.SourceTree)
-                            {
-                                diagnostics.Add(diag);
-                            }
-                        }
-                    }
-                }
-            }
-
-            var results = SortDiagnostics(diagnostics);
-            diagnostics.Clear();
-            return results;
-        }
-
-        /// <summary>
-        /// Sort diagnostics by location in source document
-        /// </summary>
-        /// <param name="diagnostics">The list of Diagnostics to be sorted</param>
-        /// <returns>An IEnumerable containing the Diagnostics in order of Location</returns>
-        private static Diagnostic[] SortDiagnostics(IEnumerable<Diagnostic> diagnostics)
-        {
-            return diagnostics.OrderBy(d => d.Location.SourceSpan.Start).ToArray();
-        }
-
-        #endregion
-
-        #region Set up compilation and documents
-        /// <summary>
-        /// Given an array of strings as sources and a language, turn them into a project and return the documents and spans of it.
-        /// </summary>
-        /// <param name="sources">Classes in the form of strings</param>
-        /// <param name="language">The language the source code is in</param>
-        /// <returns>A Tuple containing the Documents produced from the sources and their TextSpans if relevant</returns>
-        private static Document[] GetDocuments(string[] sources, string language)
-        {
-            if (language != LanguageNames.CSharp && language != LanguageNames.VisualBasic)
-            {
-                throw new ArgumentException("Unsupported Language");
-            }
-
-            var project = CreateProject(sources, language);
-            var documents = project.Documents.ToArray();
-
-            if (sources.Length != documents.Length)
-            {
-                throw new InvalidOperationException("Amount of sources did not match amount of Documents created");
-            }
-
-            return documents;
-        }
-
-        /// <summary>
-        /// Create a Document from a string through creating a project that contains it.
-        /// </summary>
-        /// <param name="source">Classes in the form of a string</param>
-        /// <param name="language">The language the source code is in</param>
-        /// <returns>A Document created from the source string</returns>
-        protected static Document CreateDocument(string source, string language = LanguageNames.CSharp)
-        {
-            return CreateProject(new[] { source }, language).Documents.First();
-        }
-
-        /// <summary>
-        /// Create a project using the inputted strings as sources.
-        /// </summary>
-        /// <param name="sources">Classes in the form of strings</param>
-        /// <param name="language">The language the source code is in</param>
-        /// <returns>A Project created out of the Documents created from the source strings</returns>
-        private static Project CreateProject(string[] sources, string language = LanguageNames.CSharp)
-        {
-            string fileNamePrefix = DefaultFilePathPrefix;
-            string fileExt = language == LanguageNames.CSharp ? CSharpDefaultFileExt : VisualBasicDefaultExt;
-
-            var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
-
-            var solution = new AdhocWorkspace()
-                .CurrentSolution
-                .AddProject(projectId, TestProjectName, TestProjectName, language)
-                .AddMetadataReference(projectId, DiagnosticVerifier.SelfReference)
-                .AddMetadataReference(projectId, CorlibReference)
-                .AddMetadataReference(projectId, SystemCoreReference)
-                .AddMetadataReference(projectId, CSharpSymbolsReference)
-                .AddMetadataReference(projectId, CodeAnalysisReference);
-
-            int count = 0;
-            foreach (var source in sources)
-            {
-                var newFileName = fileNamePrefix + count + "." + fileExt;
-                var documentId = DocumentId.CreateNewId(projectId, debugName: newFileName);
-                solution = solution.AddDocument(documentId, newFileName, SourceText.From(source));
-                count++;
-            }
-            return solution.GetProject(projectId);
-        }
-        #endregion
-    }
-}
-
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticVerifier.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticVerifier.cs
deleted file mode 100644
index edaaabd4..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Framework/DiagnosticVerifier.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// <generated />
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-using NUnit.Framework;
-
-namespace SMAPI.ModBuildConfig.Analyzer.Tests.Framework
-{
-    /// <summary>
-    /// Superclass of all Unit Tests for DiagnosticAnalyzers
-    /// </summary>
-    public abstract partial class DiagnosticVerifier
-    {
-        #region To be implemented by Test classes
-        /// <summary>
-        /// Get the CSharp analyzer being tested - to be implemented in non-abstract class
-        /// </summary>
-        protected virtual DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
-        {
-            return null;
-        }
-
-        /// <summary>
-        /// Get the Visual Basic analyzer being tested (C#) - to be implemented in non-abstract class
-        /// </summary>
-        protected virtual DiagnosticAnalyzer GetBasicDiagnosticAnalyzer()
-        {
-            return null;
-        }
-        #endregion
-
-        #region Verifier wrappers
-
-        /// <summary>
-        /// Called to test a C# DiagnosticAnalyzer when applied on the single inputted string as a source
-        /// Note: input a DiagnosticResult for each Diagnostic expected
-        /// </summary>
-        /// <param name="source">A class in the form of a string to run the analyzer on</param>
-        /// <param name="expected"> DiagnosticResults that should appear after the analyzer is run on the source</param>
-        protected void VerifyCSharpDiagnostic(string source, params DiagnosticResult[] expected)
-        {
-            VerifyDiagnostics(new[] { source }, LanguageNames.CSharp, GetCSharpDiagnosticAnalyzer(), expected);
-        }
-
-        /// <summary>
-        /// Called to test a C# DiagnosticAnalyzer when applied on the inputted strings as a source
-        /// Note: input a DiagnosticResult for each Diagnostic expected
-        /// </summary>
-        /// <param name="sources">An array of strings to create source documents from to run the analyzers on</param>
-        /// <param name="expected">DiagnosticResults that should appear after the analyzer is run on the sources</param>
-        protected void VerifyCSharpDiagnostic(string[] sources, params DiagnosticResult[] expected)
-        {
-            VerifyDiagnostics(sources, LanguageNames.CSharp, GetCSharpDiagnosticAnalyzer(), expected);
-        }
-
-        /// <summary>
-        /// General method that gets a collection of actual diagnostics found in the source after the analyzer is run, 
-        /// then verifies each of them.
-        /// </summary>
-        /// <param name="sources">An array of strings to create source documents from to run the analyzers on</param>
-        /// <param name="language">The language of the classes represented by the source strings</param>
-        /// <param name="analyzer">The analyzer to be run on the source code</param>
-        /// <param name="expected">DiagnosticResults that should appear after the analyzer is run on the sources</param>
-        private void VerifyDiagnostics(string[] sources, string language, DiagnosticAnalyzer analyzer, params DiagnosticResult[] expected)
-        {
-            var diagnostics = GetSortedDiagnostics(sources, language, analyzer);
-            VerifyDiagnosticResults(diagnostics, analyzer, expected);
-        }
-
-        #endregion
-
-        #region Actual comparisons and verifications
-        /// <summary>
-        /// Checks each of the actual Diagnostics found and compares them with the corresponding DiagnosticResult in the array of expected results.
-        /// Diagnostics are considered equal only if the DiagnosticResultLocation, Id, Severity, and Message of the DiagnosticResult match the actual diagnostic.
-        /// </summary>
-        /// <param name="actualResults">The Diagnostics found by the compiler after running the analyzer on the source code</param>
-        /// <param name="analyzer">The analyzer that was being run on the sources</param>
-        /// <param name="expectedResults">Diagnostic Results that should have appeared in the code</param>
-        private static void VerifyDiagnosticResults(IEnumerable<Diagnostic> actualResults, DiagnosticAnalyzer analyzer, params DiagnosticResult[] expectedResults)
-        {
-            int expectedCount = expectedResults.Count();
-            int actualCount = actualResults.Count();
-
-            if (expectedCount != actualCount)
-            {
-                string diagnosticsOutput = actualResults.Any() ? FormatDiagnostics(analyzer, actualResults.ToArray()) : "    NONE.";
-
-                Assert.IsTrue(false,
-                    string.Format("Mismatch between number of diagnostics returned, expected \"{0}\" actual \"{1}\"\r\n\r\nDiagnostics:\r\n{2}\r\n", expectedCount, actualCount, diagnosticsOutput));
-            }
-
-            for (int i = 0; i < expectedResults.Length; i++)
-            {
-                var actual = actualResults.ElementAt(i);
-                var expected = expectedResults[i];
-
-                if (expected.Line == -1 && expected.Column == -1)
-                {
-                    if (actual.Location != Location.None)
-                    {
-                        Assert.IsTrue(false,
-                            string.Format("Expected:\nA project diagnostic with No location\nActual:\n{0}",
-                            FormatDiagnostics(analyzer, actual)));
-                    }
-                }
-                else
-                {
-                    VerifyDiagnosticLocation(analyzer, actual, actual.Location, expected.Locations.First());
-                    var additionalLocations = actual.AdditionalLocations.ToArray();
-
-                    if (additionalLocations.Length != expected.Locations.Length - 1)
-                    {
-                        Assert.IsTrue(false,
-                            string.Format("Expected {0} additional locations but got {1} for Diagnostic:\r\n    {2}\r\n",
-                                expected.Locations.Length - 1, additionalLocations.Length,
-                                FormatDiagnostics(analyzer, actual)));
-                    }
-
-                    for (int j = 0; j < additionalLocations.Length; ++j)
-                    {
-                        VerifyDiagnosticLocation(analyzer, actual, additionalLocations[j], expected.Locations[j + 1]);
-                    }
-                }
-
-                if (actual.Id != expected.Id)
-                {
-                    Assert.IsTrue(false,
-                        string.Format("Expected diagnostic id to be \"{0}\" was \"{1}\"\r\n\r\nDiagnostic:\r\n    {2}\r\n",
-                            expected.Id, actual.Id, FormatDiagnostics(analyzer, actual)));
-                }
-
-                if (actual.Severity != expected.Severity)
-                {
-                    Assert.IsTrue(false,
-                        string.Format("Expected diagnostic severity to be \"{0}\" was \"{1}\"\r\n\r\nDiagnostic:\r\n    {2}\r\n",
-                            expected.Severity, actual.Severity, FormatDiagnostics(analyzer, actual)));
-                }
-
-                if (actual.GetMessage() != expected.Message)
-                {
-                    Assert.IsTrue(false,
-                        string.Format("Expected diagnostic message to be \"{0}\" was \"{1}\"\r\n\r\nDiagnostic:\r\n    {2}\r\n",
-                            expected.Message, actual.GetMessage(), FormatDiagnostics(analyzer, actual)));
-                }
-            }
-        }
-
-        /// <summary>
-        /// Helper method to VerifyDiagnosticResult that checks the location of a diagnostic and compares it with the location in the expected DiagnosticResult.
-        /// </summary>
-        /// <param name="analyzer">The analyzer that was being run on the sources</param>
-        /// <param name="diagnostic">The diagnostic that was found in the code</param>
-        /// <param name="actual">The Location of the Diagnostic found in the code</param>
-        /// <param name="expected">The DiagnosticResultLocation that should have been found</param>
-        private static void VerifyDiagnosticLocation(DiagnosticAnalyzer analyzer, Diagnostic diagnostic, Location actual, DiagnosticResultLocation expected)
-        {
-            var actualSpan = actual.GetLineSpan();
-
-            Assert.IsTrue(actualSpan.Path == expected.Path || (actualSpan.Path != null && actualSpan.Path.Contains("Test0.") && expected.Path.Contains("Test.")),
-                string.Format("Expected diagnostic to be in file \"{0}\" was actually in file \"{1}\"\r\n\r\nDiagnostic:\r\n    {2}\r\n",
-                    expected.Path, actualSpan.Path, FormatDiagnostics(analyzer, diagnostic)));
-
-            var actualLinePosition = actualSpan.StartLinePosition;
-
-            // Only check line position if there is an actual line in the real diagnostic
-            if (actualLinePosition.Line > 0)
-            {
-                if (actualLinePosition.Line + 1 != expected.Line)
-                {
-                    Assert.IsTrue(false,
-                        string.Format("Expected diagnostic to be on line \"{0}\" was actually on line \"{1}\"\r\n\r\nDiagnostic:\r\n    {2}\r\n",
-                            expected.Line, actualLinePosition.Line + 1, FormatDiagnostics(analyzer, diagnostic)));
-                }
-            }
-
-            // Only check column position if there is an actual column position in the real diagnostic
-            if (actualLinePosition.Character > 0)
-            {
-                if (actualLinePosition.Character + 1 != expected.Column)
-                {
-                    Assert.IsTrue(false,
-                        string.Format("Expected diagnostic to start at column \"{0}\" was actually at column \"{1}\"\r\n\r\nDiagnostic:\r\n    {2}\r\n",
-                            expected.Column, actualLinePosition.Character + 1, FormatDiagnostics(analyzer, diagnostic)));
-                }
-            }
-        }
-        #endregion
-
-        #region Formatting Diagnostics
-        /// <summary>
-        /// Helper method to format a Diagnostic into an easily readable string
-        /// </summary>
-        /// <param name="analyzer">The analyzer that this verifier tests</param>
-        /// <param name="diagnostics">The Diagnostics to be formatted</param>
-        /// <returns>The Diagnostics formatted as a string</returns>
-        private static string FormatDiagnostics(DiagnosticAnalyzer analyzer, params Diagnostic[] diagnostics)
-        {
-            var builder = new StringBuilder();
-            for (int i = 0; i < diagnostics.Length; ++i)
-            {
-                builder.AppendLine("// " + diagnostics[i].ToString());
-
-                var analyzerType = analyzer.GetType();
-                var rules = analyzer.SupportedDiagnostics;
-
-                foreach (var rule in rules)
-                {
-                    if (rule != null && rule.Id == diagnostics[i].Id)
-                    {
-                        var location = diagnostics[i].Location;
-                        if (location == Location.None)
-                        {
-                            builder.AppendFormat("GetGlobalResult({0}.{1})", analyzerType.Name, rule.Id);
-                        }
-                        else
-                        {
-                            Assert.IsTrue(location.IsInSource,
-                                $"Test base does not currently handle diagnostics in metadata locations. Diagnostic in metadata: {diagnostics[i]}\r\n");
-
-                            string resultMethodName = diagnostics[i].Location.SourceTree.FilePath.EndsWith(".cs") ? "GetCSharpResultAt" : "GetBasicResultAt";
-                            var linePosition = diagnostics[i].Location.GetLineSpan().StartLinePosition;
-
-                            builder.AppendFormat("{0}({1}, {2}, {3}.{4})",
-                                resultMethodName,
-                                linePosition.Line + 1,
-                                linePosition.Character + 1,
-                                analyzerType.Name,
-                                rule.Id);
-                        }
-
-                        if (i != diagnostics.Length - 1)
-                        {
-                            builder.Append(',');
-                        }
-
-                        builder.AppendLine();
-                        break;
-                    }
-                }
-            }
-            return builder.ToString();
-        }
-        #endregion
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetCollection.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetCollection.cs
deleted file mode 100644
index d160610e..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetCollection.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// ReSharper disable CheckNamespace -- matches Stardew Valley's code
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-
-namespace Netcode
-{
-    /// <summary>A simplified version of Stardew Valley's <c>Netcode.NetCollection</c> for unit testing.</summary>
-    public class NetCollection<T> : Collection<T>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable { }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetFieldBase.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetFieldBase.cs
deleted file mode 100644
index 1684229a..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetFieldBase.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// ReSharper disable CheckNamespace -- matches Stardew Valley's code
-namespace Netcode
-{
-    /// <summary>A simplified version of Stardew Valley's <c>Netcode.NetFieldBase</c> for unit testing.</summary>
-    /// <typeparam name="T">The type of the synchronised value.</typeparam>
-    /// <typeparam name="TSelf">The type of the current instance.</typeparam>
-    public class NetFieldBase<T, TSelf> where TSelf : NetFieldBase<T, TSelf>
-    {
-        /// <summary>The synchronised value.</summary>
-        public T Value { get; set; }
-
-        /// <summary>Implicitly convert a net field to the its type.</summary>
-        /// <param name="field">The field to convert.</param>
-        public static implicit operator T(NetFieldBase<T, TSelf> field) => field.Value;
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetInt.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetInt.cs
deleted file mode 100644
index b3abc467..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetInt.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-// ReSharper disable CheckNamespace -- matches Stardew Valley's code
-namespace Netcode
-{
-    /// <summary>A simplified version of Stardew Valley's <c>Netcode.NetInt</c> for unit testing.</summary>
-    public class NetInt : NetFieldBase<int, NetInt> { }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetList.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetList.cs
deleted file mode 100644
index 1699f71c..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetList.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-// ReSharper disable CheckNamespace -- matches Stardew Valley's code
-using System.Collections;
-using System.Collections.Generic;
-
-namespace Netcode
-{
-    /// <summary>A simplified version of Stardew Valley's <c>Netcode.NetObjectList</c> for unit testing.</summary>
-    public class NetList<T> : List<T>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable { }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetObjectList.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetObjectList.cs
deleted file mode 100644
index 7814e7d6..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetObjectList.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-// ReSharper disable CheckNamespace -- matches Stardew Valley's code
-namespace Netcode
-{
-    /// <summary>A simplified version of Stardew Valley's <c>Netcode.NetObjectList</c> for unit testing.</summary>
-    public class NetObjectList<T> : NetList<T> { }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetRef.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetRef.cs
deleted file mode 100644
index be2459cc..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/Netcode/NetRef.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-// ReSharper disable CheckNamespace -- matches Stardew Valley's code
-namespace Netcode
-{
-    /// <summary>A simplified version of Stardew Valley's <c>Netcode.NetRef</c> for unit testing.</summary>
-    public class NetRef<T> : NetFieldBase<T, NetRef<T>> where T : class { }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Farmer.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Farmer.cs
deleted file mode 100644
index 13fab069..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Farmer.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// ReSharper disable CheckNamespace, InconsistentNaming -- matches Stardew Valley's code
-#pragma warning disable 649 // (never assigned) -- only used to test type conversions
-using System.Collections.Generic;
-
-namespace StardewValley
-{
-    /// <summary>A simplified version of Stardew Valley's <c>StardewValley.Farmer</c> class for unit testing.</summary>
-    internal class Farmer
-    {
-        /// <summary>A sample field which should be replaced with a different property.</summary>
-        public readonly IDictionary<string, int[]> friendships;
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Item.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Item.cs
deleted file mode 100644
index 1b6317c1..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Item.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// ReSharper disable CheckNamespace, InconsistentNaming -- matches Stardew Valley's code
-using Netcode;
-
-namespace StardewValley
-{
-    /// <summary>A simplified version of Stardew Valley's <c>StardewValley.Item</c> class for unit testing.</summary>
-    public class Item
-    {
-        /// <summary>A net int field with an equivalent non-net <c>Category</c> property.</summary>
-        public readonly NetInt category = new NetInt { Value = 42 };
-
-        /// <summary>A generic net int field with no equivalent non-net property.</summary>
-        public readonly NetInt netIntField = new NetInt { Value = 42 };
-
-        /// <summary>A generic net ref field with no equivalent non-net property.</summary>
-        public readonly NetRef<object> netRefField = new NetRef<object>();
-
-        /// <summary>A generic net int property with no equivalent non-net property.</summary>
-        public NetInt netIntProperty = new NetInt { Value = 42 };
-
-        /// <summary>A generic net ref property with no equivalent non-net property.</summary>
-        public NetRef<object> netRefProperty { get; } = new NetRef<object>();
-
-        /// <summary>A sample net list.</summary>
-        public readonly NetList<int> netList = new NetList<int>();
-
-        /// <summary>A sample net object list.</summary>
-        public readonly NetObjectList<int> netObjectList = new NetObjectList<int>();
-
-        /// <summary>A sample net collection.</summary>
-        public readonly NetCollection<int> netCollection = new NetCollection<int>();
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Object.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Object.cs
deleted file mode 100644
index 3dd66a6d..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/Mock/StardewValley/Object.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// ReSharper disable CheckNamespace, InconsistentNaming -- matches Stardew Valley's code
-using Netcode;
-
-namespace StardewValley
-{
-    /// <summary>A simplified version of Stardew Valley's <c>StardewValley.Object</c> class for unit testing.</summary>
-    public class Object : Item
-    {
-        /// <summary>A net int field with an equivalent non-net property.</summary>
-        public NetInt type = new NetInt { Value = 42 };
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/NetFieldAnalyzerTests.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/NetFieldAnalyzerTests.cs
deleted file mode 100644
index 85a77d15..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/NetFieldAnalyzerTests.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-using NUnit.Framework;
-using SMAPI.ModBuildConfig.Analyzer.Tests.Framework;
-using StardewModdingAPI.ModBuildConfig.Analyzer;
-
-namespace SMAPI.ModBuildConfig.Analyzer.Tests
-{
-    /// <summary>Unit tests for <see cref="NetFieldAnalyzer"/>.</summary>
-    [TestFixture]
-    public class NetFieldAnalyzerTests : DiagnosticVerifier
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Sample C# mod code, with a {{test-code}} placeholder for the code in the Entry method to test.</summary>
-        const string SampleProgram = @"
-            using System;
-            using StardewValley;
-            using Netcode;
-            using SObject = StardewValley.Object;
-
-            namespace SampleMod
-            {
-                class ModEntry
-                {
-                    public void Entry()
-                    {
-                        {{test-code}}
-                    }
-                }
-            }
-        ";
-
-        /// <summary>The line number where the unit tested code is injected into <see cref="SampleProgram"/>.</summary>
-        private const int SampleCodeLine = 13;
-
-        /// <summary>The column number where the unit tested code is injected into <see cref="SampleProgram"/>.</summary>
-        private const int SampleCodeColumn = 25;
-
-
-        /*********
-        ** Unit tests
-        *********/
-        /// <summary>Test that no diagnostics are raised for an empty code block.</summary>
-        [TestCase]
-        public void EmptyCode_HasNoDiagnostics()
-        {
-            // arrange
-            string test = @"";
-
-            // assert
-            this.VerifyCSharpDiagnostic(test);
-        }
-
-        /// <summary>Test that the expected diagnostic message is raised for implicit net field comparisons.</summary>
-        /// <param name="codeText">The code line to test.</param>
-        /// <param name="column">The column within the code line where the diagnostic message should be reported.</param>
-        /// <param name="expression">The expression which should be reported.</param>
-        /// <param name="fromType">The source type name which should be reported.</param>
-        /// <param name="toType">The target type name which should be reported.</param>
-        [TestCase("Item item = null; if (item.netIntField < 42);", 22, "item.netIntField", "NetInt", "int")] // ↓ implicit conversion
-        [TestCase("Item item = null; if (item.netIntField <= 42);", 22, "item.netIntField", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntField > 42);", 22, "item.netIntField", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntField >= 42);", 22, "item.netIntField", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntField == 42);", 22, "item.netIntField", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntField != 42);", 22, "item.netIntField", "NetInt", "int")]
-        [TestCase("Item item = null; if (item?.netIntField != 42);", 22, "item?.netIntField", "NetInt", "int")]
-        [TestCase("Item item = null; if (item?.netIntField != null);", 22, "item?.netIntField", "NetInt", "object")]
-        [TestCase("Item item = null; if (item.netIntProperty < 42);", 22, "item.netIntProperty", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntProperty <= 42);", 22, "item.netIntProperty", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntProperty > 42);", 22, "item.netIntProperty", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntProperty >= 42);", 22, "item.netIntProperty", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntProperty == 42);", 22, "item.netIntProperty", "NetInt", "int")]
-        [TestCase("Item item = null; if (item.netIntProperty != 42);", 22, "item.netIntProperty", "NetInt", "int")]
-        [TestCase("Item item = null; if (item?.netIntProperty != 42);", 22, "item?.netIntProperty", "NetInt", "int")]
-        [TestCase("Item item = null; if (item?.netIntProperty != null);", 22, "item?.netIntProperty", "NetInt", "object")]
-        [TestCase("Item item = null; if (item.netRefField == null);", 22, "item.netRefField", "NetRef", "object")]
-        [TestCase("Item item = null; if (item.netRefField != null);", 22, "item.netRefField", "NetRef", "object")]
-        [TestCase("Item item = null; if (item.netRefProperty == null);", 22, "item.netRefProperty", "NetRef", "object")]
-        [TestCase("Item item = null; if (item.netRefProperty != null);", 22, "item.netRefProperty", "NetRef", "object")]
-        [TestCase("SObject obj = null; if (obj.netIntField != 42);", 24, "obj.netIntField", "NetInt", "int")] // ↓ implicit conversion for parent field
-        [TestCase("SObject obj = null; if (obj.netIntProperty != 42);", 24, "obj.netIntProperty", "NetInt", "int")]
-        [TestCase("SObject obj = null; if (obj.netRefField == null);", 24, "obj.netRefField", "NetRef", "object")]
-        [TestCase("SObject obj = null; if (obj.netRefField != null);", 24, "obj.netRefField", "NetRef", "object")]
-        [TestCase("SObject obj = null; if (obj.netRefProperty == null);", 24, "obj.netRefProperty", "NetRef", "object")]
-        [TestCase("SObject obj = null; if (obj.netRefProperty != null);", 24, "obj.netRefProperty", "NetRef", "object")]
-        [TestCase("Item item = new Item(); object list = item.netList;", 38, "item.netList", "NetList", "object")] // ↓ NetList field converted to a non-interface type
-        [TestCase("Item item = new Item(); object list = item.netCollection;", 38, "item.netCollection", "NetCollection", "object")]
-        [TestCase("Item item = new Item(); int x = (int)item.netIntField;", 32, "item.netIntField", "NetInt", "int")] // ↓ explicit conversion to invalid type
-        [TestCase("Item item = new Item(); int x = item.netRefField as object;", 32, "item.netRefField", "NetRef", "object")]
-        public void AvoidImplicitNetFieldComparisons_RaisesDiagnostic(string codeText, int column, string expression, string fromType, string toType)
-        {
-            // arrange
-            string code = NetFieldAnalyzerTests.SampleProgram.Replace("{{test-code}}", codeText);
-            DiagnosticResult expected = new DiagnosticResult
-            {
-                Id = "AvoidImplicitNetFieldCast",
-                Message = $"This implicitly converts '{expression}' from {fromType} to {toType}, but {fromType} has unintuitive implicit conversion rules. Consider comparing against the actual value instead to avoid bugs. See https://smapi.io/buildmsg/avoid-implicit-net-field-cast for details.",
-                Severity = DiagnosticSeverity.Warning,
-                Locations = new[] { new DiagnosticResultLocation("Test0.cs", NetFieldAnalyzerTests.SampleCodeLine, NetFieldAnalyzerTests.SampleCodeColumn + column) }
-            };
-
-            // assert
-            this.VerifyCSharpDiagnostic(code, expected);
-        }
-
-        /// <summary>Test that the net field analyzer doesn't raise any warnings for safe member access.</summary>
-        /// <param name="codeText">The code line to test.</param>
-        [TestCase("Item item = new Item(); System.Collections.IEnumerable list = farmer.eventsSeen;")]
-        [TestCase("Item item = new Item(); System.Collections.Generic.IEnumerable<int> list = farmer.netList;")]
-        [TestCase("Item item = new Item(); System.Collections.Generic.IList<int> list = farmer.netList;")]
-        [TestCase("Item item = new Item(); System.Collections.Generic.ICollection<int> list = farmer.netCollection;")]
-        [TestCase("Item item = new Item(); System.Collections.Generic.IList<int> list = farmer.netObjectList;")] // subclass of NetList
-        public void AvoidImplicitNetFieldComparisons_AllowsSafeAccess(string codeText)
-        {
-            // arrange
-            string code = NetFieldAnalyzerTests.SampleProgram.Replace("{{test-code}}", codeText);
-
-            // assert
-            this.VerifyCSharpDiagnostic(code);
-        }
-
-        /// <summary>Test that the expected diagnostic message is raised for avoidable net field references.</summary>
-        /// <param name="codeText">The code line to test.</param>
-        /// <param name="column">The column within the code line where the diagnostic message should be reported.</param>
-        /// <param name="expression">The expression which should be reported.</param>
-        /// <param name="netType">The net type name which should be reported.</param>
-        /// <param name="suggestedProperty">The suggested property name which should be reported.</param>
-        [TestCase("Item item = null; int category = item.category;", 33, "item.category", "NetInt", "Category")]
-        [TestCase("Item item = null; int category = (item).category;", 33, "(item).category", "NetInt", "Category")]
-        [TestCase("Item item = null; int category = ((Item)item).category;", 33, "((Item)item).category", "NetInt", "Category")]
-        [TestCase("SObject obj = null; int category = obj.category;", 35, "obj.category", "NetInt", "Category")]
-        public void AvoidNetFields_RaisesDiagnostic(string codeText, int column, string expression, string netType, string suggestedProperty)
-        {
-            // arrange
-            string code = NetFieldAnalyzerTests.SampleProgram.Replace("{{test-code}}", codeText);
-            DiagnosticResult expected = new DiagnosticResult
-            {
-                Id = "AvoidNetField",
-                Message = $"'{expression}' is a {netType} field; consider using the {suggestedProperty} property instead. See https://smapi.io/buildmsg/avoid-net-field for details.",
-                Severity = DiagnosticSeverity.Warning,
-                Locations = new[] { new DiagnosticResultLocation("Test0.cs", NetFieldAnalyzerTests.SampleCodeLine, NetFieldAnalyzerTests.SampleCodeColumn + column) }
-            };
-
-            // assert
-            this.VerifyCSharpDiagnostic(code, expected);
-        }
-
-
-        /*********
-        ** Helpers
-        *********/
-        /// <summary>Get the analyzer being tested.</summary>
-        protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
-        {
-            return new NetFieldAnalyzer();
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/ObsoleteFieldAnalyzerTests.cs b/src/SMAPI.ModBuildConfig.Analyzer.Tests/ObsoleteFieldAnalyzerTests.cs
deleted file mode 100644
index fa9235a3..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/ObsoleteFieldAnalyzerTests.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-using NUnit.Framework;
-using SMAPI.ModBuildConfig.Analyzer.Tests.Framework;
-using StardewModdingAPI.ModBuildConfig.Analyzer;
-
-namespace SMAPI.ModBuildConfig.Analyzer.Tests
-{
-    /// <summary>Unit tests for <see cref="ObsoleteFieldAnalyzer"/>.</summary>
-    [TestFixture]
-    public class ObsoleteFieldAnalyzerTests : DiagnosticVerifier
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Sample C# mod code, with a {{test-code}} placeholder for the code in the Entry method to test.</summary>
-        const string SampleProgram = @"
-            using System;
-            using StardewValley;
-            using Netcode;
-            using SObject = StardewValley.Object;
-
-            namespace SampleMod
-            {
-                class ModEntry
-                {
-                    public void Entry()
-                    {
-                        {{test-code}}
-                    }
-                }
-            }
-        ";
-
-        /// <summary>The line number where the unit tested code is injected into <see cref="SampleProgram"/>.</summary>
-        private const int SampleCodeLine = 13;
-
-        /// <summary>The column number where the unit tested code is injected into <see cref="SampleProgram"/>.</summary>
-        private const int SampleCodeColumn = 25;
-
-
-        /*********
-        ** Unit tests
-        *********/
-        /// <summary>Test that no diagnostics are raised for an empty code block.</summary>
-        [TestCase]
-        public void EmptyCode_HasNoDiagnostics()
-        {
-            // arrange
-            string test = @"";
-
-            // assert
-            this.VerifyCSharpDiagnostic(test);
-        }
-
-        /// <summary>Test that the expected diagnostic message is raised for an obsolete field reference.</summary>
-        /// <param name="codeText">The code line to test.</param>
-        /// <param name="column">The column within the code line where the diagnostic message should be reported.</param>
-        /// <param name="oldName">The old field name which should be reported.</param>
-        /// <param name="newName">The new field name which should be reported.</param>
-        [TestCase("var x = new Farmer().friendships;", 8, "StardewValley.Farmer.friendships", "friendshipData")]
-        [TestCase("var x = new Farmer()?.friendships;", 8, "StardewValley.Farmer.friendships", "friendshipData")]
-        public void AvoidObsoleteField_RaisesDiagnostic(string codeText, int column, string oldName, string newName)
-        {
-            // arrange
-            string code = ObsoleteFieldAnalyzerTests.SampleProgram.Replace("{{test-code}}", codeText);
-            DiagnosticResult expected = new DiagnosticResult
-            {
-                Id = "AvoidObsoleteField",
-                Message = $"The '{oldName}' field is obsolete and should be replaced with '{newName}'. See https://smapi.io/buildmsg/avoid-obsolete-field for details.",
-                Severity = DiagnosticSeverity.Warning,
-                Locations = new[] { new DiagnosticResultLocation("Test0.cs", ObsoleteFieldAnalyzerTests.SampleCodeLine, ObsoleteFieldAnalyzerTests.SampleCodeColumn + column) }
-            };
-
-            // assert
-            this.VerifyCSharpDiagnostic(code, expected);
-        }
-
-
-        /*********
-        ** Helpers
-        *********/
-        /// <summary>Get the analyzer being tested.</summary>
-        protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
-        {
-            return new ObsoleteFieldAnalyzer();
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer.Tests/SMAPI.ModBuildConfig.Analyzer.Tests.csproj b/src/SMAPI.ModBuildConfig.Analyzer.Tests/SMAPI.ModBuildConfig.Analyzer.Tests.csproj
deleted file mode 100644
index 72aaec89..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer.Tests/SMAPI.ModBuildConfig.Analyzer.Tests.csproj
+++ /dev/null
@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="2.8.2" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
-    <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\SMAPI.ModBuildConfig.Analyzer\StardewModdingAPI.ModBuildConfig.Analyzer.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/SMAPI.ModBuildConfig.Analyzer/AnalyzerUtilities.cs b/src/SMAPI.ModBuildConfig.Analyzer/AnalyzerUtilities.cs
deleted file mode 100644
index 68b5001e..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer/AnalyzerUtilities.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-using System.Collections.Generic;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace StardewModdingAPI.ModBuildConfig.Analyzer
-{
-    /// <summary>Provides generic utilities for SMAPI's Roslyn analyzers.</summary>
-    internal static class AnalyzerUtilities
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Get the metadata for an explicit cast or 'x as y' expression.</summary>
-        /// <param name="node">The member access expression.</param>
-        /// <param name="semanticModel">provides methods for asking semantic questions about syntax nodes.</param>
-        /// <param name="fromExpression">The expression whose value is being converted.</param>
-        /// <param name="fromType">The type being converted from.</param>
-        /// <param name="toType">The type being converted to.</param>
-        /// <returns>Returns true if the node is a matched expression, else false.</returns>
-        public static bool TryGetCastOrAsInfo(SyntaxNode node, SemanticModel semanticModel, out ExpressionSyntax fromExpression, out TypeInfo fromType, out TypeInfo toType)
-        {
-            // (type)x
-            if (node is CastExpressionSyntax cast)
-            {
-                fromExpression = cast.Expression;
-                fromType = semanticModel.GetTypeInfo(fromExpression);
-                toType = semanticModel.GetTypeInfo(cast.Type);
-                return true;
-            }
-
-            // x as y
-            if (node is BinaryExpressionSyntax binary && binary.Kind() == SyntaxKind.AsExpression)
-            {
-                fromExpression = binary.Left;
-                fromType = semanticModel.GetTypeInfo(fromExpression);
-                toType = semanticModel.GetTypeInfo(binary.Right);
-                return true;
-            }
-
-            // invalid
-            fromExpression = null;
-            fromType = default(TypeInfo);
-            toType = default(TypeInfo);
-            return false;
-        }
-
-        /// <summary>Get the metadata for a member access expression.</summary>
-        /// <param name="node">The member access expression.</param>
-        /// <param name="semanticModel">provides methods for asking semantic questions about syntax nodes.</param>
-        /// <param name="declaringType">The object type which has the member.</param>
-        /// <param name="memberType">The type of the accessed member.</param>
-        /// <param name="memberName">The name of the accessed member.</param>
-        /// <returns>Returns true if the node is a member access expression, else false.</returns>
-        public static bool TryGetMemberInfo(SyntaxNode node, SemanticModel semanticModel, out ITypeSymbol declaringType, out TypeInfo memberType, out string memberName)
-        {
-            // simple access
-            if (node is MemberAccessExpressionSyntax memberAccess)
-            {
-                declaringType = semanticModel.GetTypeInfo(memberAccess.Expression).Type;
-                memberType = semanticModel.GetTypeInfo(node);
-                memberName = memberAccess.Name.Identifier.Text;
-                return true;
-            }
-
-            // conditional access
-            if (node is ConditionalAccessExpressionSyntax conditionalAccess && conditionalAccess.WhenNotNull is MemberBindingExpressionSyntax conditionalBinding)
-            {
-                declaringType = semanticModel.GetTypeInfo(conditionalAccess.Expression).Type;
-                memberType = semanticModel.GetTypeInfo(node);
-                memberName = conditionalBinding.Name.Identifier.Text;
-                return true;
-            }
-
-            // invalid
-            declaringType = null;
-            memberType = default(TypeInfo);
-            memberName = null;
-            return false;
-        }
-
-        /// <summary>Get the class types in a type's inheritance chain, including itself.</summary>
-        /// <param name="type">The initial type.</param>
-        public static IEnumerable<ITypeSymbol> GetConcreteTypes(ITypeSymbol type)
-        {
-            while (type != null)
-            {
-                yield return type;
-                type = type.BaseType;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer/NetFieldAnalyzer.cs b/src/SMAPI.ModBuildConfig.Analyzer/NetFieldAnalyzer.cs
deleted file mode 100644
index f2608348..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer/NetFieldAnalyzer.cs
+++ /dev/null
@@ -1,329 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace StardewModdingAPI.ModBuildConfig.Analyzer
-{
-    /// <summary>Detects implicit conversion from Stardew Valley's <c>Netcode</c> types. These have very unintuitive implicit conversion rules, so mod authors should always explicitly convert the type with appropriate null checks.</summary>
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class NetFieldAnalyzer : DiagnosticAnalyzer
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The namespace for Stardew Valley's <c>Netcode</c> types.</summary>
-        private const string NetcodeNamespace = "Netcode";
-
-        /// <summary>Maps net fields to their equivalent non-net properties where available.</summary>
-        private readonly IDictionary<string, string> NetFieldWrapperProperties = new Dictionary<string, string>
-        {
-            // AnimatedSprite
-            ["StardewValley.AnimatedSprite::currentAnimation"] = "CurrentAnimation",
-            ["StardewValley.AnimatedSprite::currentFrame"] = "CurrentFrame",
-            ["StardewValley.AnimatedSprite::sourceRect"] = "SourceRect",
-            ["StardewValley.AnimatedSprite::spriteHeight"] = "SpriteHeight",
-            ["StardewValley.AnimatedSprite::spriteWidth"] = "SpriteWidth",
-
-            // Character
-            ["StardewValley.Character::currentLocationRef"] = "currentLocation",
-            ["StardewValley.Character::facingDirection"] = "FacingDirection",
-            ["StardewValley.Character::name"] = "Name",
-            ["StardewValley.Character::position"] = "Position",
-            ["StardewValley.Character::scale"] = "Scale",
-            ["StardewValley.Character::speed"] = "Speed",
-            ["StardewValley.Character::sprite"] = "Sprite",
-
-            // Chest
-            ["StardewValley.Objects.Chest::tint"] = "Tint",
-
-            // Farmer
-            ["StardewValley.Farmer::houseUpgradeLevel"] = "HouseUpgradeLevel",
-            ["StardewValley.Farmer::isMale"] = "IsMale",
-            ["StardewValley.Farmer::items"] = "Items",
-            ["StardewValley.Farmer::magneticRadius"] = "MagneticRadius",
-            ["StardewValley.Farmer::stamina"] = "Stamina",
-            ["StardewValley.Farmer::uniqueMultiplayerID"] = "UniqueMultiplayerID",
-            ["StardewValley.Farmer::usingTool"] = "UsingTool",
-
-            // Forest
-            ["StardewValley.Locations.Forest::netTravelingMerchantDay"] = "travelingMerchantDay",
-            ["StardewValley.Locations.Forest::netLog"] = "log",
-
-            // FruitTree
-            ["StardewValley.TerrainFeatures.FruitTree::greenHouseTileTree"] = "GreenHouseTileTree",
-            ["StardewValley.TerrainFeatures.FruitTree::greenHouseTree"] = "GreenHouseTree",
-
-            // GameLocation
-            ["StardewValley.GameLocation::isFarm"] = "IsFarm",
-            ["StardewValley.GameLocation::isOutdoors"] = "IsOutdoors",
-            ["StardewValley.GameLocation::lightLevel"] = "LightLevel",
-            ["StardewValley.GameLocation::name"] = "Name",
-
-            // Item
-            ["StardewValley.Item::category"] = "Category",
-            ["StardewValley.Item::netName"] = "Name",
-            ["StardewValley.Item::parentSheetIndex"] = "ParentSheetIndex",
-            ["StardewValley.Item::specialVariable"] = "SpecialVariable",
-
-            // Junimo
-            ["StardewValley.Characters.Junimo::eventActor"] = "EventActor",
-
-            // LightSource
-            ["StardewValley.LightSource::identifier"] = "Identifier",
-
-            // Monster
-            ["StardewValley.Monsters.Monster::damageToFarmer"] = "DamageToFarmer",
-            ["StardewValley.Monsters.Monster::experienceGained"] = "ExperienceGained",
-            ["StardewValley.Monsters.Monster::health"] = "Health",
-            ["StardewValley.Monsters.Monster::maxHealth"] = "MaxHealth",
-            ["StardewValley.Monsters.Monster::netFocusedOnFarmers"] = "focusedOnFarmers",
-            ["StardewValley.Monsters.Monster::netWildernessFarmMonster"] = "wildernessFarmMonster",
-            ["StardewValley.Monsters.Monster::slipperiness"] = "Slipperiness",
-
-            // NPC
-            ["StardewValley.NPC::age"] = "Age",
-            ["StardewValley.NPC::birthday_Day"] = "Birthday_Day",
-            ["StardewValley.NPC::birthday_Season"] = "Birthday_Season",
-            ["StardewValley.NPC::breather"] = "Breather",
-            ["StardewValley.NPC::defaultMap"] = "DefaultMap",
-            ["StardewValley.NPC::gender"] = "Gender",
-            ["StardewValley.NPC::hideShadow"] = "HideShadow",
-            ["StardewValley.NPC::isInvisible"] = "IsInvisible",
-            ["StardewValley.NPC::isWalkingTowardPlayer"] = "IsWalkingTowardPlayer",
-            ["StardewValley.NPC::manners"] = "Manners",
-            ["StardewValley.NPC::optimism"] = "Optimism",
-            ["StardewValley.NPC::socialAnxiety"] = "SocialAnxiety",
-
-            // Object
-            ["StardewValley.Object::canBeGrabbed"] = "CanBeGrabbed",
-            ["StardewValley.Object::canBeSetDown"] = "CanBeSetDown",
-            ["StardewValley.Object::edibility"] = "Edibility",
-            ["StardewValley.Object::flipped"] = "Flipped",
-            ["StardewValley.Object::fragility"] = "Fragility",
-            ["StardewValley.Object::hasBeenPickedUpByFarmer"] = "HasBeenPickedUpByFarmer",
-            ["StardewValley.Object::isHoedirt"] = "IsHoeDirt",
-            ["StardewValley.Object::isOn"] = "IsOn",
-            ["StardewValley.Object::isRecipe"] = "IsRecipe",
-            ["StardewValley.Object::isSpawnedObject"] = "IsSpawnedObject",
-            ["StardewValley.Object::minutesUntilReady"] = "MinutesUntilReady",
-            ["StardewValley.Object::netName"] = "name",
-            ["StardewValley.Object::price"] = "Price",
-            ["StardewValley.Object::quality"] = "Quality",
-            ["StardewValley.Object::stack"] = "Stack",
-            ["StardewValley.Object::tileLocation"] = "TileLocation",
-            ["StardewValley.Object::type"] = "Type",
-
-            // Projectile
-            ["StardewValley.Projectiles.Projectile::ignoreLocationCollision"] = "IgnoreLocationCollision",
-
-            // Tool
-            ["StardewValley.Tool::currentParentTileIndex"] = "CurrentParentTileIndex",
-            ["StardewValley.Tool::indexOfMenuItemView"] = "IndexOfMenuItemView",
-            ["StardewValley.Tool::initialParentTileIndex"] = "InitialParentTileIndex",
-            ["StardewValley.Tool::instantUse"] = "InstantUse",
-            ["StardewValley.Tool::netName"] = "BaseName",
-            ["StardewValley.Tool::stackable"] = "Stackable",
-            ["StardewValley.Tool::upgradeLevel"] = "UpgradeLevel"
-        };
-
-        /// <summary>The diagnostic info for an implicit net field cast.</summary>
-        private readonly DiagnosticDescriptor AvoidImplicitNetFieldCastRule = new DiagnosticDescriptor(
-            id: "AvoidImplicitNetFieldCast",
-            title: "Netcode types shouldn't be implicitly converted",
-            messageFormat: "This implicitly converts '{0}' from {1} to {2}, but {1} has unintuitive implicit conversion rules. Consider comparing against the actual value instead to avoid bugs. See https://smapi.io/buildmsg/avoid-implicit-net-field-cast for details.",
-            category: "SMAPI.CommonErrors",
-            defaultSeverity: DiagnosticSeverity.Warning,
-            isEnabledByDefault: true,
-            helpLinkUri: "https://smapi.io/buildmsg/avoid-implicit-net-field-cast"
-        );
-
-        /// <summary>The diagnostic info for an avoidable net field access.</summary>
-        private readonly DiagnosticDescriptor AvoidNetFieldRule = new DiagnosticDescriptor(
-            id: "AvoidNetField",
-            title: "Avoid Netcode types when possible",
-            messageFormat: "'{0}' is a {1} field; consider using the {2} property instead. See https://smapi.io/buildmsg/avoid-net-field for details.",
-            category: "SMAPI.CommonErrors",
-            defaultSeverity: DiagnosticSeverity.Warning,
-            isEnabledByDefault: true,
-            helpLinkUri: "https://smapi.io/buildmsg/avoid-net-field"
-        );
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The descriptors for the diagnostics that this analyzer is capable of producing.</summary>
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public NetFieldAnalyzer()
-        {
-            this.SupportedDiagnostics = ImmutableArray.CreateRange(new[] { this.AvoidNetFieldRule, this.AvoidImplicitNetFieldCastRule });
-        }
-
-        /// <summary>Called once at session start to register actions in the analysis context.</summary>
-        /// <param name="context">The analysis context.</param>
-        public override void Initialize(AnalysisContext context)
-        {
-            context.RegisterSyntaxNodeAction(
-                this.AnalyzeMemberAccess,
-                SyntaxKind.SimpleMemberAccessExpression,
-                SyntaxKind.ConditionalAccessExpression
-            );
-            context.RegisterSyntaxNodeAction(
-                this.AnalyzeCast,
-                SyntaxKind.CastExpression,
-                SyntaxKind.AsExpression
-            );
-            context.RegisterSyntaxNodeAction(
-                this.AnalyzeBinaryComparison,
-                SyntaxKind.EqualsExpression,
-                SyntaxKind.NotEqualsExpression,
-                SyntaxKind.GreaterThanExpression,
-                SyntaxKind.GreaterThanOrEqualExpression,
-                SyntaxKind.LessThanExpression,
-                SyntaxKind.LessThanOrEqualExpression
-            );
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Analyse a member access syntax node and add a diagnostic message if applicable.</summary>
-        /// <param name="context">The analysis context.</param>
-        /// <returns>Returns whether any warnings were added.</returns>
-        private void AnalyzeMemberAccess(SyntaxNodeAnalysisContext context)
-        {
-            this.HandleErrors(context.Node, () =>
-            {
-                // get member access info
-                if (!AnalyzerUtilities.TryGetMemberInfo(context.Node, context.SemanticModel, out ITypeSymbol declaringType, out TypeInfo memberType, out string memberName))
-                    return;
-                if (!this.IsNetType(memberType.Type))
-                    return;
-
-                // warn: use property wrapper if available
-                foreach (ITypeSymbol type in AnalyzerUtilities.GetConcreteTypes(declaringType))
-                {
-                    if (this.NetFieldWrapperProperties.TryGetValue($"{type}::{memberName}", out string suggestedPropertyName))
-                    {
-                        context.ReportDiagnostic(Diagnostic.Create(this.AvoidNetFieldRule, context.Node.GetLocation(), context.Node, memberType.Type.Name, suggestedPropertyName));
-                        return;
-                    }
-                }
-
-                // warn: implicit conversion
-                if (this.IsInvalidConversion(memberType.Type, memberType.ConvertedType))
-                {
-                    context.ReportDiagnostic(Diagnostic.Create(this.AvoidImplicitNetFieldCastRule, context.Node.GetLocation(), context.Node, memberType.Type.Name, memberType.ConvertedType));
-                    return;
-                }
-            });
-        }
-
-        /// <summary>Analyse an explicit cast or 'x as y' node and add a diagnostic message if applicable.</summary>
-        /// <param name="context">The analysis context.</param>
-        /// <returns>Returns whether any warnings were added.</returns>
-        private void AnalyzeCast(SyntaxNodeAnalysisContext context)
-        {
-            // NOTE: implicit conversion within the expression is detected by the member access
-            // checks. This method is only concerned with the conversion of its final value.
-            this.HandleErrors(context.Node, () =>
-            {
-                if (AnalyzerUtilities.TryGetCastOrAsInfo(context.Node, context.SemanticModel, out ExpressionSyntax fromExpression, out TypeInfo fromType, out TypeInfo toType))
-                {
-                    if (this.IsInvalidConversion(fromType.ConvertedType, toType.Type))
-                        context.ReportDiagnostic(Diagnostic.Create(this.AvoidImplicitNetFieldCastRule, context.Node.GetLocation(), fromExpression, fromType.ConvertedType.Name, toType.Type));
-                }
-            });
-        }
-
-        /// <summary>Analyse a binary comparison syntax node and add a diagnostic message if applicable.</summary>
-        /// <param name="context">The analysis context.</param>
-        /// <returns>Returns whether any warnings were added.</returns>
-        private void AnalyzeBinaryComparison(SyntaxNodeAnalysisContext context)
-        {
-            // NOTE: implicit conversion within an operand is detected by the member access checks.
-            // This method is only concerned with the conversion of each side's final value.
-            this.HandleErrors(context.Node, () =>
-            {
-                BinaryExpressionSyntax expression = (BinaryExpressionSyntax)context.Node;
-                foreach (var pair in new[] { Tuple.Create(expression.Left, expression.Right), Tuple.Create(expression.Right, expression.Left) })
-                {
-                    // get node info
-                    ExpressionSyntax curExpression = pair.Item1; // the side of the comparison being examined
-                    ExpressionSyntax otherExpression = pair.Item2; // the other side
-                    TypeInfo curType = context.SemanticModel.GetTypeInfo(curExpression);
-                    TypeInfo otherType = context.SemanticModel.GetTypeInfo(otherExpression);
-                    if (!this.IsNetType(curType.ConvertedType))
-                        continue;
-
-                    // warn for comparison to null
-                    // An expression like `building.indoors != null` will sometimes convert `building.indoors` to NetFieldBase instead of object before comparison. Haven't reproduced this in unit tests yet.
-                    Optional<object> otherValue = context.SemanticModel.GetConstantValue(otherExpression);
-                    if (otherValue.HasValue && otherValue.Value == null)
-                    {
-                        context.ReportDiagnostic(Diagnostic.Create(this.AvoidImplicitNetFieldCastRule, context.Node.GetLocation(), curExpression, curType.Type.Name, "null"));
-                        break;
-                    }
-
-                    // warn for implicit conversion
-                    if (!this.IsNetType(otherType.ConvertedType))
-                    {
-                        context.ReportDiagnostic(Diagnostic.Create(this.AvoidImplicitNetFieldCastRule, context.Node.GetLocation(), curExpression, curType.Type.Name, curType.ConvertedType));
-                        break;
-                    }
-                }
-            });
-        }
-
-        /// <summary>Handle exceptions raised while analyzing a node.</summary>
-        /// <param name="node">The node being analysed.</param>
-        /// <param name="action">The callback to invoke.</param>
-        private void HandleErrors(SyntaxNode node, Action action)
-        {
-            try
-            {
-                action();
-            }
-            catch (Exception ex)
-            {
-                throw new InvalidOperationException($"Failed processing expression: '{node}'. Exception details: {ex.ToString().Replace('\r', ' ').Replace('\n', ' ')}");
-            }
-        }
-
-        /// <summary>Get whether a net field was converted in an error-prone way.</summary>
-        /// <param name="fromType">The source type.</param>
-        /// <param name="toType">The target type.</param>
-        private bool IsInvalidConversion(ITypeSymbol fromType, ITypeSymbol toType)
-        {
-            // no conversion
-            if (!this.IsNetType(fromType) || this.IsNetType(toType))
-                return false;
-
-            // conversion to implemented interface is OK
-            if (fromType.AllInterfaces.Contains(toType))
-                return false;
-
-            // avoid any other conversions
-            return true;
-        }
-
-        /// <summary>Get whether a type symbol references a <c>Netcode</c> type.</summary>
-        /// <param name="typeSymbol">The type symbol.</param>
-        private bool IsNetType(ITypeSymbol typeSymbol)
-        {
-            return typeSymbol?.ContainingNamespace?.Name == NetFieldAnalyzer.NetcodeNamespace;
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer/ObsoleteFieldAnalyzer.cs b/src/SMAPI.ModBuildConfig.Analyzer/ObsoleteFieldAnalyzer.cs
deleted file mode 100644
index f1a3ef75..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer/ObsoleteFieldAnalyzer.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace StardewModdingAPI.ModBuildConfig.Analyzer
-{
-    /// <summary>Detects references to a field which has been replaced.</summary>
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ObsoleteFieldAnalyzer : DiagnosticAnalyzer
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Maps obsolete fields/properties to their non-obsolete equivalent.</summary>
-        private readonly IDictionary<string, string> ReplacedFields = new Dictionary<string, string>
-        {
-            // Farmer
-            ["StardewValley.Farmer::friendships"] = "friendshipData"
-        };
-
-        /// <summary>Describes the diagnostic rule covered by the analyzer.</summary>
-        private readonly IDictionary<string, DiagnosticDescriptor> Rules = new Dictionary<string, DiagnosticDescriptor>
-        {
-            ["AvoidObsoleteField"] = new DiagnosticDescriptor(
-                id: "AvoidObsoleteField",
-                title: "Reference to obsolete field",
-                messageFormat: "The '{0}' field is obsolete and should be replaced with '{1}'. See https://smapi.io/buildmsg/avoid-obsolete-field for details.",
-                category: "SMAPI.CommonErrors",
-                defaultSeverity: DiagnosticSeverity.Warning,
-                isEnabledByDefault: true,
-                helpLinkUri: "https://smapi.io/buildmsg/avoid-obsolete-field"
-            )
-        };
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The descriptors for the diagnostics that this analyzer is capable of producing.</summary>
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ObsoleteFieldAnalyzer()
-        {
-            this.SupportedDiagnostics = ImmutableArray.CreateRange(this.Rules.Values);
-        }
-
-        /// <summary>Called once at session start to register actions in the analysis context.</summary>
-        /// <param name="context">The analysis context.</param>
-        public override void Initialize(AnalysisContext context)
-        {
-            context.RegisterSyntaxNodeAction(
-                this.AnalyzeObsoleteFields,
-                SyntaxKind.SimpleMemberAccessExpression,
-                SyntaxKind.ConditionalAccessExpression
-            );
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Analyse a syntax node and add a diagnostic message if it references an obsolete field.</summary>
-        /// <param name="context">The analysis context.</param>
-        private void AnalyzeObsoleteFields(SyntaxNodeAnalysisContext context)
-        {
-            try
-            {
-                // get reference info
-                if (!AnalyzerUtilities.TryGetMemberInfo(context.Node, context.SemanticModel, out ITypeSymbol declaringType, out TypeInfo memberType, out string memberName))
-                    return;
-
-                // suggest replacement
-                foreach (ITypeSymbol type in AnalyzerUtilities.GetConcreteTypes(declaringType))
-                {
-                    if (this.ReplacedFields.TryGetValue($"{type}::{memberName}", out string replacement))
-                    {
-                        context.ReportDiagnostic(Diagnostic.Create(this.Rules["AvoidObsoleteField"], context.Node.GetLocation(), $"{type}.{memberName}", replacement));
-                        break;
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                throw new InvalidOperationException($"Failed processing expression: '{context.Node}'. Exception details: {ex.ToString().Replace('\r', ' ').Replace('\n', ' ')}");
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig.Analyzer/Properties/AssemblyInfo.cs b/src/SMAPI.ModBuildConfig.Analyzer/Properties/AssemblyInfo.cs
deleted file mode 100644
index 1cc41000..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("SMAPI.ModBuildConfig.Analyzer")]
-[assembly: AssemblyDescription("")]
diff --git a/src/SMAPI.ModBuildConfig.Analyzer/StardewModdingAPI.ModBuildConfig.Analyzer.csproj b/src/SMAPI.ModBuildConfig.Analyzer/StardewModdingAPI.ModBuildConfig.Analyzer.csproj
deleted file mode 100644
index 9d646e8f..00000000
--- a/src/SMAPI.ModBuildConfig.Analyzer/StardewModdingAPI.ModBuildConfig.Analyzer.csproj
+++ /dev/null
@@ -1,24 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netstandard1.3</TargetFramework>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <IncludeBuildOutput>false</IncludeBuildOutput>
-    <OutputPath>bin</OutputPath>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs" Link="Properties\GlobalAssemblyInfo.cs" />
-  </ItemGroup>
-   
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="2.8.2" PrivateAssets="all" />
-    <PackageReference Update="NETStandard.Library" PrivateAssets="all" />
-  </ItemGroup>
-  
-  <ItemGroup>
-    <None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/SMAPI.ModBuildConfig/DeployModTask.cs b/src/SMAPI.ModBuildConfig/DeployModTask.cs
deleted file mode 100644
index 96d95e06..00000000
--- a/src/SMAPI.ModBuildConfig/DeployModTask.cs
+++ /dev/null
@@ -1,185 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.IO.Compression;
-using System.Linq;
-using System.Text.RegularExpressions;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using StardewModdingAPI.ModBuildConfig.Framework;
-
-namespace StardewModdingAPI.ModBuildConfig
-{
-    /// <summary>A build task which deploys the mod files and prepares a release zip.</summary>
-    public class DeployModTask : Task
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The name of the mod folder.</summary>
-        [Required]
-        public string ModFolderName { get; set; }
-
-        /// <summary>The absolute or relative path to the folder which should contain the generated zip file.</summary>
-        [Required]
-        public string ModZipPath { get; set; }
-
-        /// <summary>The folder containing the project files.</summary>
-        [Required]
-        public string ProjectDir { get; set; }
-
-        /// <summary>The folder containing the build output.</summary>
-        [Required]
-        public string TargetDir { get; set; }
-
-        /// <summary>The folder containing the game files.</summary>
-        [Required]
-        public string GameDir { get; set; }
-
-        /// <summary>Whether to enable copying the mod files into the game's Mods folder.</summary>
-        [Required]
-        public bool EnableModDeploy { get; set; }
-
-        /// <summary>Whether to enable the release zip.</summary>
-        [Required]
-        public bool EnableModZip { get; set; }
-
-        /// <summary>Custom comma-separated regex patterns matching files to ignore when deploying or zipping the mod.</summary>
-        public string IgnoreModFilePatterns { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>When overridden in a derived class, executes the task.</summary>
-        /// <returns>true if the task successfully executed; otherwise, false.</returns>
-        public override bool Execute()
-        {
-            if (!this.EnableModDeploy && !this.EnableModZip)
-                return true; // nothing to do
-
-            try
-            {
-                // parse ignore patterns
-                Regex[] ignoreFilePatterns = this.GetCustomIgnorePatterns().ToArray();
-
-                // get mod info
-                ModFileManager package = new ModFileManager(this.ProjectDir, this.TargetDir, ignoreFilePatterns, validateRequiredModFiles: this.EnableModDeploy || this.EnableModZip);
-
-                // deploy mod files
-                if (this.EnableModDeploy)
-                {
-                    string outputPath = Path.Combine(this.GameDir, "Mods", this.EscapeInvalidFilenameCharacters(this.ModFolderName));
-                    this.Log.LogMessage(MessageImportance.High, $"The mod build package is copying the mod files to {outputPath}...");
-                    this.CreateModFolder(package.GetFiles(), outputPath);
-                }
-
-                // create release zip
-                if (this.EnableModZip)
-                {
-                    this.Log.LogMessage(MessageImportance.High, $"The mod build package is generating a release zip at {this.ModZipPath} for {this.ModFolderName}...");
-                    this.CreateReleaseZip(package.GetFiles(), this.ModFolderName, package.GetManifestVersion(), this.ModZipPath);
-                }
-
-                return true;
-            }
-            catch (UserErrorException ex)
-            {
-                this.Log.LogErrorFromException(ex);
-                return false;
-            }
-            catch (Exception ex)
-            {
-                this.Log.LogError($"The mod build package failed trying to deploy the mod.\n{ex}");
-                return false;
-            }
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the custom ignore patterns provided by the user.</summary>
-        private IEnumerable<Regex> GetCustomIgnorePatterns()
-        {
-            if (string.IsNullOrWhiteSpace(this.IgnoreModFilePatterns))
-                yield break;
-
-            foreach (string raw in this.IgnoreModFilePatterns.Split(','))
-            {
-                Regex regex;
-                try
-                {
-                    regex = new Regex(raw.Trim(), RegexOptions.IgnoreCase);
-                }
-                catch (Exception ex)
-                {
-                    this.Log.LogWarning($"Ignored invalid <{nameof(this.IgnoreModFilePatterns)}> pattern {raw}:\n{ex}");
-                    continue;
-                }
-
-                yield return regex;
-            }
-        }
-
-        /// <summary>Copy the mod files into the game's mod folder.</summary>
-        /// <param name="files">The files to include.</param>
-        /// <param name="modFolderPath">The folder path to create with the mod files.</param>
-        private void CreateModFolder(IDictionary<string, FileInfo> files, string modFolderPath)
-        {
-            foreach (var entry in files)
-            {
-                string fromPath = entry.Value.FullName;
-                string toPath = Path.Combine(modFolderPath, entry.Key);
-
-                // ReSharper disable once AssignNullToNotNullAttribute -- not applicable in this context
-                Directory.CreateDirectory(Path.GetDirectoryName(toPath));
-
-                File.Copy(fromPath, toPath, overwrite: true);
-            }
-        }
-
-        /// <summary>Create a release zip in the recommended format for uploading to mod sites.</summary>
-        /// <param name="files">The files to include.</param>
-        /// <param name="modName">The name of the mod.</param>
-        /// <param name="modVersion">The mod version string.</param>
-        /// <param name="outputFolderPath">The absolute or relative path to the folder which should contain the generated zip file.</param>
-        private void CreateReleaseZip(IDictionary<string, FileInfo> files, string modName, string modVersion, string outputFolderPath)
-        {
-            // get names
-            string zipName = this.EscapeInvalidFilenameCharacters($"{modName} {modVersion}.zip");
-            string folderName = this.EscapeInvalidFilenameCharacters(modName);
-            string zipPath = Path.Combine(outputFolderPath, zipName);
-
-            // create zip file
-            Directory.CreateDirectory(outputFolderPath);
-            using (Stream zipStream = new FileStream(zipPath, FileMode.Create, FileAccess.Write))
-            using (ZipArchive archive = new ZipArchive(zipStream, ZipArchiveMode.Create))
-            {
-                foreach (var fileEntry in files)
-                {
-                    string relativePath = fileEntry.Key;
-                    FileInfo file = fileEntry.Value;
-
-                    // get file info
-                    string filePath = file.FullName;
-                    string entryName = folderName + '/' + relativePath.Replace(Path.DirectorySeparatorChar, '/');
-
-                    // add to zip
-                    using (Stream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
-                    using (Stream fileStreamInZip = archive.CreateEntry(entryName).Open())
-                        fileStream.CopyTo(fileStreamInZip);
-                }
-            }
-        }
-
-        /// <summary>Get a copy of a filename with all invalid filename characters substituted.</summary>
-        /// <param name="name">The filename.</param>
-        private string EscapeInvalidFilenameCharacters(string name)
-        {
-            foreach (char invalidChar in Path.GetInvalidFileNameChars())
-                name = name.Replace(invalidChar, '.');
-            return name;
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig/Framework/ModFileManager.cs b/src/SMAPI.ModBuildConfig/Framework/ModFileManager.cs
deleted file mode 100644
index 6c11b0fe..00000000
--- a/src/SMAPI.ModBuildConfig/Framework/ModFileManager.cs
+++ /dev/null
@@ -1,173 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using StardewModdingAPI.Toolkit.Serialisation;
-using StardewModdingAPI.Toolkit.Serialisation.Models;
-using StardewModdingAPI.Toolkit.Utilities;
-
-namespace StardewModdingAPI.ModBuildConfig.Framework
-{
-    /// <summary>Manages the files that are part of a mod package.</summary>
-    internal class ModFileManager
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The name of the manifest file.</summary>
-        private readonly string ManifestFileName = "manifest.json";
-
-        /// <summary>The files that are part of the package.</summary>
-        private readonly IDictionary<string, FileInfo> Files;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="projectDir">The folder containing the project files.</param>
-        /// <param name="targetDir">The folder containing the build output.</param>
-        /// <param name="ignoreFilePatterns">Custom regex patterns matching files to ignore when deploying or zipping the mod.</param>
-        /// <param name="validateRequiredModFiles">Whether to validate that required mod files like the manifest are present.</param>
-        /// <exception cref="UserErrorException">The mod package isn't valid.</exception>
-        public ModFileManager(string projectDir, string targetDir, Regex[] ignoreFilePatterns, bool validateRequiredModFiles)
-        {
-            this.Files = new Dictionary<string, FileInfo>(StringComparer.InvariantCultureIgnoreCase);
-
-            // validate paths
-            if (!Directory.Exists(projectDir))
-                throw new UserErrorException("Could not create mod package because the project folder wasn't found.");
-            if (!Directory.Exists(targetDir))
-                throw new UserErrorException("Could not create mod package because no build output was found.");
-
-            // project manifest
-            bool hasProjectManifest = false;
-            {
-                FileInfo manifest = new FileInfo(Path.Combine(projectDir, "manifest.json"));
-                if (manifest.Exists)
-                {
-                    this.Files[this.ManifestFileName] = manifest;
-                    hasProjectManifest = true;
-                }
-            }
-
-            // project i18n files
-            bool hasProjectTranslations = false;
-            DirectoryInfo translationsFolder = new DirectoryInfo(Path.Combine(projectDir, "i18n"));
-            if (translationsFolder.Exists)
-            {
-                foreach (FileInfo file in translationsFolder.EnumerateFiles())
-                    this.Files[Path.Combine("i18n", file.Name)] = file;
-                hasProjectTranslations = true;
-            }
-
-            // project assets folder
-            bool hasAssetsFolder = false;
-            DirectoryInfo assetsFolder = new DirectoryInfo(Path.Combine(projectDir, "assets"));
-            if (assetsFolder.Exists)
-            {
-                foreach (FileInfo file in assetsFolder.EnumerateFiles("*", SearchOption.AllDirectories))
-                {
-                    string relativePath = PathUtilities.GetRelativePath(projectDir, file.FullName);
-                    this.Files[relativePath] = file;
-                }
-                hasAssetsFolder = true;
-            }
-
-            // build output
-            DirectoryInfo buildFolder = new DirectoryInfo(targetDir);
-            foreach (FileInfo file in buildFolder.EnumerateFiles("*", SearchOption.AllDirectories))
-            {
-                // get path info
-                string relativePath = PathUtilities.GetRelativePath(buildFolder.FullName, file.FullName);
-                string[] segments = PathUtilities.GetSegments(relativePath);
-
-                // prefer project manifest/i18n/assets files
-                if (hasProjectManifest && this.EqualsInvariant(relativePath, this.ManifestFileName))
-                    continue;
-                if (hasProjectTranslations && this.EqualsInvariant(segments[0], "i18n"))
-                    continue;
-                if (hasAssetsFolder && this.EqualsInvariant(segments[0], "assets"))
-                    continue;
-
-                // handle ignored files
-                if (this.ShouldIgnore(file, relativePath, ignoreFilePatterns))
-                    continue;
-
-                // add file
-                this.Files[relativePath] = file;
-            }
-
-            // check for required files
-            if (validateRequiredModFiles)
-            {
-                // manifest
-                if (!this.Files.ContainsKey(this.ManifestFileName))
-                    throw new UserErrorException($"Could not create mod package because no {this.ManifestFileName} was found in the project or build output.");
-
-                // DLL
-                // ReSharper disable once SimplifyLinqExpression
-                if (!this.Files.Any(p => !p.Key.EndsWith(".dll")))
-                    throw new UserErrorException("Could not create mod package because no .dll file was found in the project or build output.");
-            }
-        }
-
-        /// <summary>Get the files in the mod package.</summary>
-        public IDictionary<string, FileInfo> GetFiles()
-        {
-            return new Dictionary<string, FileInfo>(this.Files, StringComparer.InvariantCultureIgnoreCase);
-        }
-
-        /// <summary>Get a semantic version from the mod manifest.</summary>
-        /// <exception cref="UserErrorException">The manifest is missing or invalid.</exception>
-        public string GetManifestVersion()
-        {
-            if (!this.Files.TryGetValue(this.ManifestFileName, out FileInfo manifestFile) || !new JsonHelper().ReadJsonFileIfExists(manifestFile.FullName, out Manifest manifest))
-                throw new InvalidOperationException($"The mod does not have a {this.ManifestFileName} file."); // shouldn't happen since we validate in constructor
-
-            return manifest.Version.ToString();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get whether a build output file should be ignored.</summary>
-        /// <param name="file">The file to check.</param>
-        /// <param name="relativePath">The file's relative path in the package.</param>
-        /// <param name="ignoreFilePatterns">Custom regex patterns matching files to ignore when deploying or zipping the mod.</param>
-        private bool ShouldIgnore(FileInfo file, string relativePath, Regex[] ignoreFilePatterns)
-        {
-            return
-                // release zips
-                this.EqualsInvariant(file.Extension, ".zip")
-
-                // Json.NET (bundled into SMAPI)
-                || this.EqualsInvariant(file.Name, "Newtonsoft.Json.dll")
-                || this.EqualsInvariant(file.Name, "Newtonsoft.Json.pdb")
-                || this.EqualsInvariant(file.Name, "Newtonsoft.Json.xml")
-
-                // code analysis files
-                || file.Name.EndsWith(".CodeAnalysisLog.xml", StringComparison.InvariantCultureIgnoreCase)
-                || file.Name.EndsWith(".lastcodeanalysissucceeded", StringComparison.InvariantCultureIgnoreCase)
-
-                // OS metadata files
-                || this.EqualsInvariant(file.Name, ".DS_Store")
-                || this.EqualsInvariant(file.Name, "Thumbs.db")
-
-                // custom ignore patterns
-                || ignoreFilePatterns.Any(p => p.IsMatch(relativePath));
-        }
-
-        /// <summary>Get whether a string is equal to another case-insensitively.</summary>
-        /// <param name="str">The string value.</param>
-        /// <param name="other">The string to compare with.</param>
-        private bool EqualsInvariant(string str, string other)
-        {
-            if (str == null)
-                return other == null;
-            return str.Equals(other, StringComparison.InvariantCultureIgnoreCase);
-        }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig/Framework/UserErrorException.cs b/src/SMAPI.ModBuildConfig/Framework/UserErrorException.cs
deleted file mode 100644
index 64e31c29..00000000
--- a/src/SMAPI.ModBuildConfig/Framework/UserErrorException.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using System;
-
-namespace StardewModdingAPI.ModBuildConfig.Framework
-{
-    /// <summary>A user error whose message can be displayed to the user.</summary>
-    internal class UserErrorException : Exception
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="message">The error message.</param>
-        public UserErrorException(string message)
-            : base(message) { }
-    }
-}
diff --git a/src/SMAPI.ModBuildConfig/Properties/AssemblyInfo.cs b/src/SMAPI.ModBuildConfig/Properties/AssemblyInfo.cs
deleted file mode 100644
index e051bfbd..00000000
--- a/src/SMAPI.ModBuildConfig/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("SMAPI.ModBuildConfig")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyVersion("2.2.0")]
-[assembly: AssemblyFileVersion("2.2.0")]
diff --git a/src/SMAPI.ModBuildConfig/StardewModdingAPI.ModBuildConfig.csproj b/src/SMAPI.ModBuildConfig/StardewModdingAPI.ModBuildConfig.csproj
deleted file mode 100644
index 25cb372f..00000000
--- a/src/SMAPI.ModBuildConfig/StardewModdingAPI.ModBuildConfig.csproj
+++ /dev/null
@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
-    <ProjectGuid>{EA4F1E80-743F-4A1D-9757-AE66904A196A}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>StardewModdingAPI.ModBuildConfig</RootNamespace>
-    <AssemblyName>StardewModdingAPI.ModBuildConfig</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Microsoft.Build" />
-    <Reference Include="Microsoft.Build.Framework" />
-    <Reference Include="Microsoft.Build.Utilities.v4.0" />
-    <Reference Include="System" />
-    <Reference Include="System.IO.Compression" />
-    <Reference Include="System.Web.Extensions" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="DeployModTask.cs" />
-    <Compile Include="Framework\UserErrorException.cs" />
-    <Compile Include="Framework\ModFileManager.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="..\..\docs\mod-build-config.md">
-      <Link>mod-build-config.md</Link>
-    </None>
-    <None Include="assets\nuget-icon.pdn" />
-    <None Include="build\smapi.targets">
-      <SubType>Designer</SubType>
-    </None>
-    <None Include="package.nuspec">
-      <SubType>Designer</SubType>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="assets\nuget-icon.png" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit.CoreInterfaces\StardewModdingAPI.Toolkit.CoreInterfaces.csproj">
-      <Project>{d5cfd923-37f1-4bc3-9be8-e506e202ac28}</Project>
-      <Name>StardewModdingAPI.Toolkit.CoreInterfaces</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit\StardewModdingAPI.Toolkit.csproj">
-      <Project>{ea5cfd2e-9453-4d29-b80f-8e0ea23f4ac6}</Project>
-      <Name>StardewModdingAPI.Toolkit</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="..\SMAPI.Internal\SMAPI.Internal.projitems" Label="Shared" />
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\..\build\common.targets" />
-  <Import Project="..\..\build\prepare-nuget-package.targets" />
-</Project>
\ No newline at end of file
diff --git a/src/SMAPI.ModBuildConfig/assets/nuget-icon.pdn b/src/SMAPI.ModBuildConfig/assets/nuget-icon.pdn
deleted file mode 100644
index 7bd5c0c5..00000000
Binary files a/src/SMAPI.ModBuildConfig/assets/nuget-icon.pdn and /dev/null differ
diff --git a/src/SMAPI.ModBuildConfig/assets/nuget-icon.png b/src/SMAPI.ModBuildConfig/assets/nuget-icon.png
deleted file mode 100644
index 611cdf88..00000000
Binary files a/src/SMAPI.ModBuildConfig/assets/nuget-icon.png and /dev/null differ
diff --git a/src/SMAPI.ModBuildConfig/build/smapi.targets b/src/SMAPI.ModBuildConfig/build/smapi.targets
deleted file mode 100644
index 99011629..00000000
--- a/src/SMAPI.ModBuildConfig/build/smapi.targets
+++ /dev/null
@@ -1,185 +0,0 @@
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <!--*********************************************
-  ** Import build tasks
-  **********************************************-->
-  <UsingTask TaskName="DeployModTask" AssemblyFile="StardewModdingAPI.ModBuildConfig.dll" />
-
-  <!--*********************************************
-  ** Find the basic mod metadata
-  **********************************************-->
-  <!-- import developer's custom settings (if any) -->
-  <Import Condition="$(OS) != 'Windows_NT' AND Exists('$(HOME)\stardewvalley.targets')" Project="$(HOME)\stardewvalley.targets" />
-  <Import Condition="$(OS) == 'Windows_NT' AND Exists('$(USERPROFILE)\stardewvalley.targets')" Project="$(USERPROFILE)\stardewvalley.targets" />
-
-  <!-- set setting defaults -->
-  <PropertyGroup>
-    <!-- map legacy settings -->
-    <ModFolderName Condition="'$(ModFolderName)' == '' AND '$(DeployModFolderName)' != ''">$(DeployModFolderName)</ModFolderName>
-    <ModZipPath Condition="'$(ModZipPath)' == '' AND '$(DeployModZipTo)' != ''">$(DeployModZipTo)</ModZipPath>
-
-    <!-- set default settings -->
-    <ModFolderName Condition="'$(ModFolderName)' == ''">$(MSBuildProjectName)</ModFolderName>
-    <ModZipPath Condition="'$(ModZipPath)' == ''">$(TargetDir)</ModZipPath>
-    <EnableModDeploy Condition="'$(EnableModDeploy)' == ''">True</EnableModDeploy>
-    <EnableModZip Condition="'$(EnableModZip)' == ''">True</EnableModZip>
-    <CopyModReferencesToBuildOutput Condition="'$(CopyModReferencesToBuildOutput)' == ''">False</CopyModReferencesToBuildOutput>
-  </PropertyGroup>
-
-  <!-- find platform + game path -->
-  <Choose>
-    <When Condition="$(OS) == 'Unix' OR $(OS) == 'OSX'">
-      <PropertyGroup>
-        <!-- Linux -->
-        <GamePath Condition="!Exists('$(GamePath)')">$(HOME)/GOG Games/Stardew Valley/game</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">$(HOME)/.steam/steam/steamapps/common/Stardew Valley</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">$(HOME)/.local/share/Steam/steamapps/common/Stardew Valley</GamePath>
-
-        <!-- Mac (may be 'Unix' or 'OSX') -->
-        <GamePath Condition="!Exists('$(GamePath)')">/Applications/Stardew Valley.app/Contents/MacOS</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">$(HOME)/Library/Application Support/Steam/steamapps/common/Stardew Valley/Contents/MacOS</GamePath>
-      </PropertyGroup>
-    </When>
-    <When Condition="$(OS) == 'Windows_NT'">
-      <PropertyGroup>
-        <!-- default paths -->
-        <GamePath Condition="!Exists('$(GamePath)')">C:\Program Files\GalaxyClient\Games\Stardew Valley</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">C:\Program Files\GOG Galaxy\Games\Stardew Valley</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">C:\Program Files\Steam\steamapps\common\Stardew Valley</GamePath>
-
-        <GamePath Condition="!Exists('$(GamePath)')">C:\Program Files (x86)\GalaxyClient\Games\Stardew Valley</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">C:\Program Files (x86)\GOG Galaxy\Games\Stardew Valley</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">C:\Program Files (x86)\Steam\steamapps\common\Stardew Valley</GamePath>
-
-        <!-- registry paths -->
-        <GamePath Condition="!Exists('$(GamePath)')">$([MSBuild]::GetRegistryValueFromView('HKEY_LOCAL_MACHINE\SOFTWARE\GOG.com\Games\1453375253', 'PATH', null, RegistryView.Registry32))</GamePath>
-        <GamePath Condition="!Exists('$(GamePath)')">$([MSBuild]::GetRegistryValueFromView('HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Steam App 413150', 'InstallLocation', null, RegistryView.Registry64, RegistryView.Registry32))</GamePath>
-
-        <!-- derive from Steam library path -->
-        <_SteamLibraryPath>$([MSBuild]::GetRegistryValueFromView('HKEY_CURRENT_USER\SOFTWARE\Valve\Steam', 'SteamPath', null, RegistryView.Registry32))</_SteamLibraryPath>
-        <GamePath Condition="!Exists('$(GamePath)') AND '$(_SteamLibraryPath)' != ''">$(_SteamLibraryPath)\steamapps\common\Stardew Valley</GamePath>
-      </PropertyGroup>
-    </When>
-  </Choose>
-
-
-  <!--*********************************************
-  ** Inject the assembly references and debugging configuration
-  **********************************************-->
-  <Choose>
-    <When Condition="$(OS) == 'Windows_NT'">
-      <!-- references -->
-      <ItemGroup>
-        <Reference Include="Microsoft.Xna.Framework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="Microsoft.Xna.Framework.Game, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="Microsoft.Xna.Framework.Graphics, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="Microsoft.Xna.Framework.Xact, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="Netcode">
-          <HintPath>$(GamePath)\Netcode.dll</HintPath>
-          <Private>False</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="Stardew Valley">
-          <HintPath>$(GamePath)\Stardew Valley.exe</HintPath>
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="StardewModdingAPI">
-          <HintPath>$(GamePath)\StardewModdingAPI.exe</HintPath>
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="StardewModdingAPI.Toolkit.CoreInterfaces">
-          <HintPath>$(GamePath)\smapi-internal\StardewModdingAPI.Toolkit.CoreInterfaces.dll</HintPath>
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="xTile, Version=2.0.4.0, Culture=neutral, processorArchitecture=x86">
-          <HintPath>$(GamePath)\xTile.dll</HintPath>
-          <Private>false</Private>
-          <SpecificVersion>False</SpecificVersion>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-      </ItemGroup>
-
-      <!-- launch game for debugging -->
-      <PropertyGroup>
-        <StartAction>Program</StartAction>
-        <StartProgram>$(GamePath)\StardewModdingAPI.exe</StartProgram>
-        <StartWorkingDirectory>$(GamePath)</StartWorkingDirectory>
-      </PropertyGroup>
-    </When>
-    <Otherwise>
-      <!-- references -->
-      <ItemGroup>
-        <Reference Include="MonoGame.Framework">
-          <HintPath>$(GamePath)\MonoGame.Framework.dll</HintPath>
-          <Private>false</Private>
-          <SpecificVersion>False</SpecificVersion>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="StardewValley">
-          <HintPath>$(GamePath)\StardewValley.exe</HintPath>
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="StardewModdingAPI">
-          <HintPath>$(GamePath)\StardewModdingAPI.exe</HintPath>
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="StardewModdingAPI.Toolkit.CoreInterfaces">
-          <HintPath>$(GamePath)\smapi-internal\StardewModdingAPI.Toolkit.CoreInterfaces.dll</HintPath>
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-        <Reference Include="xTile">
-          <HintPath>$(GamePath)\xTile.dll</HintPath>
-          <Private>false</Private>
-          <Private Condition="$(CopyModReferencesToBuildOutput)">true</Private>
-        </Reference>
-      </ItemGroup>
-    </Otherwise>
-  </Choose>
-
-
-  <!--*********************************************
-  ** Deploy mod files & create release zip after build
-  **********************************************-->
-  <!-- if game path or OS is invalid, show one user-friendly error instead of a slew of reference errors -->
-  <Target Name="BeforeBuild">
-    <Error Condition="'$(OS)' != 'OSX' AND '$(OS)' != 'Unix' AND '$(OS)' != 'Windows_NT'" Text="The mod build package doesn't recognise OS type '$(OS)'." />
-
-    <Error Condition="!Exists('$(GamePath)')" Text="The mod build package can't find your game folder. You can specify where to find it; see https://smapi.io/buildmsg/game-path." />
-    <Error Condition="'$(OS)' == 'Windows_NT' AND !Exists('$(GamePath)\Stardew Valley.exe')" Text="The mod build package found a game folder at $(GamePath), but it doesn't contain the Stardew Valley.exe file. If this folder is invalid, delete it and the package will autodetect another game install path." />
-    <Error Condition="'$(OS)' != 'Windows_NT' AND !Exists('$(GamePath)\StardewValley.exe')" Text="The mod build package found a game folder at $(GamePath), but it doesn't contain the StardewValley.exe file. If this folder is invalid, delete it and the package will autodetect another game install path." />
-    <Error Condition="!Exists('$(GamePath)\StardewModdingAPI.exe')" Text="The mod build package found a game folder at $(GamePath), but it doesn't contain SMAPI. You need to install SMAPI before building the mod." />
-  </Target>
-
-  <!-- deploy mod files & create release zip -->
-  <Target Name="AfterBuild">
-    <DeployModTask
-      ModFolderName="$(ModFolderName)"
-      ModZipPath="$(ModZipPath)"
-
-      EnableModDeploy="$(EnableModDeploy)"
-      EnableModZip="$(EnableModZip)"
-
-      ProjectDir="$(ProjectDir)"
-      TargetDir="$(TargetDir)"
-      GameDir="$(GamePath)"
-      IgnoreModFilePatterns="$(IgnoreModFilePatterns)"
-    />
-  </Target>
-</Project>
diff --git a/src/SMAPI.ModBuildConfig/package.nuspec b/src/SMAPI.ModBuildConfig/package.nuspec
deleted file mode 100644
index eb967bc0..00000000
--- a/src/SMAPI.ModBuildConfig/package.nuspec
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
-  <metadata>
-    <id>Pathoschild.Stardew.ModBuildConfig</id>
-    <version>3.0.0</version>
-    <title>Build package for SMAPI mods</title>
-    <authors>Pathoschild</authors>
-    <owners>Pathoschild</owners>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <licenseUrl>https://github.com/Pathoschild/SMAPI/blob/develop/LICENSE.txt</licenseUrl>
-    <projectUrl>https://github.com/Pathoschild/SMAPI/blob/develop/docs/mod-build-config.md#readme</projectUrl>
-    <iconUrl>https://raw.githubusercontent.com/Pathoschild/SMAPI/develop/src/SMAPI.ModBuildConfig/assets/nuget-icon.png</iconUrl>
-    <description>Automates the build configuration for crossplatform Stardew Valley SMAPI mods. For SMAPI 2.11 or later.</description>
-    <releaseNotes>
-      3.0.0:
-      - If the project contains an `assets` folder, its contents are now included in the mod automatically.
-      - Dropped support for very old versions of SMAPI and Visual Studio.
-      - Fixed `Newtonsoft.Json.pdb` included in release zips when Json.NET is referenced directly.
-    </releaseNotes>
-  </metadata>
-</package>
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ArgumentParser.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ArgumentParser.cs
deleted file mode 100644
index 10007b42..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ArgumentParser.cs
+++ /dev/null
@@ -1,158 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands
-{
-    /// <summary>Provides methods for parsing command-line arguments.</summary>
-    internal class ArgumentParser : IReadOnlyList<string>
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The command name for errors.</summary>
-        private readonly string CommandName;
-
-        /// <summary>The arguments to parse.</summary>
-        private readonly string[] Args;
-
-        /// <summary>Writes messages to the console and log file.</summary>
-        private readonly IMonitor Monitor;
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>Get the number of arguments.</summary>
-        public int Count => this.Args.Length;
-
-        /// <summary>Get the argument at the specified index in the list.</summary>
-        /// <param name="index">The zero-based index of the element to get.</param>
-        public string this[int index] => this.Args[index];
-
-        /// <summary>A method which parses a string argument into the given value.</summary>
-        /// <typeparam name="T">The expected argument type.</typeparam>
-        /// <param name="input">The argument to parse.</param>
-        /// <param name="output">The parsed value.</param>
-        /// <returns>Returns whether the argument was successfully parsed.</returns>
-        public delegate bool ParseDelegate<T>(string input, out T output);
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="commandName">The command name for errors.</param>
-        /// <param name="args">The arguments to parse.</param>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        public ArgumentParser(string commandName, string[] args, IMonitor monitor)
-        {
-            this.CommandName = commandName;
-            this.Args = args;
-            this.Monitor = monitor;
-        }
-
-        /// <summary>Try to read a string argument.</summary>
-        /// <param name="index">The argument index.</param>
-        /// <param name="name">The argument name for error messages.</param>
-        /// <param name="value">The parsed value.</param>
-        /// <param name="required">Whether to show an error if the argument is missing.</param>
-        /// <param name="oneOf">Require that the argument match one of the given values (case-insensitive).</param>
-        public bool TryGet(int index, string name, out string value, bool required = true, string[] oneOf = null)
-        {
-            value = null;
-
-            // validate
-            if (this.Args.Length < index + 1)
-            {
-                if (required)
-                    this.LogError($"Argument {index} ({name}) is required.");
-                return false;
-            }
-            if (oneOf?.Any() == true && !oneOf.Contains(this.Args[index], StringComparer.InvariantCultureIgnoreCase))
-            {
-                this.LogError($"Argument {index} ({name}) must be one of {string.Join(", ", oneOf)}.");
-                return false;
-            }
-
-            // get value
-            value = this.Args[index];
-            return true;
-        }
-
-        /// <summary>Try to read an integer argument.</summary>
-        /// <param name="index">The argument index.</param>
-        /// <param name="name">The argument name for error messages.</param>
-        /// <param name="value">The parsed value.</param>
-        /// <param name="required">Whether to show an error if the argument is missing.</param>
-        /// <param name="min">The minimum value allowed.</param>
-        /// <param name="max">The maximum value allowed.</param>
-        public bool TryGetInt(int index, string name, out int value, bool required = true, int? min = null, int? max = null)
-        {
-            value = 0;
-
-            // get argument
-            if (!this.TryGet(index, name, out string raw, required))
-                return false;
-
-            // parse
-            if (!int.TryParse(raw, out value))
-            {
-                this.LogIntFormatError(index, name, min, max);
-                return false;
-            }
-
-            // validate
-            if ((min.HasValue && value < min) || (max.HasValue && value > max))
-            {
-                this.LogIntFormatError(index, name, min, max);
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <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<string> GetEnumerator()
-        {
-            return ((IEnumerable<string>)this.Args).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 this.GetEnumerator();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Log a usage error.</summary>
-        /// <param name="message">The message describing the error.</param>
-        private void LogError(string message)
-        {
-            this.Monitor.Log($"{message} Type 'help {this.CommandName}' for usage.", LogLevel.Error);
-        }
-
-        /// <summary>Print an error for an invalid int argument.</summary>
-        /// <param name="index">The argument index.</param>
-        /// <param name="name">The argument name for error messages.</param>
-        /// <param name="min">The minimum value allowed.</param>
-        /// <param name="max">The maximum value allowed.</param>
-        private void LogIntFormatError(int index, string name, int? min, int? max)
-        {
-            if (min.HasValue && max.HasValue)
-                this.LogError($"Argument {index} ({name}) must be an integer between {min} and {max}.");
-            else if (min.HasValue)
-                this.LogError($"Argument {index} ({name}) must be an integer and at least {min}.");
-            else if (max.HasValue)
-                this.LogError($"Argument {index} ({name}) must be an integer and at most {max}.");
-            else
-                this.LogError($"Argument {index} ({name}) must be an integer.");
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ITrainerCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ITrainerCommand.cs
deleted file mode 100644
index a0b739f8..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/ITrainerCommand.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands
-{
-    /// <summary>A console command to register.</summary>
-    internal interface ITrainerCommand
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The command name the user must type.</summary>
-        string Name { get; }
-
-        /// <summary>The command description.</summary>
-        string Description { get; }
-
-        /// <summary>Whether the command needs to perform logic when the game updates.</summary>
-        bool NeedsUpdate { get; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        void Handle(IMonitor monitor, string command, ArgumentParser args);
-
-        /// <summary>Perform any logic needed on update tick.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        void Update(IMonitor monitor);
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/DebugCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/DebugCommand.cs
deleted file mode 100644
index e4010111..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/DebugCommand.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other
-{
-    /// <summary>A command which sends a debug command to the game.</summary>
-    internal class DebugCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public DebugCommand()
-            : base("debug", "Run one of the game's debug commands; for example, 'debug warp FarmHouse 1 1' warps the player to the farmhouse.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // submit command
-            string debugCommand = string.Join(" ", args);
-            string oldOutput = Game1.debugOutput;
-            Game1.game1.parseDebugInput(debugCommand);
-
-            // show result
-            monitor.Log(Game1.debugOutput != oldOutput
-                ? $"> {Game1.debugOutput}"
-                : "Sent debug command to the game, but there was no output.", LogLevel.Info);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/ShowDataFilesCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/ShowDataFilesCommand.cs
deleted file mode 100644
index 54d27185..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/ShowDataFilesCommand.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using System.Diagnostics;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other
-{
-    /// <summary>A command which shows the data files.</summary>
-    internal class ShowDataFilesCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ShowDataFilesCommand()
-            : base("show_data_files", "Opens the folder containing the save and log files.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            Process.Start(Constants.DataPath);
-            monitor.Log($"OK, opening {Constants.DataPath}.", LogLevel.Info);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/ShowGameFilesCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/ShowGameFilesCommand.cs
deleted file mode 100644
index 0257892f..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Other/ShowGameFilesCommand.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using System.Diagnostics;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Other
-{
-    /// <summary>A command which shows the game files.</summary>
-    internal class ShowGameFilesCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ShowGameFilesCommand()
-            : base("show_game_files", "Opens the game folder.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            Process.Start(Constants.ExecutionPath);
-            monitor.Log($"OK, opening {Constants.ExecutionPath}.", LogLevel.Info);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/AddCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/AddCommand.cs
deleted file mode 100644
index 263e126c..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/AddCommand.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-using System;
-using System.Linq;
-using StardewModdingAPI.Mods.ConsoleCommands.Framework.ItemData;
-using StardewValley;
-using Object = StardewValley.Object;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which adds an item to the player inventory.</summary>
-    internal class AddCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Provides methods for searching and constructing items.</summary>
-        private readonly ItemRepository Items = new ItemRepository();
-
-        /// <summary>The type names recognised by this command.</summary>
-        private readonly string[] ValidTypes = Enum.GetNames(typeof(ItemType)).Concat(new[] { "Name" }).ToArray();
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public AddCommand()
-            : base("player_add", AddCommand.GetDescription()) { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!Context.IsWorldReady)
-            {
-                monitor.Log("You need to load a save to use this command.", LogLevel.Error);
-                return;
-            }
-
-            // read arguments
-            if (!args.TryGet(0, "item type", out string type, oneOf: this.ValidTypes))
-                return;
-            if (!args.TryGetInt(2, "count", out int count, min: 1, required: false))
-                count = 1;
-            if (!args.TryGetInt(3, "quality", out int quality, min: Object.lowQuality, max: Object.bestQuality, required: false))
-                quality = Object.lowQuality;
-
-            // find matching item
-            SearchableItem match = Enum.TryParse(type, true, out ItemType itemType)
-                ? this.FindItemByID(monitor, args, itemType)
-                : this.FindItemByName(monitor, args);
-            if (match == null)
-                return;
-
-            // apply count
-            match.Item.Stack = count;
-
-            // apply quality
-            if (match.Item is Object obj)
-                obj.Quality = quality;
-            else if (match.Item is Tool tool)
-                tool.UpgradeLevel = quality;
-
-            // add to inventory
-            Game1.player.addItemByMenuIfNecessary(match.Item);
-            monitor.Log($"OK, added {match.Name} ({match.Type} #{match.ID}) to your inventory.", LogLevel.Info);
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get a matching item by its ID.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="args">The command arguments.</param>
-        /// <param name="type">The item type.</param>
-        private SearchableItem FindItemByID(IMonitor monitor, ArgumentParser args, ItemType type)
-        {
-            // read arguments
-            if (!args.TryGetInt(1, "item ID", out int id, min: 0))
-                return null;
-
-            // find matching item
-            SearchableItem item = this.Items.GetAll().FirstOrDefault(p => p.Type == type && p.ID == id);
-            if (item == null)
-                monitor.Log($"There's no {type} item with ID {id}.", LogLevel.Error);
-            return item;
-        }
-
-        /// <summary>Get a matching item by its name.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="args">The command arguments.</param>
-        private SearchableItem FindItemByName(IMonitor monitor, ArgumentParser args)
-        {
-            // read arguments
-            if (!args.TryGet(1, "item name", out string name))
-                return null;
-
-            // find matching items
-            SearchableItem[] matches = this.Items.GetAll().Where(p => p.NameContains(name)).ToArray();
-            if (!matches.Any())
-            {
-                monitor.Log($"There's no item with name '{name}'. You can use the 'list_items [name]' command to search for items.", LogLevel.Error);
-                return null;
-            }
-
-            // handle single exact match
-            SearchableItem[] exactMatches = matches.Where(p => p.NameEquivalentTo(name)).ToArray();
-            if (exactMatches.Length == 1)
-                return exactMatches[0];
-
-            // handle ambiguous results
-            string options = this.GetTableString(
-                data: matches,
-                header: new[] { "type", "name", "command" },
-                getRow: item => new[] { item.Type.ToString(), item.DisplayName, $"player_add {item.Type} {item.ID}" }
-            );
-            monitor.Log($"There's no item with name '{name}'. Do you mean one of these?\n\n{options}", LogLevel.Info);
-            return null;
-        }
-
-        /// <summary>Get the command description.</summary>
-        private static string GetDescription()
-        {
-            string[] typeValues = Enum.GetNames(typeof(ItemType));
-            return "Gives the player an item.\n"
-                + "\n"
-                + "Usage: player_add <type> <item> [count] [quality]\n"
-                + $"- type: the item type (one of {string.Join(", ", typeValues)}).\n"
-                + "- item: the item ID (use the 'list_items' command to see a list).\n"
-                + "- count (optional): how many of the item to give.\n"
-                + $"- quality (optional): one of {Object.lowQuality} (normal), {Object.medQuality} (silver), {Object.highQuality} (gold), or {Object.bestQuality} (iridium).\n"
-                + "\n"
-                + "Usage: player_add name \"<name>\" [count] [quality]\n"
-                + "- name: the item name to search (use the 'list_items' command to see a list). This will add the item immediately if it's an exact match, else show a table of matching items.\n"
-                + "- count (optional): how many of the item to give.\n"
-                + $"- quality (optional): one of {Object.lowQuality} (normal), {Object.medQuality} (silver), {Object.highQuality} (gold), or {Object.bestQuality} (iridium).\n"
-                + "\n"
-                + "These examples both add the galaxy sword to your inventory:\n"
-                + "  player_add weapon 4\n"
-                + "  player_add name \"Galaxy Sword\"";
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/ListItemTypesCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/ListItemTypesCommand.cs
deleted file mode 100644
index a835455e..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/ListItemTypesCommand.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using System.Linq;
-using StardewModdingAPI.Mods.ConsoleCommands.Framework.ItemData;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which list item types.</summary>
-    internal class ListItemTypesCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Provides methods for searching and constructing items.</summary>
-        private readonly ItemRepository Items = new ItemRepository();
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ListItemTypesCommand()
-            : base("list_item_types", "Lists item types you can filter in other commands.\n\nUsage: list_item_types") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!Context.IsWorldReady)
-            {
-                monitor.Log("You need to load a save to use this command.", LogLevel.Error);
-                return;
-            }
-
-            // handle
-            ItemType[] matches =
-                (
-                    from item in this.Items.GetAll()
-                    orderby item.Type.ToString()
-                    select item.Type
-                )
-                .Distinct()
-                .ToArray();
-            string summary = "Searching...\n";
-            if (matches.Any())
-                monitor.Log(summary + this.GetTableString(matches, new[] { "type" }, val => new[] { val.ToString() }), LogLevel.Info);
-            else
-                monitor.Log(summary + "No item types found.", LogLevel.Info);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/ListItemsCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/ListItemsCommand.cs
deleted file mode 100644
index 5b52e9a2..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/ListItemsCommand.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using StardewModdingAPI.Mods.ConsoleCommands.Framework.ItemData;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which list items available to spawn.</summary>
-    internal class ListItemsCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Provides methods for searching and constructing items.</summary>
-        private readonly ItemRepository Items = new ItemRepository();
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ListItemsCommand()
-            : base("list_items", "Lists and searches items in the game data.\n\nUsage: list_items [search]\n- search (optional): an arbitrary search string to filter by.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!Context.IsWorldReady)
-            {
-                monitor.Log("You need to load a save to use this command.", LogLevel.Error);
-                return;
-            }
-
-            // handle
-            SearchableItem[] matches =
-                (
-                    from item in this.GetItems(args.ToArray())
-                    orderby item.Type.ToString(), item.Name
-                    select item
-                )
-                .ToArray();
-            string summary = "Searching...\n";
-            if (matches.Any())
-                monitor.Log(summary + this.GetTableString(matches, new[] { "type", "name", "id" }, val => new[] { val.Type.ToString(), val.Name, val.ID.ToString() }), LogLevel.Info);
-            else
-                monitor.Log(summary + "No items found", LogLevel.Info);
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get all items which can be searched and added to the player's inventory through the console.</summary>
-        /// <param name="searchWords">The search string to find.</param>
-        private IEnumerable<SearchableItem> GetItems(string[] searchWords)
-        {
-            // normalise search term
-            searchWords = searchWords?.Where(word => !string.IsNullOrWhiteSpace(word)).ToArray();
-            if (searchWords?.Any() == false)
-                searchWords = null;
-
-            // find matches
-            return (
-                from item in this.Items.GetAll()
-                let term = $"{item.ID}|{item.Type}|{item.Name}|{item.DisplayName}"
-                where searchWords == null || searchWords.All(word => term.IndexOf(word, StringComparison.CurrentCultureIgnoreCase) != -1)
-                select item
-            );
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetColorCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetColorCommand.cs
deleted file mode 100644
index f0815ef6..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetColorCommand.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-using Microsoft.Xna.Framework;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the color of a player feature.</summary>
-    internal class SetColorCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetColorCommand()
-            : base("player_changecolor", "Sets the color of a player feature.\n\nUsage: player_changecolor <target> <color>\n- target: what to change (one of 'hair', 'eyes', or 'pants').\n- color: a color value in RGB format, like (255,255,255).") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // parse arguments
-            if (!args.TryGet(0, "target", out string target, oneOf: new[] { "hair", "eyes", "pants" }))
-                return;
-            if (!args.TryGet(1, "color", out string rawColor))
-                return;
-
-            // parse color
-            if (!this.TryParseColor(rawColor, out Color color))
-            {
-                this.LogUsageError(monitor, "Argument 1 (color) must be an RBG value like '255,150,0'.");
-                return;
-            }
-
-            // handle
-            switch (target)
-            {
-                case "hair":
-                    Game1.player.hairstyleColor.Value = color;
-                    monitor.Log("OK, your hair color is updated.", LogLevel.Info);
-                    break;
-
-                case "eyes":
-                    Game1.player.changeEyeColor(color);
-                    monitor.Log("OK, your eye color is updated.", LogLevel.Info);
-                    break;
-
-                case "pants":
-                    Game1.player.pantsColor.Value = color;
-                    monitor.Log("OK, your pants color is updated.", LogLevel.Info);
-                    break;
-            }
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Try to parse a color from a string.</summary>
-        /// <param name="input">The input string.</param>
-        /// <param name="color">The color to set.</param>
-        private bool TryParseColor(string input, out Color color)
-        {
-            string[] colorHexes = input.Split(new[] { ',' }, 3);
-            if (int.TryParse(colorHexes[0], out int r) && int.TryParse(colorHexes[1], out int g) && int.TryParse(colorHexes[2], out int b))
-            {
-                color = new Color(r, g, b);
-                return true;
-            }
-
-            color = Color.Transparent;
-            return false;
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetHealthCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetHealthCommand.cs
deleted file mode 100644
index 1abb82b5..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetHealthCommand.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the player's current health.</summary>
-    internal class SetHealthCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Whether to keep the player's health at its maximum.</summary>
-        private bool InfiniteHealth;
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>Whether the command needs to perform logic when the game updates.</summary>
-        public override bool NeedsUpdate => this.InfiniteHealth;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetHealthCommand()
-            : base("player_sethealth", "Sets the player's health.\n\nUsage: player_sethealth [value]\n- value: an integer amount, or 'inf' for infinite health.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // no-argument mode
-            if (!args.Any())
-            {
-                monitor.Log($"You currently have {(this.InfiniteHealth ? "infinite" : Game1.player.health.ToString())} health. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // handle
-            string amountStr = args[0];
-            if (amountStr == "inf")
-            {
-                this.InfiniteHealth = true;
-                monitor.Log("OK, you now have infinite health.", LogLevel.Info);
-            }
-            else
-            {
-                this.InfiniteHealth = false;
-                if (int.TryParse(amountStr, out int amount))
-                {
-                    Game1.player.health = amount;
-                    monitor.Log($"OK, you now have {Game1.player.health} health.", LogLevel.Info);
-                }
-                else
-                    this.LogArgumentNotInt(monitor);
-            }
-        }
-
-        /// <summary>Perform any logic needed on update tick.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        public override void Update(IMonitor monitor)
-        {
-            if (this.InfiniteHealth)
-                Game1.player.health = Game1.player.maxHealth;
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetImmunityCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetImmunityCommand.cs
deleted file mode 100644
index 9c66c4fe..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetImmunityCommand.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the player's current immunity.</summary>
-    internal class SetImmunityCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetImmunityCommand()
-            : base("player_setimmunity", "Sets the player's immunity.\n\nUsage: player_setimmunity [value]\n- value: an integer amount.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!args.Any())
-            {
-                monitor.Log($"You currently have {Game1.player.immunity} immunity. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // handle
-            if (args.TryGetInt(0, "amount", out int amount, min: 0))
-            {
-                Game1.player.immunity = amount;
-                monitor.Log($"OK, you now have {Game1.player.immunity} immunity.", LogLevel.Info);
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMaxHealthCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMaxHealthCommand.cs
deleted file mode 100644
index f4ae0694..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMaxHealthCommand.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the player's maximum health.</summary>
-    internal class SetMaxHealthCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetMaxHealthCommand()
-            : base("player_setmaxhealth", "Sets the player's max health.\n\nUsage: player_setmaxhealth [value]\n- value: an integer amount.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!args.Any())
-            {
-                monitor.Log($"You currently have {Game1.player.maxHealth} max health. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // handle
-            if (args.TryGetInt(0, "amount", out int amount, min: 1))
-            {
-                Game1.player.maxHealth = amount;
-                monitor.Log($"OK, you now have {Game1.player.maxHealth} max health.", LogLevel.Info);
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMaxStaminaCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMaxStaminaCommand.cs
deleted file mode 100644
index 5bce5ea3..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMaxStaminaCommand.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the player's maximum stamina.</summary>
-    internal class SetMaxStaminaCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetMaxStaminaCommand()
-            : base("player_setmaxstamina", "Sets the player's max stamina.\n\nUsage: player_setmaxstamina [value]\n- value: an integer amount.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!args.Any())
-            {
-                monitor.Log($"You currently have {Game1.player.MaxStamina} max stamina. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // handle
-            if (args.TryGetInt(0, "amount", out int amount, min: 1))
-            {
-                Game1.player.MaxStamina = amount;
-                monitor.Log($"OK, you now have {Game1.player.MaxStamina} max stamina.", LogLevel.Info);
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMoneyCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMoneyCommand.cs
deleted file mode 100644
index ad11cc66..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetMoneyCommand.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the player's current money.</summary>
-    internal class SetMoneyCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Whether to keep the player's money at a set value.</summary>
-        private bool InfiniteMoney;
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>Whether the command needs to perform logic when the game updates.</summary>
-        public override bool NeedsUpdate => this.InfiniteMoney;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetMoneyCommand()
-            : base("player_setmoney", "Sets the player's money.\n\nUsage: player_setmoney <value>\n- value: an integer amount, or 'inf' for infinite money.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!args.Any())
-            {
-                monitor.Log($"You currently have {(this.InfiniteMoney ? "infinite" : Game1.player.Money.ToString())} gold. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // handle
-            string amountStr = args[0];
-            if (amountStr == "inf")
-            {
-                this.InfiniteMoney = true;
-                monitor.Log("OK, you now have infinite money.", LogLevel.Info);
-            }
-            else
-            {
-                this.InfiniteMoney = false;
-                if (int.TryParse(amountStr, out int amount))
-                {
-                    Game1.player.Money = amount;
-                    monitor.Log($"OK, you now have {Game1.player.Money} gold.", LogLevel.Info);
-                }
-                else
-                    this.LogArgumentNotInt(monitor);
-            }
-        }
-
-        /// <summary>Perform any logic needed on update tick.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        public override void Update(IMonitor monitor)
-        {
-            if (this.InfiniteMoney)
-                Game1.player.money = 999999;
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetNameCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetNameCommand.cs
deleted file mode 100644
index e8cb0584..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetNameCommand.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the player's name.</summary>
-    internal class SetNameCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetNameCommand()
-            : base("player_setname", "Sets the player's name.\n\nUsage: player_setname <target> <name>\n- target: what to rename (one of 'player' or 'farm').\n- name: the new name to set.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // parse arguments
-            if (!args.TryGet(0, "target", out string target, oneOf: new[] { "player", "farm" }))
-                return;
-            args.TryGet(1, "name", out string name, required: false);
-
-            // handle
-            switch (target)
-            {
-                case "player":
-                    if (!string.IsNullOrWhiteSpace(name))
-                    {
-                        Game1.player.Name = args[1];
-                        monitor.Log($"OK, your name is now {Game1.player.Name}.", LogLevel.Info);
-                    }
-                    else
-                        monitor.Log($"Your name is currently '{Game1.player.Name}'. Type 'help player_setname' for usage.", LogLevel.Info);
-                    break;
-
-                case "farm":
-                    if (!string.IsNullOrWhiteSpace(name))
-                    {
-                        Game1.player.farmName.Value = args[1];
-                        monitor.Log($"OK, your farm's name is now {Game1.player.farmName}.", LogLevel.Info);
-                    }
-                    else
-                        monitor.Log($"Your farm's name is currently '{Game1.player.farmName}'. Type 'help player_setname' for usage.", LogLevel.Info);
-                    break;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetStaminaCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetStaminaCommand.cs
deleted file mode 100644
index 009cb1de..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetStaminaCommand.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits the player's current stamina.</summary>
-    internal class SetStaminaCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Whether to keep the player's stamina at its maximum.</summary>
-        private bool InfiniteStamina;
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>Whether the command needs to perform logic when the game updates.</summary>
-        public override bool NeedsUpdate => this.InfiniteStamina;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetStaminaCommand()
-            : base("player_setstamina", "Sets the player's stamina.\n\nUsage: player_setstamina [value]\n- value: an integer amount, or 'inf' for infinite stamina.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // validate
-            if (!args.Any())
-            {
-                monitor.Log($"You currently have {(this.InfiniteStamina ? "infinite" : Game1.player.Stamina.ToString())} stamina. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // handle
-            string amountStr = args[0];
-            if (amountStr == "inf")
-            {
-                this.InfiniteStamina = true;
-                monitor.Log("OK, you now have infinite stamina.", LogLevel.Info);
-            }
-            else
-            {
-                this.InfiniteStamina = false;
-                if (int.TryParse(amountStr, out int amount))
-                {
-                    Game1.player.Stamina = amount;
-                    monitor.Log($"OK, you now have {Game1.player.Stamina} stamina.", LogLevel.Info);
-                }
-                else
-                    this.LogArgumentNotInt(monitor);
-            }
-        }
-
-        /// <summary>Perform any logic needed on update tick.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        public override void Update(IMonitor monitor)
-        {
-            if (this.InfiniteStamina)
-                Game1.player.stamina = Game1.player.MaxStamina;
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetStyleCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetStyleCommand.cs
deleted file mode 100644
index 31f4107d..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/Player/SetStyleCommand.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.Player
-{
-    /// <summary>A command which edits a player style.</summary>
-    internal class SetStyleCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetStyleCommand()
-            : base("player_changestyle", "Sets the style of a player feature.\n\nUsage: player_changestyle <target> <value>.\n- target: what to change (one of 'hair', 'shirt', 'skin', 'acc', 'shoe', 'swim', or 'gender').\n- value: the integer style ID.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // parse arguments
-            if (!args.TryGet(0, "target", out string target, oneOf: new[] { "hair", "shirt", "acc", "skin", "shoe", "swim", "gender" }))
-                return;
-            if (!args.TryGetInt(1, "style ID", out int styleID))
-                return;
-
-            // handle
-            switch (target)
-            {
-                case "hair":
-                    Game1.player.changeHairStyle(styleID);
-                    monitor.Log("OK, your hair style is updated.", LogLevel.Info);
-                    break;
-
-                case "shirt":
-                    Game1.player.changeShirt(styleID);
-                    monitor.Log("OK, your shirt style is updated.", LogLevel.Info);
-                    break;
-
-                case "acc":
-                    Game1.player.changeAccessory(styleID);
-                    monitor.Log("OK, your accessory style is updated.", LogLevel.Info);
-                    break;
-
-                case "skin":
-                    Game1.player.changeSkinColor(styleID);
-                    monitor.Log("OK, your skin color is updated.", LogLevel.Info);
-                    break;
-
-                case "shoe":
-                    Game1.player.changeShoeColor(styleID);
-                    monitor.Log("OK, your shoe style is updated.", LogLevel.Info);
-                    break;
-
-                case "swim":
-                    switch (styleID)
-                    {
-                        case 0:
-                            Game1.player.changeOutOfSwimSuit();
-                            monitor.Log("OK, you're no longer in your swimming suit.", LogLevel.Info);
-                            break;
-                        case 1:
-                            Game1.player.changeIntoSwimsuit();
-                            monitor.Log("OK, you're now in your swimming suit.", LogLevel.Info);
-                            break;
-                        default:
-                            this.LogUsageError(monitor, "The swim value should be 0 (no swimming suit) or 1 (swimming suit).");
-                            break;
-                    }
-                    break;
-
-                case "gender":
-                    switch (styleID)
-                    {
-                        case 0:
-                            Game1.player.changeGender(true);
-                            monitor.Log("OK, you're now male.", LogLevel.Info);
-                            break;
-                        case 1:
-                            Game1.player.changeGender(false);
-                            monitor.Log("OK, you're now female.", LogLevel.Info);
-                            break;
-                        default:
-                            this.LogUsageError(monitor, "The gender value should be 0 (male) or 1 (female).");
-                            break;
-                    }
-                    break;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/TrainerCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/TrainerCommand.cs
deleted file mode 100644
index 466b8f6e..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/TrainerCommand.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands
-{
-    /// <summary>The base implementation for a trainer command.</summary>
-    internal abstract class TrainerCommand : ITrainerCommand
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The command name the user must type.</summary>
-        public string Name { get; }
-
-        /// <summary>The command description.</summary>
-        public string Description { get; }
-
-        /// <summary>Whether the command needs to perform logic when the game updates.</summary>
-        public virtual bool NeedsUpdate { get; } = false;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public abstract void Handle(IMonitor monitor, string command, ArgumentParser args);
-
-        /// <summary>Perform any logic needed on update tick.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        public virtual void Update(IMonitor monitor) { }
-
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="name">The command name the user must type.</param>
-        /// <param name="description">The command description.</param>
-        protected TrainerCommand(string name, string description)
-        {
-            this.Name = name;
-            this.Description = description;
-        }
-
-        /// <summary>Log an error indicating incorrect usage.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="error">A sentence explaining the problem.</param>
-        protected void LogUsageError(IMonitor monitor, string error)
-        {
-            monitor.Log($"{error} Type 'help {this.Name}' for usage.", LogLevel.Error);
-        }
-
-        /// <summary>Log an error indicating a value must be an integer.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        protected void LogArgumentNotInt(IMonitor monitor)
-        {
-            this.LogUsageError(monitor, "The value must be a whole number.");
-        }
-
-        /// <summary>Get an ASCII table to show tabular data in the console.</summary>
-        /// <typeparam name="T">The data type.</typeparam>
-        /// <param name="data">The data to display.</param>
-        /// <param name="header">The table header.</param>
-        /// <param name="getRow">Returns a set of fields for a data value.</param>
-        protected string GetTableString<T>(IEnumerable<T> data, string[] header, Func<T, string[]> getRow)
-        {
-            // get table data
-            int[] widths = header.Select(p => p.Length).ToArray();
-            string[][] rows = data
-                .Select(item =>
-                {
-                    string[] fields = getRow(item);
-                    if (fields.Length != widths.Length)
-                        throw new InvalidOperationException($"Expected {widths.Length} columns, but found {fields.Length}: {string.Join(", ", fields)}");
-
-                    for (int i = 0; i < fields.Length; i++)
-                        widths[i] = Math.Max(widths[i], fields[i].Length);
-
-                    return fields;
-                })
-                .ToArray();
-
-            // render fields
-            List<string[]> lines = new List<string[]>(rows.Length + 2)
-            {
-                header,
-                header.Select((value, i) => "".PadRight(widths[i], '-')).ToArray()
-            };
-            lines.AddRange(rows);
-
-            return string.Join(
-                Environment.NewLine,
-                lines.Select(line => string.Join(" | ", line.Select((field, i) => field.PadRight(widths[i], ' ')).ToArray())
-                )
-            );
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/ClearCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/ClearCommand.cs
deleted file mode 100644
index e9545575..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/ClearCommand.cs
+++ /dev/null
@@ -1,262 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using StardewValley;
-using StardewValley.Locations;
-using StardewValley.Objects;
-using StardewValley.TerrainFeatures;
-using SObject = StardewValley.Object;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which clears in-game objects.</summary>
-    internal class ClearCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The valid types that can be cleared.</summary>
-        private readonly string[] ValidTypes = { "crops", "debris", "fruit-trees", "grass", "trees", "everything" };
-
-        /// <summary>The resource clump IDs to consider debris.</summary>
-        private readonly int[] DebrisClumps = { ResourceClump.stumpIndex, ResourceClump.hollowLogIndex, ResourceClump.meteoriteIndex, ResourceClump.boulderIndex };
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ClearCommand()
-            : base(
-                name: "world_clear",
-                description: "Clears in-game entities in a given location.\n\n"
-                    + "Usage: world_clear <location> <object type>\n"
-                    + "- location: the location name for which to clear objects (like Farm), or 'current' for the current location.\n"
-                    + " - object type: the type of object clear. You can specify 'crops', 'debris' (stones/twigs/weeds and dead crops), 'grass', and 'trees' / 'fruit-trees'. You can also specify 'everything', which includes things not removed by the other types (like furniture or resource clumps)."
-            )
-        { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // check context
-            if (!Context.IsWorldReady)
-            {
-                monitor.Log("You need to load a save to use this command.", LogLevel.Error);
-                return;
-            }
-
-            // parse arguments
-            if (!args.TryGet(0, "location", out string locationName, required: true))
-                return;
-            if (!args.TryGet(1, "object type", out string type, required: true, oneOf: this.ValidTypes))
-                return;
-
-            // get target location
-            GameLocation location = Game1.locations.FirstOrDefault(p => p.Name != null && p.Name.Equals(locationName, StringComparison.InvariantCultureIgnoreCase));
-            if (location == null && locationName == "current")
-                location = Game1.currentLocation;
-            if (location == null)
-            {
-                string[] locationNames = (from loc in Game1.locations where !string.IsNullOrWhiteSpace(loc.Name) orderby loc.Name select loc.Name).ToArray();
-                monitor.Log($"Could not find a location with that name. Must be one of [{string.Join(", ", locationNames)}].", LogLevel.Error);
-                return;
-            }
-
-            // apply
-            switch (type)
-            {
-                case "crops":
-                    {
-                        int removed =
-                            this.RemoveTerrainFeatures(location, p => p is HoeDirt)
-                            + this.RemoveResourceClumps(location, p => p is GiantCrop);
-                        monitor.Log($"Done! Removed {removed} entities from {location.Name}.", LogLevel.Info);
-                        break;
-                    }
-
-                case "debris":
-                    {
-                        int removed = 0;
-                        foreach (var pair in location.terrainFeatures.Pairs.ToArray())
-                        {
-                            TerrainFeature feature = pair.Value;
-                            if (feature is HoeDirt dirt && dirt.crop?.dead == true)
-                            {
-                                dirt.crop = null;
-                                removed++;
-                            }
-                        }
-
-                        removed +=
-                            this.RemoveObjects(location, obj =>
-                                !(obj is Chest)
-                                && (
-                                    obj.Name == "Weeds"
-                                    || obj.Name == "Stone"
-                                    || (obj.ParentSheetIndex == 294 || obj.ParentSheetIndex == 295)
-                                )
-                            )
-                            + this.RemoveResourceClumps(location, clump => this.DebrisClumps.Contains(clump.parentSheetIndex.Value));
-
-                        monitor.Log($"Done! Removed {removed} entities from {location.Name}.", LogLevel.Info);
-                        break;
-                    }
-
-                case "fruit-trees":
-                    {
-                        int removed = this.RemoveTerrainFeatures(location, feature => feature is FruitTree);
-                        monitor.Log($"Done! Removed {removed} entities from {location.Name}.", LogLevel.Info);
-                        break;
-                    }
-
-                case "grass":
-                    {
-                        int removed = this.RemoveTerrainFeatures(location, feature => feature is Grass);
-                        monitor.Log($"Done! Removed {removed} entities from {location.Name}.", LogLevel.Info);
-                        break;
-                    }
-
-                case "trees":
-                    {
-                        int removed = this.RemoveTerrainFeatures(location, feature => feature is Tree);
-                        monitor.Log($"Done! Removed {removed} entities from {location.Name}.", LogLevel.Info);
-                        break;
-                    }
-
-                case "everything":
-                    {
-                        int removed =
-                            this.RemoveFurniture(location, p => true)
-                            + this.RemoveObjects(location, p => true)
-                            + this.RemoveTerrainFeatures(location, p => true)
-                            + this.RemoveLargeTerrainFeatures(location, p => true)
-                            + this.RemoveResourceClumps(location, p => true);
-                        monitor.Log($"Done! Removed {removed} entities from {location.Name}.", LogLevel.Info);
-                        break;
-                    }
-
-                default:
-                    monitor.Log($"Unknown type '{type}'. Must be one [{string.Join(", ", this.ValidTypes)}].", LogLevel.Error);
-                    break;
-            }
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Remove objects from a location matching a lambda.</summary>
-        /// <param name="location">The location to search.</param>
-        /// <param name="shouldRemove">Whether an entity should be removed.</param>
-        /// <returns>Returns the number of removed entities.</returns>
-        private int RemoveObjects(GameLocation location, Func<SObject, bool> shouldRemove)
-        {
-            int removed = 0;
-
-            foreach (var pair in location.Objects.Pairs.ToArray())
-            {
-                if (shouldRemove(pair.Value))
-                {
-                    location.Objects.Remove(pair.Key);
-                    removed++;
-                }
-            }
-
-            return removed;
-        }
-
-        /// <summary>Remove terrain features from a location matching a lambda.</summary>
-        /// <param name="location">The location to search.</param>
-        /// <param name="shouldRemove">Whether an entity should be removed.</param>
-        /// <returns>Returns the number of removed entities.</returns>
-        private int RemoveTerrainFeatures(GameLocation location, Func<TerrainFeature, bool> shouldRemove)
-        {
-            int removed = 0;
-
-            foreach (var pair in location.terrainFeatures.Pairs.ToArray())
-            {
-                if (shouldRemove(pair.Value))
-                {
-                    location.terrainFeatures.Remove(pair.Key);
-                    removed++;
-                }
-            }
-
-            return removed;
-        }
-
-        /// <summary>Remove large terrain features from a location matching a lambda.</summary>
-        /// <param name="location">The location to search.</param>
-        /// <param name="shouldRemove">Whether an entity should be removed.</param>
-        /// <returns>Returns the number of removed entities.</returns>
-        private int RemoveLargeTerrainFeatures(GameLocation location, Func<LargeTerrainFeature, bool> shouldRemove)
-        {
-            int removed = 0;
-
-            foreach (LargeTerrainFeature feature in location.largeTerrainFeatures.ToArray())
-            {
-                if (shouldRemove(feature))
-                {
-                    location.largeTerrainFeatures.Remove(feature);
-                    removed++;
-                }
-            }
-
-            return removed;
-        }
-
-        /// <summary>Remove resource clumps from a location matching a lambda.</summary>
-        /// <param name="location">The location to search.</param>
-        /// <param name="shouldRemove">Whether an entity should be removed.</param>
-        /// <returns>Returns the number of removed entities.</returns>
-        private int RemoveResourceClumps(GameLocation location, Func<ResourceClump, bool> shouldRemove)
-        {
-            int removed = 0;
-
-            // get resource clumps
-            IList<ResourceClump> resourceClumps =
-                (location as Farm)?.resourceClumps
-                ?? (IList<ResourceClump>)(location as Woods)?.stumps
-                ?? new List<ResourceClump>();
-
-            // remove matching clumps
-            foreach (var clump in resourceClumps.ToArray())
-            {
-                if (shouldRemove(clump))
-                {
-                    resourceClumps.Remove(clump);
-                    removed++;
-                }
-            }
-
-            return removed;
-        }
-
-        /// <summary>Remove furniture from a location matching a lambda.</summary>
-        /// <param name="location">The location to search.</param>
-        /// <param name="shouldRemove">Whether an entity should be removed.</param>
-        /// <returns>Returns the number of removed entities.</returns>
-        private int RemoveFurniture(GameLocation location, Func<Furniture, bool> shouldRemove)
-        {
-            int removed = 0;
-
-            if (location is DecoratableLocation decoratableLocation)
-            {
-                foreach (Furniture furniture in decoratableLocation.furniture.ToArray())
-                {
-                    if (shouldRemove(furniture))
-                    {
-                        decoratableLocation.furniture.Remove(furniture);
-                        removed++;
-                    }
-                }
-            }
-
-            return removed;
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/DownMineLevelCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/DownMineLevelCommand.cs
deleted file mode 100644
index 2cec0fd3..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/DownMineLevelCommand.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using StardewValley;
-using StardewValley.Locations;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which moves the player to the next mine level.</summary>
-    internal class DownMineLevelCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public DownMineLevelCommand()
-            : base("world_downminelevel", "Goes down one mine level.") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            int level = (Game1.currentLocation as MineShaft)?.mineLevel ?? 0;
-            monitor.Log($"OK, warping you to mine level {level + 1}.", LogLevel.Info);
-            Game1.enterMine(level + 1);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/FreezeTimeCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/FreezeTimeCommand.cs
deleted file mode 100644
index 6a7ab162..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/FreezeTimeCommand.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which freezes the current time.</summary>
-    internal class FreezeTimeCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The time of day at which to freeze time.</summary>
-        internal static int FrozenTime;
-
-        /// <summary>Whether to freeze time.</summary>
-        private bool FreezeTime;
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>Whether the command needs to perform logic when the game updates.</summary>
-        public override bool NeedsUpdate => this.FreezeTime;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public FreezeTimeCommand()
-            : base("world_freezetime", "Freezes or resumes time.\n\nUsage: world_freezetime [value]\n- value: one of 0 (resume), 1 (freeze), or blank (toggle).") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            if (args.Any())
-            {
-                // parse arguments
-                if (!args.TryGetInt(0, "value", out int value, min: 0, max: 1))
-                    return;
-
-                // handle
-                this.FreezeTime = value == 1;
-                FreezeTimeCommand.FrozenTime = Game1.timeOfDay;
-                monitor.Log($"OK, time is now {(this.FreezeTime ? "frozen" : "resumed")}.", LogLevel.Info);
-            }
-            else
-            {
-                this.FreezeTime = !this.FreezeTime;
-                FreezeTimeCommand.FrozenTime = Game1.timeOfDay;
-                monitor.Log($"OK, time is now {(this.FreezeTime ? "frozen" : "resumed")}.", LogLevel.Info);
-            }
-        }
-
-        /// <summary>Perform any logic needed on update tick.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        public override void Update(IMonitor monitor)
-        {
-            if (this.FreezeTime)
-                Game1.timeOfDay = FreezeTimeCommand.FrozenTime;
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetDayCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetDayCommand.cs
deleted file mode 100644
index 8d6bd759..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetDayCommand.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which sets the current day.</summary>
-    internal class SetDayCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetDayCommand()
-            : base("world_setday", "Sets the day to the specified value.\n\nUsage: world_setday <value>.\n- value: the target day (a number from 1 to 28).") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // no-argument mode
-            if (!args.Any())
-            {
-                monitor.Log($"The current date is {Game1.currentSeason} {Game1.dayOfMonth}. Specify a value to change the day.", LogLevel.Info);
-                return;
-            }
-
-            // parse arguments
-            if (!args.TryGetInt(0, "day", out int day, min: 1, max: 28))
-                return;
-
-            // handle
-            Game1.dayOfMonth = day;
-            monitor.Log($"OK, the date is now {Game1.currentSeason} {Game1.dayOfMonth}.", LogLevel.Info);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetMineLevelCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetMineLevelCommand.cs
deleted file mode 100644
index b4f6d5b3..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetMineLevelCommand.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using System;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which moves the player to the given mine level.</summary>
-    internal class SetMineLevelCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetMineLevelCommand()
-            : base("world_setminelevel", "Sets the mine level?\n\nUsage: world_setminelevel <value>\n- value: The target level (a number starting at 1).") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // parse arguments
-            if (!args.TryGetInt(0, "mine level", out int level, min: 1))
-                return;
-
-            // handle
-            level = Math.Max(1, level);
-            monitor.Log($"OK, warping you to mine level {level}.", LogLevel.Info);
-            Game1.enterMine(level);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetSeasonCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetSeasonCommand.cs
deleted file mode 100644
index 0615afe7..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetSeasonCommand.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which sets the current season.</summary>
-    internal class SetSeasonCommand : TrainerCommand
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The valid season names.</summary>
-        private readonly string[] ValidSeasons = { "winter", "spring", "summer", "fall" };
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetSeasonCommand()
-            : base("world_setseason", "Sets the season to the specified value.\n\nUsage: world_setseason <season>\n- season: the target season (one of 'spring', 'summer', 'fall', 'winter').") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // no-argument mode
-            if (!args.Any())
-            {
-                monitor.Log($"The current season is {Game1.currentSeason}. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // parse arguments
-            if (!args.TryGet(0, "season", out string season, oneOf: this.ValidSeasons))
-                return;
-
-            // handle
-            Game1.currentSeason = season.ToLower();
-            Game1.setGraphicsForSeason();
-            monitor.Log($"OK, the date is now {Game1.currentSeason} {Game1.dayOfMonth}.", LogLevel.Info);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetTimeCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetTimeCommand.cs
deleted file mode 100644
index a6075013..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetTimeCommand.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-using System;
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which sets the current time.</summary>
-    internal class SetTimeCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetTimeCommand()
-            : base("world_settime", "Sets the time to the specified value.\n\nUsage: world_settime <value>\n- value: the target time in military time (like 0600 for 6am and 1800 for 6pm).") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // no-argument mode
-            if (!args.Any())
-            {
-                monitor.Log($"The current time is {Game1.timeOfDay}. Specify a value to change it.", LogLevel.Info);
-                return;
-            }
-
-            // parse arguments
-            if (!args.TryGetInt(0, "time", out int time, min: 600, max: 2600))
-                return;
-
-            // handle
-            this.SafelySetTime(time);
-            FreezeTimeCommand.FrozenTime = Game1.timeOfDay;
-            monitor.Log($"OK, the time is now {Game1.timeOfDay.ToString().PadLeft(4, '0')}.", LogLevel.Info);
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Safely transition to the given time, allowing NPCs to update their schedule.</summary>
-        /// <param name="time">The time of day.</param>
-        private void SafelySetTime(int time)
-        {
-            // define conversion between game time and TimeSpan
-            TimeSpan ToTimeSpan(int value) => new TimeSpan(0, value / 100, value % 100, 0);
-            int FromTimeSpan(TimeSpan span) => (span.Hours * 100) + span.Minutes;
-
-            // transition to new time
-            int intervals = (int)((ToTimeSpan(time) - ToTimeSpan(Game1.timeOfDay)).TotalMinutes / 10);
-            if (intervals > 0)
-            {
-                for (int i = 0; i < intervals; i++)
-                    Game1.performTenMinuteClockUpdate();
-            }
-            else if (intervals < 0)
-            {
-                for (int i = 0; i > intervals; i--)
-                {
-                    Game1.timeOfDay = FromTimeSpan(ToTimeSpan(Game1.timeOfDay).Subtract(TimeSpan.FromMinutes(20))); // offset 20 mins so game updates to next interval
-                    Game1.performTenMinuteClockUpdate();
-                }
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetYearCommand.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetYearCommand.cs
deleted file mode 100644
index 66abd6dc..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/Commands/World/SetYearCommand.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System.Linq;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands.World
-{
-    /// <summary>A command which sets the current year.</summary>
-    internal class SetYearCommand : TrainerCommand
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public SetYearCommand()
-            : base("world_setyear", "Sets the year to the specified value.\n\nUsage: world_setyear <year>\n- year: the target year (a number starting from 1).") { }
-
-        /// <summary>Handle the command.</summary>
-        /// <param name="monitor">Writes messages to the console and log file.</param>
-        /// <param name="command">The command name.</param>
-        /// <param name="args">The command arguments.</param>
-        public override void Handle(IMonitor monitor, string command, ArgumentParser args)
-        {
-            // no-argument mode
-            if (!args.Any())
-            {
-                monitor.Log($"The current year is {Game1.year}. Specify a value to change the year.", LogLevel.Info);
-                return;
-            }
-
-            // parse arguments
-            if (!args.TryGetInt(0, "year", out int year, min: 1))
-                return;
-
-            // handle
-            Game1.year = year;
-            monitor.Log($"OK, the year is now {Game1.year}.", LogLevel.Info);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/ItemData/ItemType.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/ItemData/ItemType.cs
deleted file mode 100644
index 7ee662d0..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/ItemData/ItemType.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.ItemData
-{
-    /// <summary>An item type that can be searched and added to the player through the console.</summary>
-    internal enum ItemType
-    {
-        /// <summary>A big craftable object in <see cref="StardewValley.Game1.bigCraftablesInformation"/></summary>
-        BigCraftable,
-
-        /// <summary>A <see cref="Boots"/> item.</summary>
-        Boots,
-
-        /// <summary>A <see cref="Wallpaper"/> flooring item.</summary>
-        Flooring,
-
-        /// <summary>A <see cref="Furniture"/> item.</summary>
-        Furniture,
-
-        /// <summary>A <see cref="Hat"/> item.</summary>
-        Hat,
-
-        /// <summary>Any object in <see cref="StardewValley.Game1.objectInformation"/> (except rings).</summary>
-        Object,
-
-        /// <summary>A <see cref="Ring"/> item.</summary>
-        Ring,
-
-        /// <summary>A <see cref="Tool"/> tool.</summary>
-        Tool,
-
-        /// <summary>A <see cref="Wallpaper"/> wall item.</summary>
-        Wallpaper,
-
-        /// <summary>A <see cref="StardewValley.Tools.MeleeWeapon"/> or <see cref="StardewValley.Tools.Slingshot"/> item.</summary>
-        Weapon
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/ItemData/SearchableItem.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/ItemData/SearchableItem.cs
deleted file mode 100644
index b618a308..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/ItemData/SearchableItem.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-using System;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework.ItemData
-{
-    /// <summary>A game item with metadata.</summary>
-    internal class SearchableItem
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The item type.</summary>
-        public ItemType Type { get; }
-
-        /// <summary>The item instance.</summary>
-        public Item Item { get; }
-
-        /// <summary>The item's unique ID for its type.</summary>
-        public int ID { get; }
-
-        /// <summary>The item's default name.</summary>
-        public string Name => this.Item.Name;
-
-        /// <summary>The item's display name for the current language.</summary>
-        public string DisplayName => this.Item.DisplayName;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="type">The item type.</param>
-        /// <param name="id">The unique ID (if different from the item's parent sheet index).</param>
-        /// <param name="item">The item instance.</param>
-        public SearchableItem(ItemType type, int id, Item item)
-        {
-            this.Type = type;
-            this.ID = id;
-            this.Item = item;
-        }
-
-        /// <summary>Get whether the item name contains a case-insensitive substring.</summary>
-        /// <param name="substring">The substring to find.</param>
-        public bool NameContains(string substring)
-        {
-            return
-                this.Name.IndexOf(substring, StringComparison.InvariantCultureIgnoreCase) != -1
-                || this.DisplayName.IndexOf(substring, StringComparison.InvariantCultureIgnoreCase) != -1;
-        }
-
-        /// <summary>Get whether the item name is exactly equal to a case-insensitive string.</summary>
-        /// <param name="name">The substring to find.</param>
-        public bool NameEquivalentTo(string name)
-        {
-            return
-                this.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)
-                || this.DisplayName.Equals(name, StringComparison.InvariantCultureIgnoreCase);
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Framework/ItemRepository.cs b/src/SMAPI.Mods.ConsoleCommands/Framework/ItemRepository.cs
deleted file mode 100644
index fc631826..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Framework/ItemRepository.cs
+++ /dev/null
@@ -1,193 +0,0 @@
-using System.Collections.Generic;
-using Microsoft.Xna.Framework;
-using StardewModdingAPI.Mods.ConsoleCommands.Framework.ItemData;
-using StardewValley;
-using StardewValley.Objects;
-using StardewValley.Tools;
-using SObject = StardewValley.Object;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands.Framework
-{
-    /// <summary>Provides methods for searching and constructing items.</summary>
-    internal class ItemRepository
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The custom ID offset for items don't have a unique ID in the game.</summary>
-        private readonly int CustomIDOffset = 1000;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Get all spawnable items.</summary>
-        public IEnumerable<SearchableItem> GetAll()
-        {
-            // get tools
-            yield return new SearchableItem(ItemType.Tool, ToolFactory.axe, ToolFactory.getToolFromDescription(ToolFactory.axe, 0));
-            yield return new SearchableItem(ItemType.Tool, ToolFactory.hoe, ToolFactory.getToolFromDescription(ToolFactory.hoe, 0));
-            yield return new SearchableItem(ItemType.Tool, ToolFactory.pickAxe, ToolFactory.getToolFromDescription(ToolFactory.pickAxe, 0));
-            yield return new SearchableItem(ItemType.Tool, ToolFactory.wateringCan, ToolFactory.getToolFromDescription(ToolFactory.wateringCan, 0));
-            yield return new SearchableItem(ItemType.Tool, ToolFactory.fishingRod, ToolFactory.getToolFromDescription(ToolFactory.fishingRod, 0));
-            yield return new SearchableItem(ItemType.Tool, this.CustomIDOffset, new MilkPail()); // these don't have any sort of ID, so we'll just assign some arbitrary ones
-            yield return new SearchableItem(ItemType.Tool, this.CustomIDOffset + 1, new Shears());
-            yield return new SearchableItem(ItemType.Tool, this.CustomIDOffset + 2, new Pan());
-            yield return new SearchableItem(ItemType.Tool, this.CustomIDOffset + 3, new Wand());
-
-            // wallpapers
-            for (int id = 0; id < 112; id++)
-                yield return new SearchableItem(ItemType.Wallpaper, id, new Wallpaper(id) { Category = SObject.furnitureCategory });
-
-            // flooring
-            for (int id = 0; id < 40; id++)
-                yield return new SearchableItem(ItemType.Flooring, id, new Wallpaper(id, isFloor: true) { Category = SObject.furnitureCategory });
-
-            // equipment
-            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\Boots").Keys)
-                yield return new SearchableItem(ItemType.Boots, id, new Boots(id));
-            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\hats").Keys)
-                yield return new SearchableItem(ItemType.Hat, id, new Hat(id));
-            foreach (int id in Game1.objectInformation.Keys)
-            {
-                if (id >= Ring.ringLowerIndexRange && id <= Ring.ringUpperIndexRange)
-                    yield return new SearchableItem(ItemType.Ring, id, new Ring(id));
-            }
-
-            // weapons
-            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\weapons").Keys)
-            {
-                Item weapon = (id >= 32 && id <= 34)
-                    ? (Item)new Slingshot(id)
-                    : new MeleeWeapon(id);
-                yield return new SearchableItem(ItemType.Weapon, id, weapon);
-            }
-
-            // furniture
-            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\Furniture").Keys)
-            {
-                if (id == 1466 || id == 1468)
-                    yield return new SearchableItem(ItemType.Furniture, id, new TV(id, Vector2.Zero));
-                else
-                    yield return new SearchableItem(ItemType.Furniture, id, new Furniture(id, Vector2.Zero));
-            }
-
-            // craftables
-            foreach (int id in Game1.bigCraftablesInformation.Keys)
-                yield return new SearchableItem(ItemType.BigCraftable, id, new SObject(Vector2.Zero, id));
-
-            // secret notes
-            foreach (int id in Game1.content.Load<Dictionary<int, string>>("Data\\SecretNotes").Keys)
-            {
-                SObject note = new SObject(79, 1);
-                note.name = $"{note.name} #{id}";
-                yield return new SearchableItem(ItemType.Object, this.CustomIDOffset + id, note);
-            }
-
-            // objects
-            foreach (int id in Game1.objectInformation.Keys)
-            {
-                if (id == 79)
-                    continue; // secret note handled above
-                if (id >= Ring.ringLowerIndexRange && id <= Ring.ringUpperIndexRange)
-                    continue; // handled separated
-
-                SObject item = new SObject(id, 1);
-                yield return new SearchableItem(ItemType.Object, id, item);
-
-                // fruit products
-                if (item.Category == SObject.FruitsCategory)
-                {
-                    // wine
-                    SObject wine = new SObject(348, 1)
-                    {
-                        Name = $"{item.Name} Wine",
-                        Price = item.Price * 3
-                    };
-                    wine.preserve.Value = SObject.PreserveType.Wine;
-                    wine.preservedParentSheetIndex.Value = item.ParentSheetIndex;
-                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 2 + id, wine);
-
-                    // jelly
-                    SObject jelly = new SObject(344, 1)
-                    {
-                        Name = $"{item.Name} Jelly",
-                        Price = 50 + item.Price * 2
-                    };
-                    jelly.preserve.Value = SObject.PreserveType.Jelly;
-                    jelly.preservedParentSheetIndex.Value = item.ParentSheetIndex;
-                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 3 + id, jelly);
-                }
-
-                // vegetable products
-                else if (item.Category == SObject.VegetableCategory)
-                {
-                    // juice
-                    SObject juice = new SObject(350, 1)
-                    {
-                        Name = $"{item.Name} Juice",
-                        Price = (int)(item.Price * 2.25d)
-                    };
-                    juice.preserve.Value = SObject.PreserveType.Juice;
-                    juice.preservedParentSheetIndex.Value = item.ParentSheetIndex;
-                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 4 + id, juice);
-
-                    // pickled
-                    SObject pickled = new SObject(342, 1)
-                    {
-                        Name = $"Pickled {item.Name}",
-                        Price = 50 + item.Price * 2
-                    };
-                    pickled.preserve.Value = SObject.PreserveType.Pickle;
-                    pickled.preservedParentSheetIndex.Value = item.ParentSheetIndex;
-                    yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 5 + id, pickled);
-                }
-
-                // flower honey
-                else if (item.Category == SObject.flowersCategory)
-                {
-                    // get honey type
-                    SObject.HoneyType? type = null;
-                    switch (item.ParentSheetIndex)
-                    {
-                        case 376:
-                            type = SObject.HoneyType.Poppy;
-                            break;
-                        case 591:
-                            type = SObject.HoneyType.Tulip;
-                            break;
-                        case 593:
-                            type = SObject.HoneyType.SummerSpangle;
-                            break;
-                        case 595:
-                            type = SObject.HoneyType.FairyRose;
-                            break;
-                        case 597:
-                            type = SObject.HoneyType.BlueJazz;
-                            break;
-                        case 421: // sunflower standing in for all other flowers
-                            type = SObject.HoneyType.Wild;
-                            break;
-                    }
-
-                    // yield honey
-                    if (type != null)
-                    {
-                        SObject honey = new SObject(Vector2.Zero, 340, item.Name + " Honey", false, true, false, false)
-                        {
-                            Name = "Wild Honey"
-                        };
-                        honey.honeyType.Value = type;
-
-                        if (type != SObject.HoneyType.Wild)
-                        {
-                            honey.Name = $"{item.Name} Honey";
-                            honey.Price += item.Price * 2;
-                        }
-                        yield return new SearchableItem(ItemType.Object, this.CustomIDOffset * 5 + id, honey);
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/ModEntry.cs b/src/SMAPI.Mods.ConsoleCommands/ModEntry.cs
deleted file mode 100644
index 4807c46d..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/ModEntry.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using StardewModdingAPI.Mods.ConsoleCommands.Framework.Commands;
-
-namespace StardewModdingAPI.Mods.ConsoleCommands
-{
-    /// <summary>The main entry point for the mod.</summary>
-    public class ModEntry : Mod
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The commands to handle.</summary>
-        private ITrainerCommand[] Commands;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>The mod entry point, called after the mod is first loaded.</summary>
-        /// <param name="helper">Provides simplified APIs for writing mods.</param>
-        public override void Entry(IModHelper helper)
-        {
-            // register commands
-            this.Commands = this.ScanForCommands().ToArray();
-            foreach (ITrainerCommand command in this.Commands)
-                helper.ConsoleCommands.Add(command.Name, command.Description, (name, args) => this.HandleCommand(command, name, args));
-
-            // hook events
-            helper.Events.GameLoop.UpdateTicked += this.OnUpdateTicked;
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>The method invoked when the game updates its state.</summary>
-        /// <param name="sender">The event sender.</param>
-        /// <param name="e">The event arguments.</param>
-        private void OnUpdateTicked(object sender, EventArgs e)
-        {
-            if (!Context.IsWorldReady)
-                return;
-
-            foreach (ITrainerCommand command in this.Commands)
-            {
-                if (command.NeedsUpdate)
-                    command.Update(this.Monitor);
-            }
-        }
-
-        /// <summary>Handle a console command.</summary>
-        /// <param name="command">The command to invoke.</param>
-        /// <param name="commandName">The command name specified by the user.</param>
-        /// <param name="args">The command arguments.</param>
-        private void HandleCommand(ITrainerCommand command, string commandName, string[] args)
-        {
-            ArgumentParser argParser = new ArgumentParser(commandName, args, this.Monitor);
-            command.Handle(this.Monitor, commandName, argParser);
-        }
-
-        /// <summary>Find all commands in the assembly.</summary>
-        private IEnumerable<ITrainerCommand> ScanForCommands()
-        {
-            return (
-                from type in this.GetType().Assembly.GetTypes()
-                where !type.IsAbstract && typeof(ITrainerCommand).IsAssignableFrom(type)
-                select (ITrainerCommand)Activator.CreateInstance(type)
-            );
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.ConsoleCommands/Properties/AssemblyInfo.cs b/src/SMAPI.Mods.ConsoleCommands/Properties/AssemblyInfo.cs
deleted file mode 100644
index 86653141..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("SMAPI.Mods.ConsoleCommands")]
-[assembly: AssemblyDescription("")]
diff --git a/src/SMAPI.Mods.ConsoleCommands/StardewModdingAPI.Mods.ConsoleCommands.csproj b/src/SMAPI.Mods.ConsoleCommands/StardewModdingAPI.Mods.ConsoleCommands.csproj
deleted file mode 100644
index 2c958dbc..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/StardewModdingAPI.Mods.ConsoleCommands.csproj
+++ /dev/null
@@ -1,93 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
-    <ProjectGuid>{28480467-1A48-46A7-99F8-236D95225359}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>StardewModdingAPI.Mods.ConsoleCommands</RootNamespace>
-    <AssemblyName>ConsoleCommands</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>$(SolutionDir)\..\bin\Debug\Mods\ConsoleCommands\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <PlatformTarget>x86</PlatformTarget>
-    <Prefer32Bit>false</Prefer32Bit>
-    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>$(SolutionDir)\..\bin\Release\Mods\ConsoleCommands\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <Prefer32Bit>false</Prefer32Bit>
-    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>
-    <PlatformTarget>x86</PlatformTarget>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs">
-      <Link>Properties\GlobalAssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="Framework\Commands\ArgumentParser.cs" />
-    <Compile Include="Framework\Commands\Other\ShowDataFilesCommand.cs" />
-    <Compile Include="Framework\Commands\Other\ShowGameFilesCommand.cs" />
-    <Compile Include="Framework\Commands\Other\DebugCommand.cs" />
-    <Compile Include="Framework\Commands\Player\ListItemTypesCommand.cs" />
-    <Compile Include="Framework\Commands\Player\ListItemsCommand.cs" />
-    <Compile Include="Framework\Commands\Player\AddCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetStyleCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetColorCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetMaxHealthCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetMaxStaminaCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetHealthCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetImmunityCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetStaminaCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetNameCommand.cs" />
-    <Compile Include="Framework\Commands\Player\SetMoneyCommand.cs" />
-    <Compile Include="Framework\Commands\TrainerCommand.cs" />
-    <Compile Include="Framework\Commands\World\SetMineLevelCommand.cs" />
-    <Compile Include="Framework\Commands\World\DownMineLevelCommand.cs" />
-    <Compile Include="Framework\Commands\World\ClearCommand.cs" />
-    <Compile Include="Framework\Commands\World\SetYearCommand.cs" />
-    <Compile Include="Framework\Commands\World\SetSeasonCommand.cs" />
-    <Compile Include="Framework\Commands\World\SetDayCommand.cs" />
-    <Compile Include="Framework\Commands\World\SetTimeCommand.cs" />
-    <Compile Include="Framework\Commands\World\FreezeTimeCommand.cs" />
-    <Compile Include="Framework\ItemData\ItemType.cs" />
-    <Compile Include="Framework\Commands\ITrainerCommand.cs" />
-    <Compile Include="Framework\ItemData\SearchableItem.cs" />
-    <Compile Include="Framework\ItemRepository.cs" />
-    <Compile Include="ModEntry.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\SMAPI\StardewModdingAPI.csproj">
-      <Project>{f1a573b0-f436-472c-ae29-0b91ea6b9f8f}</Project>
-      <Name>StardewModdingAPI</Name>
-      <Private>False</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="manifest.json">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\..\build\common.targets" />
-</Project>
\ No newline at end of file
diff --git a/src/SMAPI.Mods.ConsoleCommands/manifest.json b/src/SMAPI.Mods.ConsoleCommands/manifest.json
deleted file mode 100644
index 3e05beda..00000000
--- a/src/SMAPI.Mods.ConsoleCommands/manifest.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "Name": "Console Commands",
-  "Author": "SMAPI",
-  "Version": "3.0.0",
-  "Description": "Adds SMAPI console commands that let you manipulate the game.",
-  "UniqueID": "SMAPI.ConsoleCommands",
-  "EntryDll": "ConsoleCommands.dll",
-  "MinimumApiVersion": "3.0.0"
-}
diff --git a/src/SMAPI.Mods.SaveBackup/ModEntry.cs b/src/SMAPI.Mods.SaveBackup/ModEntry.cs
deleted file mode 100644
index 33adf76d..00000000
--- a/src/SMAPI.Mods.SaveBackup/ModEntry.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.IO.Compression;
-using System.Linq;
-using System.Reflection;
-using StardewValley;
-
-namespace StardewModdingAPI.Mods.SaveBackup
-{
-    /// <summary>The main entry point for the mod.</summary>
-    public class ModEntry : Mod
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The number of backups to keep.</summary>
-        private readonly int BackupsToKeep = 10;
-
-        /// <summary>The absolute path to the folder in which to store save backups.</summary>
-        private readonly string BackupFolder = Path.Combine(Constants.ExecutionPath, "save-backups");
-
-        /// <summary>A unique label for the save backup to create.</summary>
-        private readonly string BackupLabel = $"{DateTime.UtcNow:yyyy-MM-dd} - SMAPI {Constants.ApiVersion} with Stardew Valley {Game1.version}";
-
-        /// <summary>The name of the save archive to create.</summary>
-        private string FileName => $"{this.BackupLabel}.zip";
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>The mod entry point, called after the mod is first loaded.</summary>
-        /// <param name="helper">Provides simplified APIs for writing mods.</param>
-        public override void Entry(IModHelper helper)
-        {
-            try
-            {
-                // init backup folder
-                DirectoryInfo backupFolder = new DirectoryInfo(this.BackupFolder);
-                backupFolder.Create();
-
-                // back up saves
-                this.CreateBackup(backupFolder);
-                this.PruneBackups(backupFolder, this.BackupsToKeep);
-            }
-            catch (Exception ex)
-            {
-                this.Monitor.Log($"Error backing up saves: {ex}", LogLevel.Error);
-            }
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Back up the current saves.</summary>
-        /// <param name="backupFolder">The folder containing save backups.</param>
-        private void CreateBackup(DirectoryInfo backupFolder)
-        {
-            try
-            {
-                // get target path
-                FileInfo targetFile = new FileInfo(Path.Combine(backupFolder.FullName, this.FileName));
-                DirectoryInfo fallbackDir = new DirectoryInfo(Path.Combine(backupFolder.FullName, this.BackupLabel));
-                if (targetFile.Exists || fallbackDir.Exists)
-                    return;
-
-                // create zip
-                // due to limitations with the bundled Mono on Mac, we can't reference System.IO.Compression.
-                this.Monitor.Log($"Adding {targetFile.Name}...", LogLevel.Trace);
-                switch (Constants.TargetPlatform)
-                {
-                    case GamePlatform.Linux:
-                    case GamePlatform.Windows:
-                        {
-                            try
-                            {
-                                // create compressed backup
-                                Assembly coreAssembly = Assembly.Load("System.IO.Compression, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089") ?? throw new InvalidOperationException("Can't load System.IO.Compression assembly.");
-                                Assembly fsAssembly = Assembly.Load("System.IO.Compression.FileSystem, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089") ?? throw new InvalidOperationException("Can't load System.IO.Compression assembly.");
-                                Type compressionLevelType = coreAssembly.GetType("System.IO.Compression.CompressionLevel") ?? throw new InvalidOperationException("Can't load CompressionLevel type.");
-                                Type zipFileType = fsAssembly.GetType("System.IO.Compression.ZipFile") ?? throw new InvalidOperationException("Can't load ZipFile type.");
-                                MethodInfo createMethod = zipFileType.GetMethod("CreateFromDirectory", new[] { typeof(string), typeof(string), compressionLevelType, typeof(bool) }) ?? throw new InvalidOperationException("Can't load ZipFile.CreateFromDirectory method.");
-                                createMethod.Invoke(null, new object[] { Constants.SavesPath, targetFile.FullName, CompressionLevel.Fastest, false });
-                            }
-                            catch (Exception ex) when (ex is TypeLoadException || ex.InnerException is TypeLoadException)
-                            {
-                                // create uncompressed backup if compression fails
-                                this.Monitor.Log("Couldn't zip the save backup, creating uncompressed backup instead.", LogLevel.Debug);
-                                this.Monitor.Log(ex.ToString(), LogLevel.Trace);
-                                this.RecursiveCopy(new DirectoryInfo(Constants.SavesPath), fallbackDir, copyRoot: false);
-                            }
-                        }
-                        break;
-
-                    case GamePlatform.Mac:
-                        {
-                            DirectoryInfo saveFolder = new DirectoryInfo(Constants.SavesPath);
-                            ProcessStartInfo startInfo = new ProcessStartInfo
-                            {
-                                FileName = "zip",
-                                Arguments = $"-rq \"{targetFile.FullName}\" \"{saveFolder.Name}\" -x \"*.DS_Store\" -x \"__MACOSX\"",
-                                WorkingDirectory = $"{Constants.SavesPath}/../",
-                                CreateNoWindow = true
-                            };
-                            new Process { StartInfo = startInfo }.Start();
-                        }
-                        break;
-                }
-            }
-            catch (Exception ex)
-            {
-                this.Monitor.Log("Couldn't back up save files (see log file for details).", LogLevel.Warn);
-                this.Monitor.Log(ex.ToString(), LogLevel.Trace);
-            }
-        }
-
-        /// <summary>Remove old backups if we've exceeded the limit.</summary>
-        /// <param name="backupFolder">The folder containing save backups.</param>
-        /// <param name="backupsToKeep">The number of backups to keep.</param>
-        private void PruneBackups(DirectoryInfo backupFolder, int backupsToKeep)
-        {
-            try
-            {
-                var oldBackups = backupFolder
-                    .GetFileSystemInfos()
-                    .OrderByDescending(p => p.CreationTimeUtc)
-                    .Skip(backupsToKeep);
-
-                foreach (FileSystemInfo entry in oldBackups)
-                {
-                    try
-                    {
-                        this.Monitor.Log($"Deleting {entry.Name}...", LogLevel.Trace);
-                        if (entry is DirectoryInfo folder)
-                            folder.Delete(recursive: true);
-                        else
-                            entry.Delete();
-                    }
-                    catch (Exception ex)
-                    {
-                        this.Monitor.Log($"Error deleting old save backup '{entry.Name}': {ex}", LogLevel.Error);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                this.Monitor.Log("Couldn't remove old backups (see log file for details).", LogLevel.Warn);
-                this.Monitor.Log(ex.ToString(), LogLevel.Trace);
-            }
-        }
-
-        /// <summary>Recursively copy a directory or file.</summary>
-        /// <param name="source">The file or folder to copy.</param>
-        /// <param name="targetFolder">The folder to copy into.</param>
-        /// <param name="copyRoot">Whether to copy the root folder itself, or <c>false</c> to only copy its contents.</param>
-        /// <remarks>Derived from the SMAPI installer code.</remarks>
-        private void RecursiveCopy(FileSystemInfo source, DirectoryInfo targetFolder, bool copyRoot = true)
-        {
-            if (!targetFolder.Exists)
-                targetFolder.Create();
-
-            switch (source)
-            {
-                case FileInfo sourceFile:
-                    sourceFile.CopyTo(Path.Combine(targetFolder.FullName, sourceFile.Name));
-                    break;
-
-                case DirectoryInfo sourceDir:
-                    DirectoryInfo targetSubfolder = copyRoot ? new DirectoryInfo(Path.Combine(targetFolder.FullName, sourceDir.Name)) : targetFolder;
-                    foreach (var entry in sourceDir.EnumerateFileSystemInfos())
-                        this.RecursiveCopy(entry, targetSubfolder);
-                    break;
-
-                default:
-                    throw new NotSupportedException($"Unknown filesystem info type '{source.GetType().FullName}'.");
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Mods.SaveBackup/Properties/AssemblyInfo.cs b/src/SMAPI.Mods.SaveBackup/Properties/AssemblyInfo.cs
deleted file mode 100644
index fc6b26fa..00000000
--- a/src/SMAPI.Mods.SaveBackup/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("StardewModdingAPI.Mods.SaveBackup")]
-[assembly: AssemblyDescription("")]
diff --git a/src/SMAPI.Mods.SaveBackup/StardewModdingAPI.Mods.SaveBackup.csproj b/src/SMAPI.Mods.SaveBackup/StardewModdingAPI.Mods.SaveBackup.csproj
deleted file mode 100644
index 56b6b7f4..00000000
--- a/src/SMAPI.Mods.SaveBackup/StardewModdingAPI.Mods.SaveBackup.csproj
+++ /dev/null
@@ -1,62 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
-    <ProjectGuid>{E272EB5D-8C57-417E-8E60-C1079D3F53C4}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>StardewModdingAPI.Mods.SaveBackup</RootNamespace>
-    <AssemblyName>SaveBackup</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>$(SolutionDir)\..\bin\Debug\Mods\SaveBackup\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>$(SolutionDir)\..\bin\Release\Mods\SaveBackup\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs">
-      <Link>Properties\GlobalAssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="ModEntry.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="manifest.json">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\SMAPI\StardewModdingAPI.csproj">
-      <Project>{f1a573b0-f436-472c-ae29-0b91ea6b9f8f}</Project>
-      <Name>StardewModdingAPI</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit.CoreInterfaces\StardewModdingAPI.Toolkit.CoreInterfaces.csproj">
-      <Project>{d5cfd923-37f1-4bc3-9be8-e506e202ac28}</Project>
-      <Name>StardewModdingAPI.Toolkit.CoreInterfaces</Name>
-      <Private>False</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\..\build\common.targets" />
-</Project>
\ No newline at end of file
diff --git a/src/SMAPI.Mods.SaveBackup/manifest.json b/src/SMAPI.Mods.SaveBackup/manifest.json
deleted file mode 100644
index 59967c29..00000000
--- a/src/SMAPI.Mods.SaveBackup/manifest.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "Name": "Save Backup",
-  "Author": "SMAPI",
-  "Version": "3.0.0",
-  "Description": "Automatically backs up all your saves once per day into its folder.",
-  "UniqueID": "SMAPI.SaveBackup",
-  "EntryDll": "SaveBackup.dll",
-  "MinimumApiVersion": "3.0.0"
-}
diff --git a/src/SMAPI.Tests/Core/ModResolverTests.cs b/src/SMAPI.Tests/Core/ModResolverTests.cs
deleted file mode 100644
index 4a1f04c6..00000000
--- a/src/SMAPI.Tests/Core/ModResolverTests.cs
+++ /dev/null
@@ -1,539 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using Moq;
-using Newtonsoft.Json;
-using NUnit.Framework;
-using StardewModdingAPI.Framework;
-using StardewModdingAPI.Framework.ModLoading;
-using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Toolkit.Framework.ModData;
-using StardewModdingAPI.Toolkit.Serialisation.Models;
-
-namespace StardewModdingAPI.Tests.Core
-{
-    /// <summary>Unit tests for <see cref="ModResolver"/>.</summary>
-    [TestFixture]
-    public class ModResolverTests
-    {
-        /*********
-        ** Unit tests
-        *********/
-        /****
-        ** ReadManifests
-        ****/
-        [Test(Description = "Assert that the resolver correctly returns an empty list if there are no mods installed.")]
-        public void ReadBasicManifest_NoMods_ReturnsEmptyList()
-        {
-            // arrange
-            string rootFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
-            Directory.CreateDirectory(rootFolder);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ReadManifests(new ModToolkit(), rootFolder, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(0, mods.Length, 0, $"Expected to find zero manifests, found {mods.Length} instead.");
-        }
-
-        [Test(Description = "Assert that the resolver correctly returns a failed metadata if there's an empty mod folder.")]
-        public void ReadBasicManifest_EmptyModFolder_ReturnsFailedManifest()
-        {
-            // arrange
-            string rootFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
-            string modFolder = Path.Combine(rootFolder, Guid.NewGuid().ToString("N"));
-            Directory.CreateDirectory(modFolder);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ReadManifests(new ModToolkit(), rootFolder, new ModDatabase()).ToArray();
-            IModMetadata mod = mods.FirstOrDefault();
-
-            // assert
-            Assert.AreEqual(1, mods.Length, 0, $"Expected to find one manifest, found {mods.Length} instead.");
-            Assert.AreEqual(ModMetadataStatus.Failed, mod.Status, "The mod metadata was not marked failed.");
-            Assert.IsNotNull(mod.Error, "The mod metadata did not have an error message set.");
-        }
-
-        [Test(Description = "Assert that the resolver correctly reads manifest data from a randomised file.")]
-        public void ReadBasicManifest_CanReadFile()
-        {
-            // create manifest data
-            IDictionary<string, object> originalDependency = new Dictionary<string, object>
-            {
-                [nameof(IManifestDependency.UniqueID)] = Sample.String()
-            };
-            IDictionary<string, object> original = new Dictionary<string, object>
-            {
-                [nameof(IManifest.Name)] = Sample.String(),
-                [nameof(IManifest.Author)] = Sample.String(),
-                [nameof(IManifest.Version)] = new SemanticVersion(Sample.Int(), Sample.Int(), Sample.Int(), Sample.String()),
-                [nameof(IManifest.Description)] = Sample.String(),
-                [nameof(IManifest.UniqueID)] = $"{Sample.String()}.{Sample.String()}",
-                [nameof(IManifest.EntryDll)] = $"{Sample.String()}.dll",
-                [nameof(IManifest.MinimumApiVersion)] = $"{Sample.Int()}.{Sample.Int()}-{Sample.String()}",
-                [nameof(IManifest.Dependencies)] = new[] { originalDependency },
-                ["ExtraString"] = Sample.String(),
-                ["ExtraInt"] = Sample.Int()
-            };
-
-            // write to filesystem
-            string rootFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
-            string modFolder = Path.Combine(rootFolder, Guid.NewGuid().ToString("N"));
-            string filename = Path.Combine(modFolder, "manifest.json");
-            Directory.CreateDirectory(modFolder);
-            File.WriteAllText(filename, JsonConvert.SerializeObject(original));
-
-            // act
-            IModMetadata[] mods = new ModResolver().ReadManifests(new ModToolkit(), rootFolder, new ModDatabase()).ToArray();
-            IModMetadata mod = mods.FirstOrDefault();
-
-            // assert
-            Assert.AreEqual(1, mods.Length, 0, "Expected to find one manifest.");
-            Assert.IsNotNull(mod, "The loaded manifest shouldn't be null.");
-            Assert.AreEqual(null, mod.DataRecord, "The data record should be null since we didn't provide one.");
-            Assert.AreEqual(modFolder, mod.DirectoryPath, "The directory path doesn't match.");
-            Assert.AreEqual(null, mod.Error, "The error should be null since parsing should have succeeded.");
-            Assert.AreEqual(ModMetadataStatus.Found, mod.Status, "The status doesn't match.");
-
-            Assert.AreEqual(original[nameof(IManifest.Name)], mod.DisplayName, "The display name should use the manifest name.");
-            Assert.AreEqual(original[nameof(IManifest.Name)], mod.Manifest.Name, "The manifest's name doesn't match.");
-            Assert.AreEqual(original[nameof(IManifest.Author)], mod.Manifest.Author, "The manifest's author doesn't match.");
-            Assert.AreEqual(original[nameof(IManifest.Description)], mod.Manifest.Description, "The manifest's description doesn't match.");
-            Assert.AreEqual(original[nameof(IManifest.EntryDll)], mod.Manifest.EntryDll, "The manifest's entry DLL doesn't match.");
-            Assert.AreEqual(original[nameof(IManifest.MinimumApiVersion)], mod.Manifest.MinimumApiVersion?.ToString(), "The manifest's minimum API version doesn't match.");
-            Assert.AreEqual(original[nameof(IManifest.Version)]?.ToString(), mod.Manifest.Version?.ToString(), "The manifest's version doesn't match.");
-
-            Assert.IsNotNull(mod.Manifest.ExtraFields, "The extra fields should not be null.");
-            Assert.AreEqual(2, mod.Manifest.ExtraFields.Count, "The extra fields should contain two values.");
-            Assert.AreEqual(original["ExtraString"], mod.Manifest.ExtraFields["ExtraString"], "The manifest's extra fields should contain an 'ExtraString' value.");
-            Assert.AreEqual(original["ExtraInt"], mod.Manifest.ExtraFields["ExtraInt"], "The manifest's extra fields should contain an 'ExtraInt' value.");
-
-            Assert.IsNotNull(mod.Manifest.Dependencies, "The dependencies field should not be null.");
-            Assert.AreEqual(1, mod.Manifest.Dependencies.Length, "The dependencies field should contain one value.");
-            Assert.AreEqual(originalDependency[nameof(IManifestDependency.UniqueID)], mod.Manifest.Dependencies[0].UniqueID, "The first dependency's unique ID doesn't match.");
-        }
-
-        /****
-        ** ValidateManifests
-        ****/
-        [Test(Description = "Assert that validation doesn't fail if there are no mods installed.")]
-        public void ValidateManifests_NoMods_DoesNothing()
-        {
-            new ModResolver().ValidateManifests(new ModMetadata[0], apiVersion: new SemanticVersion("1.0"), getUpdateUrl: key => null);
-        }
-
-        [Test(Description = "Assert that validation skips manifests that have already failed without calling any other properties.")]
-        public void ValidateManifests_Skips_Failed()
-        {
-            // arrange
-            Mock<IModMetadata> mock = this.GetMetadata("Mod A");
-            mock.Setup(p => p.Status).Returns(ModMetadataStatus.Failed);
-
-            // act
-            new ModResolver().ValidateManifests(new[] { mock.Object }, apiVersion: new SemanticVersion("1.0"), getUpdateUrl: key => null);
-
-            // assert
-            mock.VerifyGet(p => p.Status, Times.Once, "The validation did not check the manifest status.");
-        }
-
-        [Test(Description = "Assert that validation fails if the mod has 'assume broken' status.")]
-        public void ValidateManifests_ModStatus_AssumeBroken_Fails()
-        {
-            // arrange
-            Mock<IModMetadata> mock = this.GetMetadata("Mod A", new string[0], allowStatusChange: true);
-            this.SetupMetadataForValidation(mock, new ModDataRecordVersionedFields
-            {
-                Status = ModStatus.AssumeBroken,
-                AlternativeUrl = "https://example.org"
-            });
-
-            // act
-            new ModResolver().ValidateManifests(new[] { mock.Object }, apiVersion: new SemanticVersion("1.0"), getUpdateUrl: key => null);
-
-            // assert
-            mock.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "The validation did not fail the metadata.");
-        }
-
-        [Test(Description = "Assert that validation fails when the minimum API version is higher than the current SMAPI version.")]
-        public void ValidateManifests_MinimumApiVersion_Fails()
-        {
-            // arrange
-            Mock<IModMetadata> mock = this.GetMetadata("Mod A", new string[0], allowStatusChange: true);
-            mock.Setup(p => p.Manifest).Returns(this.GetManifest(minimumApiVersion: "1.1"));
-            this.SetupMetadataForValidation(mock);
-
-            // act
-            new ModResolver().ValidateManifests(new[] { mock.Object }, apiVersion: new SemanticVersion("1.0"), getUpdateUrl: key => null);
-
-            // assert
-            mock.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "The validation did not fail the metadata.");
-        }
-
-        [Test(Description = "Assert that validation fails when the manifest references a DLL that does not exist.")]
-        public void ValidateManifests_MissingEntryDLL_Fails()
-        {
-            // arrange
-            Mock<IModMetadata> mock = this.GetMetadata(this.GetManifest(id: "Mod A", version: "1.0", entryDll: "Missing.dll"), allowStatusChange: true);
-            this.SetupMetadataForValidation(mock);
-
-            // act
-            new ModResolver().ValidateManifests(new[] { mock.Object }, apiVersion: new SemanticVersion("1.0"), getUpdateUrl: key => null);
-
-            // assert
-            mock.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "The validation did not fail the metadata.");
-        }
-
-        [Test(Description = "Assert that validation fails when multiple mods have the same unique ID.")]
-        public void ValidateManifests_DuplicateUniqueID_Fails()
-        {
-            // arrange
-            Mock<IModMetadata> modA = this.GetMetadata("Mod A", new string[0], allowStatusChange: true);
-            Mock<IModMetadata> modB = this.GetMetadata(this.GetManifest(id: "Mod A", name: "Mod B", version: "1.0"), allowStatusChange: true);
-            Mock<IModMetadata> modC = this.GetMetadata("Mod C", new string[0], allowStatusChange: false);
-            foreach (Mock<IModMetadata> mod in new[] { modA, modB, modC })
-                this.SetupMetadataForValidation(mod);
-
-            // act
-            new ModResolver().ValidateManifests(new[] { modA.Object, modB.Object }, apiVersion: new SemanticVersion("1.0"), getUpdateUrl: key => null);
-
-            // assert
-            modA.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "The validation did not fail the first mod with a unique ID.");
-            modB.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "The validation did not fail the second mod with a unique ID.");
-        }
-
-        [Test(Description = "Assert that validation fails when the manifest references a DLL that does not exist.")]
-        public void ValidateManifests_Valid_Passes()
-        {
-            // set up manifest
-            IManifest manifest = this.GetManifest();
-
-            // create DLL
-            string modFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
-            Directory.CreateDirectory(modFolder);
-            File.WriteAllText(Path.Combine(modFolder, manifest.EntryDll), "");
-
-            // arrange
-            Mock<IModMetadata> mock = new Mock<IModMetadata>(MockBehavior.Strict);
-            mock.Setup(p => p.Status).Returns(ModMetadataStatus.Found);
-            mock.Setup(p => p.DataRecord).Returns(() => null);
-            mock.Setup(p => p.Manifest).Returns(manifest);
-            mock.Setup(p => p.DirectoryPath).Returns(modFolder);
-
-            // act
-            new ModResolver().ValidateManifests(new[] { mock.Object }, apiVersion: new SemanticVersion("1.0"), getUpdateUrl: key => null);
-
-            // assert
-            // if Moq doesn't throw a method-not-setup exception, the validation didn't override the status.
-        }
-
-        /****
-        ** ProcessDependencies
-        ****/
-        [Test(Description = "Assert that processing dependencies doesn't fail if there are no mods installed.")]
-        public void ProcessDependencies_NoMods_DoesNothing()
-        {
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new IModMetadata[0], new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(0, mods.Length, 0, "Expected to get an empty list of mods.");
-        }
-
-        [Test(Description = "Assert that processing dependencies doesn't change the order if there are no mod dependencies.")]
-        public void ProcessDependencies_NoDependencies_DoesNothing()
-        {
-            // arrange
-            // A B C
-            Mock<IModMetadata> modA = this.GetMetadata("Mod A");
-            Mock<IModMetadata> modB = this.GetMetadata("Mod B");
-            Mock<IModMetadata> modC = this.GetMetadata("Mod C");
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modA.Object, modB.Object, modC.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(3, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modA.Object, mods[0], "The load order unexpectedly changed with no dependencies.");
-            Assert.AreSame(modB.Object, mods[1], "The load order unexpectedly changed with no dependencies.");
-            Assert.AreSame(modC.Object, mods[2], "The load order unexpectedly changed with no dependencies.");
-        }
-
-        [Test(Description = "Assert that processing dependencies skips mods that have already failed without calling any other properties.")]
-        public void ProcessDependencies_Skips_Failed()
-        {
-            // arrange
-            Mock<IModMetadata> mock = new Mock<IModMetadata>(MockBehavior.Strict);
-            mock.Setup(p => p.Status).Returns(ModMetadataStatus.Failed);
-
-            // act
-            new ModResolver().ProcessDependencies(new[] { mock.Object }, new ModDatabase());
-
-            // assert
-            mock.VerifyGet(p => p.Status, Times.Once, "The validation did not check the manifest status.");
-        }
-
-        [Test(Description = "Assert that simple dependencies are reordered correctly.")]
-        public void ProcessDependencies_Reorders_SimpleDependencies()
-        {
-            // arrange
-            // A ◀── B
-            // ▲     ▲
-            // │     │
-            // └─ C ─┘
-            Mock<IModMetadata> modA = this.GetMetadata("Mod A");
-            Mock<IModMetadata> modB = this.GetMetadata("Mod B", dependencies: new[] { "Mod A" });
-            Mock<IModMetadata> modC = this.GetMetadata("Mod C", dependencies: new[] { "Mod A", "Mod B" });
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modC.Object, modA.Object, modB.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(3, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modA.Object, mods[0], "The load order is incorrect: mod A should be first since the other mods depend on it.");
-            Assert.AreSame(modB.Object, mods[1], "The load order is incorrect: mod B should be second since it needs mod A, and is needed by mod C.");
-            Assert.AreSame(modC.Object, mods[2], "The load order is incorrect: mod C should be third since it needs both mod A and mod B.");
-        }
-
-        [Test(Description = "Assert that simple dependency chains are reordered correctly.")]
-        public void ProcessDependencies_Reorders_DependencyChain()
-        {
-            // arrange
-            // A ◀── B ◀── C ◀── D
-            Mock<IModMetadata> modA = this.GetMetadata("Mod A");
-            Mock<IModMetadata> modB = this.GetMetadata("Mod B", dependencies: new[] { "Mod A" });
-            Mock<IModMetadata> modC = this.GetMetadata("Mod C", dependencies: new[] { "Mod B" });
-            Mock<IModMetadata> modD = this.GetMetadata("Mod D", dependencies: new[] { "Mod C" });
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modC.Object, modA.Object, modB.Object, modD.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(4, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modA.Object, mods[0], "The load order is incorrect: mod A should be first since it's needed by mod B.");
-            Assert.AreSame(modB.Object, mods[1], "The load order is incorrect: mod B should be second since it needs mod A, and is needed by mod C.");
-            Assert.AreSame(modC.Object, mods[2], "The load order is incorrect: mod C should be third since it needs mod B, and is needed by mod D.");
-            Assert.AreSame(modD.Object, mods[3], "The load order is incorrect: mod D should be fourth since it needs mod C.");
-        }
-
-        [Test(Description = "Assert that overlapping dependency chains are reordered correctly.")]
-        public void ProcessDependencies_Reorders_OverlappingDependencyChain()
-        {
-            // arrange
-            // A ◀── B ◀── C ◀── D
-            //       ▲     ▲
-            //       │     │
-            //       E ◀── F
-            Mock<IModMetadata> modA = this.GetMetadata("Mod A");
-            Mock<IModMetadata> modB = this.GetMetadata("Mod B", dependencies: new[] { "Mod A" });
-            Mock<IModMetadata> modC = this.GetMetadata("Mod C", dependencies: new[] { "Mod B" });
-            Mock<IModMetadata> modD = this.GetMetadata("Mod D", dependencies: new[] { "Mod C" });
-            Mock<IModMetadata> modE = this.GetMetadata("Mod E", dependencies: new[] { "Mod B" });
-            Mock<IModMetadata> modF = this.GetMetadata("Mod F", dependencies: new[] { "Mod C", "Mod E" });
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modC.Object, modA.Object, modB.Object, modD.Object, modF.Object, modE.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(6, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modA.Object, mods[0], "The load order is incorrect: mod A should be first since it's needed by mod B.");
-            Assert.AreSame(modB.Object, mods[1], "The load order is incorrect: mod B should be second since it needs mod A, and is needed by mod C.");
-            Assert.AreSame(modC.Object, mods[2], "The load order is incorrect: mod C should be third since it needs mod B, and is needed by mod D.");
-            Assert.AreSame(modD.Object, mods[3], "The load order is incorrect: mod D should be fourth since it needs mod C.");
-            Assert.AreSame(modE.Object, mods[4], "The load order is incorrect: mod E should be fifth since it needs mod B, but is specified after C which also needs mod B.");
-            Assert.AreSame(modF.Object, mods[5], "The load order is incorrect: mod F should be last since it needs mods E and C.");
-        }
-
-        [Test(Description = "Assert that mods with circular dependency chains are skipped, but any other mods are loaded in the correct order.")]
-        public void ProcessDependencies_Skips_CircularDependentMods()
-        {
-            // arrange
-            // A ◀── B ◀── C ──▶ D
-            //             ▲     │
-            //             │     ▼
-            //             └──── E
-            Mock<IModMetadata> modA = this.GetMetadata("Mod A");
-            Mock<IModMetadata> modB = this.GetMetadata("Mod B", dependencies: new[] { "Mod A" });
-            Mock<IModMetadata> modC = this.GetMetadata("Mod C", dependencies: new[] { "Mod B", "Mod D" }, allowStatusChange: true);
-            Mock<IModMetadata> modD = this.GetMetadata("Mod D", dependencies: new[] { "Mod E" }, allowStatusChange: true);
-            Mock<IModMetadata> modE = this.GetMetadata("Mod E", dependencies: new[] { "Mod C" }, allowStatusChange: true);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modC.Object, modA.Object, modB.Object, modD.Object, modE.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(5, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modA.Object, mods[0], "The load order is incorrect: mod A should be first since it's needed by mod B.");
-            Assert.AreSame(modB.Object, mods[1], "The load order is incorrect: mod B should be second since it needs mod A.");
-            modC.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "Mod C was expected to fail since it's part of a dependency loop.");
-            modD.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "Mod D was expected to fail since it's part of a dependency loop.");
-            modE.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "Mod E was expected to fail since it's part of a dependency loop.");
-        }
-
-        [Test(Description = "Assert that dependencies are sorted correctly even if some of the mods failed during metadata loading.")]
-        public void ProcessDependencies_WithSomeFailedMods_Succeeds()
-        {
-            // arrange
-            // A ◀── B ◀── C   D (failed)
-            Mock<IModMetadata> modA = this.GetMetadata("Mod A");
-            Mock<IModMetadata> modB = this.GetMetadata("Mod B", dependencies: new[] { "Mod A" });
-            Mock<IModMetadata> modC = this.GetMetadata("Mod C", dependencies: new[] { "Mod B" }, allowStatusChange: true);
-            Mock<IModMetadata> modD = new Mock<IModMetadata>(MockBehavior.Strict);
-            modD.Setup(p => p.Manifest).Returns<IManifest>(null);
-            modD.Setup(p => p.Status).Returns(ModMetadataStatus.Failed);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modC.Object, modA.Object, modB.Object, modD.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(4, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modD.Object, mods[0], "The load order is incorrect: mod D should be first since it was already failed.");
-            Assert.AreSame(modA.Object, mods[1], "The load order is incorrect: mod A should be second since it's needed by mod B.");
-            Assert.AreSame(modB.Object, mods[2], "The load order is incorrect: mod B should be third since it needs mod A, and is needed by mod C.");
-            Assert.AreSame(modC.Object, mods[3], "The load order is incorrect: mod C should be fourth since it needs mod B, and is needed by mod D.");
-        }
-
-        [Test(Description = "Assert that dependencies are failed if they don't meet the minimum version.")]
-        public void ProcessDependencies_WithMinVersions_FailsIfNotMet()
-        {
-            // arrange
-            // A 1.0 ◀── B (need A 1.1)
-            Mock<IModMetadata> modA = this.GetMetadata(this.GetManifest(id: "Mod A", version: "1.0"));
-            Mock<IModMetadata> modB = this.GetMetadata(this.GetManifest(id: "Mod B", version: "1.0", dependencies: new IManifestDependency[] { new ManifestDependency("Mod A", "1.1") }), allowStatusChange: true);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modA.Object, modB.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(2, mods.Length, 0, "Expected to get the same number of mods input.");
-            modB.Verify(p => p.SetStatus(ModMetadataStatus.Failed, It.IsAny<string>()), Times.Once, "Mod B unexpectedly didn't fail even though it needs a newer version of Mod A.");
-        }
-
-        [Test(Description = "Assert that dependencies are accepted if they meet the minimum version.")]
-        public void ProcessDependencies_WithMinVersions_SucceedsIfMet()
-        {
-            // arrange
-            // A 1.0 ◀── B (need A 1.0-beta)
-            Mock<IModMetadata> modA = this.GetMetadata(this.GetManifest(id: "Mod A", version: "1.0"));
-            Mock<IModMetadata> modB = this.GetMetadata(this.GetManifest(id: "Mod B", version: "1.0", dependencies: new IManifestDependency[] { new ManifestDependency("Mod A", "1.0-beta") }), allowStatusChange: false);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modA.Object, modB.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(2, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modA.Object, mods[0], "The load order is incorrect: mod A should be first since it's needed by mod B.");
-            Assert.AreSame(modB.Object, mods[1], "The load order is incorrect: mod B should be second since it needs mod A.");
-        }
-
-        [Test(Description = "Assert that optional dependencies are sorted correctly if present.")]
-        public void ProcessDependencies_IfOptional()
-        {
-            // arrange
-            // A ◀── B
-            Mock<IModMetadata> modA = this.GetMetadata(this.GetManifest(id: "Mod A", version: "1.0"));
-            Mock<IModMetadata> modB = this.GetMetadata(this.GetManifest(id: "Mod B", version: "1.0", dependencies: new IManifestDependency[] { new ManifestDependency("Mod A", "1.0", required: false) }), allowStatusChange: false);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modB.Object, modA.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(2, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modA.Object, mods[0], "The load order is incorrect: mod A should be first since it's needed by mod B.");
-            Assert.AreSame(modB.Object, mods[1], "The load order is incorrect: mod B should be second since it needs mod A.");
-        }
-
-        [Test(Description = "Assert that optional dependencies are accepted if they're missing.")]
-        public void ProcessDependencies_IfOptional_SucceedsIfMissing()
-        {
-            // arrange
-            // A ◀── B where A doesn't exist
-            Mock<IModMetadata> modB = this.GetMetadata(this.GetManifest(id: "Mod B", version: "1.0", dependencies: new IManifestDependency[] { new ManifestDependency("Mod A", "1.0", required: false) }), allowStatusChange: false);
-
-            // act
-            IModMetadata[] mods = new ModResolver().ProcessDependencies(new[] { modB.Object }, new ModDatabase()).ToArray();
-
-            // assert
-            Assert.AreEqual(1, mods.Length, 0, "Expected to get the same number of mods input.");
-            Assert.AreSame(modB.Object, mods[0], "The load order is incorrect: mod B should be first since it's the only mod.");
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get a randomised basic manifest.</summary>
-        /// <param name="id">The <see cref="IManifest.UniqueID"/> value, or <c>null</c> for a generated value.</param>
-        /// <param name="name">The <see cref="IManifest.Name"/> value, or <c>null</c> for a generated value.</param>
-        /// <param name="version">The <see cref="IManifest.Version"/> value, or <c>null</c> for a generated value.</param>
-        /// <param name="entryDll">The <see cref="IManifest.EntryDll"/> value, or <c>null</c> for a generated value.</param>
-        /// <param name="contentPackForID">The <see cref="IManifest.ContentPackFor"/> value.</param>
-        /// <param name="minimumApiVersion">The <see cref="IManifest.MinimumApiVersion"/> value.</param>
-        /// <param name="dependencies">The <see cref="IManifest.Dependencies"/> value.</param>
-        private Manifest GetManifest(string id = null, string name = null, string version = null, string entryDll = null, string contentPackForID = null, string minimumApiVersion = null, IManifestDependency[] dependencies = null)
-        {
-            return new Manifest
-            {
-                UniqueID = id ?? $"{Sample.String()}.{Sample.String()}",
-                Name = name ?? id ?? Sample.String(),
-                Author = Sample.String(),
-                Description = Sample.String(),
-                Version = version != null ? new SemanticVersion(version) : new SemanticVersion(Sample.Int(), Sample.Int(), Sample.Int(), Sample.String()),
-                EntryDll = entryDll ?? $"{Sample.String()}.dll",
-                ContentPackFor = contentPackForID != null ? new ManifestContentPackFor { UniqueID = contentPackForID } : null,
-                MinimumApiVersion = minimumApiVersion != null ? new SemanticVersion(minimumApiVersion) : null,
-                Dependencies = dependencies
-            };
-        }
-
-        /// <summary>Get a randomised basic manifest.</summary>
-        /// <param name="uniqueID">The mod's name and unique ID.</param>
-        private Mock<IModMetadata> GetMetadata(string uniqueID)
-        {
-            return this.GetMetadata(this.GetManifest(uniqueID, "1.0"));
-        }
-
-        /// <summary>Get a randomised basic manifest.</summary>
-        /// <param name="uniqueID">The mod's name and unique ID.</param>
-        /// <param name="dependencies">The dependencies this mod requires.</param>
-        /// <param name="allowStatusChange">Whether the code being tested is allowed to change the mod status.</param>
-        private Mock<IModMetadata> GetMetadata(string uniqueID, string[] dependencies, bool allowStatusChange = false)
-        {
-            IManifest manifest = this.GetManifest(id: uniqueID, version: "1.0", dependencies: dependencies?.Select(dependencyID => (IManifestDependency)new ManifestDependency(dependencyID, null)).ToArray());
-            return this.GetMetadata(manifest, allowStatusChange);
-        }
-
-        /// <summary>Get a randomised basic manifest.</summary>
-        /// <param name="manifest">The mod manifest.</param>
-        /// <param name="allowStatusChange">Whether the code being tested is allowed to change the mod status.</param>
-        private Mock<IModMetadata> GetMetadata(IManifest manifest, bool allowStatusChange = false)
-        {
-            Mock<IModMetadata> mod = new Mock<IModMetadata>(MockBehavior.Strict);
-            mod.Setup(p => p.DataRecord).Returns(() => null);
-            mod.Setup(p => p.Status).Returns(ModMetadataStatus.Found);
-            mod.Setup(p => p.DisplayName).Returns(manifest.UniqueID);
-            mod.Setup(p => p.Manifest).Returns(manifest);
-            mod.Setup(p => p.HasID(It.IsAny<string>())).Returns((string id) => manifest.UniqueID == id);
-            if (allowStatusChange)
-            {
-                mod
-                    .Setup(p => p.SetStatus(It.IsAny<ModMetadataStatus>(), It.IsAny<string>()))
-                    .Callback<ModMetadataStatus, string>((status, message) => Console.WriteLine($"<{manifest.UniqueID} changed status: [{status}] {message}"))
-                    .Returns(mod.Object);
-            }
-            return mod;
-        }
-
-        /// <summary>Set up a mock mod metadata for <see cref="ModResolver.ValidateManifests"/>.</summary>
-        /// <param name="mod">The mock mod metadata.</param>
-        /// <param name="modRecord">The extra metadata about the mod from SMAPI's internal data (if any).</param>
-        private void SetupMetadataForValidation(Mock<IModMetadata> mod, ModDataRecordVersionedFields modRecord = null)
-        {
-            mod.Setup(p => p.Status).Returns(ModMetadataStatus.Found);
-            mod.Setup(p => p.DataRecord).Returns(() => null);
-            mod.Setup(p => p.Manifest).Returns(this.GetManifest());
-            mod.Setup(p => p.DirectoryPath).Returns(Path.GetTempPath());
-            mod.Setup(p => p.DataRecord).Returns(modRecord);
-        }
-    }
-}
diff --git a/src/SMAPI.Tests/Core/TranslationTests.cs b/src/SMAPI.Tests/Core/TranslationTests.cs
deleted file mode 100644
index 63404a41..00000000
--- a/src/SMAPI.Tests/Core/TranslationTests.cs
+++ /dev/null
@@ -1,356 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using StardewModdingAPI.Framework.ModHelpers;
-using StardewValley;
-
-namespace StardewModdingAPI.Tests.Core
-{
-    /// <summary>Unit tests for <see cref="TranslationHelper"/> and <see cref="Translation"/>.</summary>
-    [TestFixture]
-    public class TranslationTests
-    {
-        /*********
-        ** Data
-        *********/
-        /// <summary>Sample translation text for unit tests.</summary>
-        public static string[] Samples = { null, "", "  ", "boop", "  boop  " };
-
-
-        /*********
-        ** Unit tests
-        *********/
-        /****
-        ** Translation helper
-        ****/
-        [Test(Description = "Assert that the translation helper correctly handles no translations.")]
-        public void Helper_HandlesNoTranslations()
-        {
-            // arrange
-            var data = new Dictionary<string, IDictionary<string, string>>();
-
-            // act
-            ITranslationHelper helper = new TranslationHelper("ModID", "ModName", "en", LocalizedContentManager.LanguageCode.en).SetTranslations(data);
-            Translation translation = helper.Get("key");
-            Translation[] translationList = helper.GetTranslations()?.ToArray();
-
-            // assert
-            Assert.AreEqual("en", helper.Locale, "The locale doesn't match the input value.");
-            Assert.AreEqual(LocalizedContentManager.LanguageCode.en, helper.LocaleEnum, "The locale enum doesn't match the input value.");
-            Assert.IsNotNull(translationList, "The full list of translations is unexpectedly null.");
-            Assert.AreEqual(0, translationList.Length, "The full list of translations is unexpectedly not empty.");
-
-            Assert.IsNotNull(translation, "The translation helper unexpectedly returned a null translation.");
-            Assert.AreEqual(this.GetPlaceholderText("key"), translation.ToString(), "The translation returned an unexpected value.");
-        }
-
-        [Test(Description = "Assert that the translation helper returns the expected translations correctly.")]
-        public void Helper_GetTranslations_ReturnsExpectedText()
-        {
-            // arrange
-            var data = this.GetSampleData();
-            var expected = this.GetExpectedTranslations();
-
-            // act
-            var actual = new Dictionary<string, Translation[]>();
-            TranslationHelper helper = new TranslationHelper("ModID", "ModName", "en", LocalizedContentManager.LanguageCode.en).SetTranslations(data);
-            foreach (string locale in expected.Keys)
-            {
-                this.AssertSetLocale(helper, locale, LocalizedContentManager.LanguageCode.en);
-                actual[locale] = helper.GetTranslations()?.ToArray();
-            }
-
-            // assert
-            foreach (string locale in expected.Keys)
-            {
-                Assert.IsNotNull(actual[locale], $"The translations for {locale} is unexpectedly null.");
-                Assert.That(actual[locale], Is.EquivalentTo(expected[locale]).Using<Translation, Translation>(this.CompareEquality), $"The translations for {locale} don't match the expected values.");
-            }
-        }
-
-        [Test(Description = "Assert that the translations returned by the helper has the expected text.")]
-        public void Helper_Get_ReturnsExpectedText()
-        {
-            // arrange
-            var data = this.GetSampleData();
-            var expected = this.GetExpectedTranslations();
-
-            // act
-            var actual = new Dictionary<string, Translation[]>();
-            TranslationHelper helper = new TranslationHelper("ModID", "ModName", "en", LocalizedContentManager.LanguageCode.en).SetTranslations(data);
-            foreach (string locale in expected.Keys)
-            {
-                this.AssertSetLocale(helper, locale, LocalizedContentManager.LanguageCode.en);
-
-                List<Translation> translations = new List<Translation>();
-                foreach (Translation translation in expected[locale])
-                    translations.Add(helper.Get(translation.Key));
-                actual[locale] = translations.ToArray();
-            }
-
-            // assert
-            foreach (string locale in expected.Keys)
-            {
-                Assert.IsNotNull(actual[locale], $"The translations for {locale} is unexpectedly null.");
-                Assert.That(actual[locale], Is.EquivalentTo(expected[locale]).Using<Translation, Translation>(this.CompareEquality), $"The translations for {locale} don't match the expected values.");
-            }
-        }
-
-        /****
-        ** Translation
-        ****/
-        [Test(Description = "Assert that HasValue returns the expected result for various inputs.")]
-        [TestCase(null, ExpectedResult = false)]
-        [TestCase("", ExpectedResult = false)]
-        [TestCase("  ", ExpectedResult = true)]
-        [TestCase("boop", ExpectedResult = true)]
-        [TestCase("  boop  ", ExpectedResult = true)]
-        public bool Translation_HasValue(string text)
-        {
-            return new Translation("ModName", "pt-BR", "key", text).HasValue();
-        }
-
-        [Test(Description = "Assert that the translation's ToString method returns the expected text for various inputs.")]
-        public void Translation_ToString([ValueSource(nameof(TranslationTests.Samples))] string text)
-        {
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", text);
-
-            // assert
-            if (translation.HasValue())
-                Assert.AreEqual(text, translation.ToString(), "The translation returned an unexpected value given a valid input.");
-            else
-                Assert.AreEqual(this.GetPlaceholderText("key"), translation.ToString(), "The translation returned an unexpected value given a null or empty input.");
-        }
-
-        [Test(Description = "Assert that the translation's implicit string conversion returns the expected text for various inputs.")]
-        public void Translation_ImplicitStringConversion([ValueSource(nameof(TranslationTests.Samples))] string text)
-        {
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", text);
-
-            // assert
-            if (translation.HasValue())
-                Assert.AreEqual(text, (string)translation, "The translation returned an unexpected value given a valid input.");
-            else
-                Assert.AreEqual(this.GetPlaceholderText("key"), (string)translation, "The translation returned an unexpected value given a null or empty input.");
-        }
-
-        [Test(Description = "Assert that the translation returns the expected text given a use-placeholder setting.")]
-        public void Translation_UsePlaceholder([Values(true, false)] bool value, [ValueSource(nameof(TranslationTests.Samples))] string text)
-        {
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", text).UsePlaceholder(value);
-
-            // assert
-            if (translation.HasValue())
-                Assert.AreEqual(text, translation.ToString(), "The translation returned an unexpected value given a valid input.");
-            else if (!value)
-                Assert.AreEqual(text, translation.ToString(), "The translation returned an unexpected value given a null or empty input with the placeholder disabled.");
-            else
-                Assert.AreEqual(this.GetPlaceholderText("key"), translation.ToString(), "The translation returned an unexpected value given a null or empty input with the placeholder enabled.");
-        }
-
-        [Test(Description = "Assert that the translation's Assert method throws the expected exception.")]
-        public void Translation_Assert([ValueSource(nameof(TranslationTests.Samples))] string text)
-        {
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", text);
-
-            // assert
-            if (translation.HasValue())
-                Assert.That(() => translation.Assert(), Throws.Nothing, "The assert unexpected threw an exception for a valid input.");
-            else
-                Assert.That(() => translation.Assert(), Throws.Exception.TypeOf<KeyNotFoundException>(), "The assert didn't throw an exception for invalid input.");
-        }
-
-        [Test(Description = "Assert that the translation returns the expected text after setting the default.")]
-        public void Translation_Default([ValueSource(nameof(TranslationTests.Samples))] string text, [ValueSource(nameof(TranslationTests.Samples))] string @default)
-        {
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", text).Default(@default);
-
-            // assert
-            if (!string.IsNullOrEmpty(text))
-                Assert.AreEqual(text, translation.ToString(), "The translation returned an unexpected value given a valid base text.");
-            else if (!string.IsNullOrEmpty(@default))
-                Assert.AreEqual(@default, translation.ToString(), "The translation returned an unexpected value given a null or empty base text, but valid default.");
-            else
-                Assert.AreEqual(this.GetPlaceholderText("key"), translation.ToString(), "The translation returned an unexpected value given a null or empty base and default text.");
-        }
-
-        /****
-        ** Translation tokens
-        ****/
-        [Test(Description = "Assert that multiple translation tokens are replaced correctly regardless of the token structure.")]
-        public void Translation_Tokens([Values("anonymous object", "class", "IDictionary<string, object>", "IDictionary<string, string>")] string structure)
-        {
-            // arrange
-            string start = Guid.NewGuid().ToString("N");
-            string middle = Guid.NewGuid().ToString("N");
-            string end = Guid.NewGuid().ToString("N");
-            const string input = "{{start}} tokens are properly replaced (including {{middle}} {{  MIDdlE}}) {{end}}";
-            string expected = $"{start} tokens are properly replaced (including {middle} {middle}) {end}";
-
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", input);
-            switch (structure)
-            {
-                case "anonymous object":
-                    translation = translation.Tokens(new { start, middle, end });
-                    break;
-
-                case "class":
-                    translation = translation.Tokens(new TokenModel { Start = start, Middle = middle, End = end });
-                    break;
-
-                case "IDictionary<string, object>":
-                    translation = translation.Tokens(new Dictionary<string, object> { ["start"] = start, ["middle"] = middle, ["end"] = end });
-                    break;
-
-                case "IDictionary<string, string>":
-                    translation = translation.Tokens(new Dictionary<string, string> { ["start"] = start, ["middle"] = middle, ["end"] = end });
-                    break;
-
-                default:
-                    throw new NotSupportedException($"Unknown structure '{structure}'.");
-            }
-
-            // assert
-            Assert.AreEqual(expected, translation.ToString(), "The translation returned an unexpected text.");
-        }
-
-        [Test(Description = "Assert that the translation can replace tokens in all valid formats.")]
-        [TestCase("{{value}}", "value")]
-        [TestCase("{{ value }}", "value")]
-        [TestCase("{{value       }}", "value")]
-        [TestCase("{{ the_value }}", "the_value")]
-        [TestCase("{{ the.value_here }}", "the.value_here")]
-        [TestCase("{{ the_value-here.... }}", "the_value-here....")]
-        [TestCase("{{ tHe_vALuE-HEre.... }}", "tHe_vALuE-HEre....")]
-        public void Translation_Tokens_ValidFormats(string text, string key)
-        {
-            // arrange
-            string value = Guid.NewGuid().ToString("N");
-
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", text).Tokens(new Dictionary<string, object> { [key] = value });
-
-            // assert
-            Assert.AreEqual(value, translation.ToString(), "The translation returned an unexpected value given a valid base text.");
-        }
-
-        [Test(Description = "Assert that translation tokens are case-insensitive and surrounding-whitespace-insensitive.")]
-        [TestCase("{{value}}", "value")]
-        [TestCase("{{VaLuE}}", "vAlUe")]
-        [TestCase("{{VaLuE   }}", "   vAlUe")]
-        public void Translation_Tokens_KeysAreNormalised(string text, string key)
-        {
-            // arrange
-            string value = Guid.NewGuid().ToString("N");
-
-            // act
-            Translation translation = new Translation("ModName", "pt-BR", "key", text).Tokens(new Dictionary<string, object> { [key] = value });
-
-            // assert
-            Assert.AreEqual(value, translation.ToString(), "The translation returned an unexpected value given a valid base text.");
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Set a translation helper's locale and assert that it was set correctly.</summary>
-        /// <param name="helper">The translation helper to change.</param>
-        /// <param name="locale">The expected locale.</param>
-        /// <param name="localeEnum">The expected game language code.</param>
-        private void AssertSetLocale(TranslationHelper helper, string locale, LocalizedContentManager.LanguageCode localeEnum)
-        {
-            helper.SetLocale(locale, localeEnum);
-            Assert.AreEqual(locale, helper.Locale, "The locale doesn't match the input value.");
-            Assert.AreEqual(localeEnum, helper.LocaleEnum, "The locale enum doesn't match the input value.");
-        }
-
-        /// <summary>Get sample raw translations to input.</summary>
-        private IDictionary<string, IDictionary<string, string>> GetSampleData()
-        {
-            return new Dictionary<string, IDictionary<string, string>>
-            {
-                ["default"] = new Dictionary<string, string>
-                {
-                    ["key A"] = "default A",
-                    ["key C"] = "default C"
-                },
-                ["en"] = new Dictionary<string, string>
-                {
-                    ["key A"] = "en A",
-                    ["key B"] = "en B"
-                },
-                ["en-US"] = new Dictionary<string, string>(),
-                ["zzz"] = new Dictionary<string, string>
-                {
-                    ["key A"] = "zzz A"
-                }
-            };
-        }
-
-        /// <summary>Get the expected translation output given <see cref="TranslationTests.GetSampleData"/>, based on the expected locale fallback.</summary>
-        private IDictionary<string, Translation[]> GetExpectedTranslations()
-        {
-            var expected = new Dictionary<string, Translation[]>
-            {
-                ["default"] = new[]
-                {
-                    new Translation(string.Empty, "default", "key A", "default A"),
-                    new Translation(string.Empty, "default", "key C", "default C")
-                },
-                ["en"] = new[]
-                {
-                    new Translation(string.Empty, "en", "key A", "en A"),
-                    new Translation(string.Empty, "en", "key B", "en B"),
-                    new Translation(string.Empty, "en", "key C", "default C")
-                },
-                ["zzz"] = new[]
-                {
-                    new Translation(string.Empty, "zzz", "key A", "zzz A"),
-                    new Translation(string.Empty, "zzz", "key C", "default C")
-                }
-            };
-            expected["en-us"] = expected["en"].ToArray();
-            return expected;
-        }
-
-        /// <summary>Get whether two translations have the same public values.</summary>
-        /// <param name="a">The first translation to compare.</param>
-        /// <param name="b">The second translation to compare.</param>
-        private bool CompareEquality(Translation a, Translation b)
-        {
-            return a.Key == b.Key && a.ToString() == b.ToString();
-        }
-
-        /// <summary>Get the default placeholder text when a translation is missing.</summary>
-        /// <param name="key">The translation key.</param>
-        private string GetPlaceholderText(string key)
-        {
-            return string.Format(Translation.PlaceholderText, key);
-        }
-
-
-        /*********
-        ** Test models
-        *********/
-        /// <summary>A model used to test token support.</summary>
-        private class TokenModel
-        {
-            /// <summary>A sample token property.</summary>
-            public string Start { get; set; }
-
-            /// <summary>A sample token property.</summary>
-            public string Middle { get; set; }
-
-            /// <summary>A sample token field.</summary>
-            public string End;
-        }
-    }
-}
diff --git a/src/SMAPI.Tests/Properties/AssemblyInfo.cs b/src/SMAPI.Tests/Properties/AssemblyInfo.cs
deleted file mode 100644
index 8b21e8fe..00000000
--- a/src/SMAPI.Tests/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("SMAPI.Tests")]
-[assembly: AssemblyDescription("")]
diff --git a/src/SMAPI.Tests/Sample.cs b/src/SMAPI.Tests/Sample.cs
deleted file mode 100644
index 6cd27707..00000000
--- a/src/SMAPI.Tests/Sample.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using System;
-
-namespace StardewModdingAPI.Tests
-{
-    /// <summary>Provides sample values for unit testing.</summary>
-    internal static class Sample
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>A random number generator.</summary>
-        private static readonly Random Random = new Random();
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>Get a sample string.</summary>
-        public static string String()
-        {
-            return Guid.NewGuid().ToString("N");
-        }
-
-        /// <summary>Get a sample integer.</summary>
-        public static int Int()
-        {
-            return Sample.Random.Next();
-        }
-    }
-}
diff --git a/src/SMAPI.Tests/StardewModdingAPI.Tests.csproj b/src/SMAPI.Tests/StardewModdingAPI.Tests.csproj
deleted file mode 100644
index 448f777f..00000000
--- a/src/SMAPI.Tests/StardewModdingAPI.Tests.csproj
+++ /dev/null
@@ -1,80 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
-    <ProjectGuid>{36CCB19E-92EB-48C7-9615-98EEFD45109B}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>StardewModdingAPI.Tests</RootNamespace>
-    <AssemblyName>StardewModdingAPI.Tests</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="Castle.Core" Version="4.3.1" />
-    <PackageReference Include="Moq" Version="4.10.1" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
-    <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.5.2" />
-    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.1" />
-    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Configuration" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs">
-      <Link>Properties\GlobalAssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="Toolkit\PathUtilitiesTests.cs" />
-    <Compile Include="Utilities\SemanticVersionTests.cs" />
-    <Compile Include="Utilities\SDateTests.cs" />
-    <Compile Include="Core\TranslationTests.cs" />
-    <Compile Include="Core\ModResolverTests.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Sample.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="app.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\SMAPI\StardewModdingAPI.csproj">
-      <Project>{f1a573b0-f436-472c-ae29-0b91ea6b9f8f}</Project>
-      <Name>StardewModdingAPI</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit.CoreInterfaces\StardewModdingAPI.Toolkit.CoreInterfaces.csproj">
-      <Project>{d5cfd923-37f1-4bc3-9be8-e506e202ac28}</Project>
-      <Name>StardewModdingAPI.Toolkit.CoreInterfaces</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit\StardewModdingAPI.Toolkit.csproj">
-      <Project>{ea5cfd2e-9453-4d29-b80f-8e0ea23f4ac6}</Project>
-      <Name>StardewModdingAPI.Toolkit</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\..\build\common.targets" />
-</Project>
\ No newline at end of file
diff --git a/src/SMAPI.Tests/Toolkit/PathUtilitiesTests.cs b/src/SMAPI.Tests/Toolkit/PathUtilitiesTests.cs
deleted file mode 100644
index 229b9a14..00000000
--- a/src/SMAPI.Tests/Toolkit/PathUtilitiesTests.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-using NUnit.Framework;
-using StardewModdingAPI.Toolkit.Utilities;
-
-namespace StardewModdingAPI.Tests.Toolkit
-{
-    /// <summary>Unit tests for <see cref="PathUtilities"/>.</summary>
-    [TestFixture]
-    public class PathUtilitiesTests
-    {
-        /*********
-        ** Unit tests
-        *********/
-        [Test(Description = "Assert that GetSegments returns the expected values.")]
-        [TestCase("", ExpectedResult = "")]
-        [TestCase("/", ExpectedResult = "")]
-        [TestCase("///", ExpectedResult = "")]
-        [TestCase("/usr/bin", ExpectedResult = "usr|bin")]
-        [TestCase("/usr//bin//", ExpectedResult = "usr|bin")]
-        [TestCase("/usr//bin//.././boop.exe", ExpectedResult = "usr|bin|..|.|boop.exe")]
-        [TestCase(@"C:", ExpectedResult = "C:")]
-        [TestCase(@"C:/boop", ExpectedResult = "C:|boop")]
-        [TestCase(@"C:\boop\/usr//bin//.././boop.exe", ExpectedResult = "C:|boop|usr|bin|..|.|boop.exe")]
-        public string GetSegments(string path)
-        {
-            return string.Join("|", PathUtilities.GetSegments(path));
-        }
-
-        [Test(Description = "Assert that NormalisePathSeparators returns the expected values.")]
-#if SMAPI_FOR_WINDOWS
-        [TestCase("", ExpectedResult = "")]
-        [TestCase("/", ExpectedResult = "")]
-        [TestCase("///", ExpectedResult = "")]
-        [TestCase("/usr/bin", ExpectedResult = @"usr\bin")]
-        [TestCase("/usr//bin//", ExpectedResult = @"usr\bin")]
-        [TestCase("/usr//bin//.././boop.exe", ExpectedResult = @"usr\bin\..\.\boop.exe")]
-        [TestCase("C:", ExpectedResult = "C:")]
-        [TestCase("C:/boop", ExpectedResult = @"C:\boop")]
-        [TestCase(@"C:\usr\bin//.././boop.exe", ExpectedResult = @"C:\usr\bin\..\.\boop.exe")]
-#else
-        [TestCase("", ExpectedResult = "")]
-        [TestCase("/", ExpectedResult = "/")]
-        [TestCase("///", ExpectedResult = "/")]
-        [TestCase("/usr/bin", ExpectedResult = "/usr/bin")]
-        [TestCase("/usr//bin//", ExpectedResult = "/usr/bin")]
-        [TestCase("/usr//bin//.././boop.exe", ExpectedResult = "/usr/bin/.././boop.exe")]
-        [TestCase("C:", ExpectedResult = "C:")]
-        [TestCase("C:/boop", ExpectedResult = "C:/boop")]
-        [TestCase(@"C:\usr\bin//.././boop.exe", ExpectedResult = "C:/usr/bin/.././boop.exe")]
-#endif
-        public string NormalisePathSeparators(string path)
-        {
-            return PathUtilities.NormalisePathSeparators(path);
-        }
-
-        [Test(Description = "Assert that GetRelativePath returns the expected values.")]
-#if SMAPI_FOR_WINDOWS
-        [TestCase(@"C:\", @"C:\", ExpectedResult = "./")]
-        [TestCase(@"C:\grandparent\parent\child", @"C:\grandparent\parent\sibling", ExpectedResult = @"..\sibling")]
-        [TestCase(@"C:\grandparent\parent\child", @"C:\cousin\file.exe", ExpectedResult = @"..\..\..\cousin\file.exe")]
-#else
-        [TestCase("/", "/", ExpectedResult = "./")]
-        [TestCase("/grandparent/parent/child", "/grandparent/parent/sibling", ExpectedResult = "../sibling")]
-        [TestCase("/grandparent/parent/child", "/cousin/file.exe", ExpectedResult = "../../../cousin/file.exe")]
-#endif
-        public string GetRelativePath(string sourceDir, string targetPath)
-        {
-            return PathUtilities.GetRelativePath(sourceDir, targetPath);
-        }
-    }
-}
diff --git a/src/SMAPI.Tests/Utilities/SDateTests.cs b/src/SMAPI.Tests/Utilities/SDateTests.cs
deleted file mode 100644
index 1f31168e..00000000
--- a/src/SMAPI.Tests/Utilities/SDateTests.cs
+++ /dev/null
@@ -1,310 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text.RegularExpressions;
-using NUnit.Framework;
-using StardewModdingAPI.Utilities;
-
-namespace StardewModdingAPI.Tests.Utilities
-{
-    /// <summary>Unit tests for <see cref="SDate"/>.</summary>
-    [TestFixture]
-    internal class SDateTests
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>All valid seasons.</summary>
-        private static readonly string[] ValidSeasons = { "spring", "summer", "fall", "winter" };
-
-        /// <summary>All valid days of a month.</summary>
-        private static readonly int[] ValidDays = Enumerable.Range(1, 28).ToArray();
-
-        /// <summary>Sample relative dates for test cases.</summary>
-        private static class Dates
-        {
-            /// <summary>The base date to which other dates are relative.</summary>
-            public const string Now = "02 summer Y2";
-
-            /// <summary>The day before <see cref="Now"/>.</summary>
-            public const string PrevDay = "01 summer Y2";
-
-            /// <summary>The month before <see cref="Now"/>.</summary>
-            public const string PrevMonth = "02 spring Y2";
-
-            /// <summary>The year before <see cref="Now"/>.</summary>
-            public const string PrevYear = "02 summer Y1";
-
-            /// <summary>The day after <see cref="Now"/>.</summary>
-            public const string NextDay = "03 summer Y2";
-
-            /// <summary>The month after <see cref="Now"/>.</summary>
-            public const string NextMonth = "02 fall Y2";
-
-            /// <summary>The year after <see cref="Now"/>.</summary>
-            public const string NextYear = "02 summer Y3";
-        }
-
-
-        /*********
-        ** Unit tests
-        *********/
-        /****
-        ** Constructor
-        ****/
-        [Test(Description = "Assert that the constructor sets the expected values for all valid dates.")]
-        public void Constructor_SetsExpectedValues([ValueSource(nameof(SDateTests.ValidSeasons))] string season, [ValueSource(nameof(SDateTests.ValidDays))] int day, [Values(1, 2, 100)] int year)
-        {
-            // act
-            SDate date = new SDate(day, season, year);
-
-            // assert
-            Assert.AreEqual(day, date.Day);
-            Assert.AreEqual(season, date.Season);
-            Assert.AreEqual(year, date.Year);
-        }
-
-        [Test(Description = "Assert that the constructor throws an exception if the values are invalid.")]
-        [TestCase(01, "Spring", 1)] // seasons are case-sensitive
-        [TestCase(01, "springs", 1)] // invalid season name
-        [TestCase(-1, "spring", 1)] // day < 0
-        [TestCase(0, "spring", 1)] // day zero
-        [TestCase(0, "spring", 2)] // day zero
-        [TestCase(29, "spring", 1)] // day > 28
-        [TestCase(01, "spring", -1)] // year < 1
-        [TestCase(01, "spring", 0)] // year < 1
-        [SuppressMessage("ReSharper", "AssignmentIsFullyDiscarded", Justification = "Deliberate for unit test.")]
-        public void Constructor_RejectsInvalidValues(int day, string season, int year)
-        {
-            // act & assert
-            Assert.Throws<ArgumentException>(() => _ = new SDate(day, season, year), "Constructing the invalid date didn't throw the expected exception.");
-        }
-
-        /****
-        ** DayOfWeek
-        ****/
-        [Test(Description = "Assert the day of week.")]
-        [TestCase("01 spring Y1", ExpectedResult = System.DayOfWeek.Monday)]
-        [TestCase("02 spring Y2", ExpectedResult = System.DayOfWeek.Tuesday)]
-        [TestCase("03 spring Y3", ExpectedResult = System.DayOfWeek.Wednesday)]
-        [TestCase("04 spring Y4", ExpectedResult = System.DayOfWeek.Thursday)]
-        [TestCase("05 spring Y5", ExpectedResult = System.DayOfWeek.Friday)]
-        [TestCase("06 spring Y6", ExpectedResult = System.DayOfWeek.Saturday)]
-        [TestCase("07 spring Y7", ExpectedResult = System.DayOfWeek.Sunday)]
-        [TestCase("08 summer Y8", ExpectedResult = System.DayOfWeek.Monday)]
-        [TestCase("09 summer Y9", ExpectedResult = System.DayOfWeek.Tuesday)]
-        [TestCase("10 summer Y10", ExpectedResult = System.DayOfWeek.Wednesday)]
-        [TestCase("11 summer Y11", ExpectedResult = System.DayOfWeek.Thursday)]
-        [TestCase("12 summer Y12", ExpectedResult = System.DayOfWeek.Friday)]
-        [TestCase("13 summer Y13", ExpectedResult = System.DayOfWeek.Saturday)]
-        [TestCase("14 summer Y14", ExpectedResult = System.DayOfWeek.Sunday)]
-        [TestCase("15 fall Y15", ExpectedResult = System.DayOfWeek.Monday)]
-        [TestCase("16 fall Y16", ExpectedResult = System.DayOfWeek.Tuesday)]
-        [TestCase("17 fall Y17", ExpectedResult = System.DayOfWeek.Wednesday)]
-        [TestCase("18 fall Y18", ExpectedResult = System.DayOfWeek.Thursday)]
-        [TestCase("19 fall Y19", ExpectedResult = System.DayOfWeek.Friday)]
-        [TestCase("20 fall Y20", ExpectedResult = System.DayOfWeek.Saturday)]
-        [TestCase("21 fall Y21", ExpectedResult = System.DayOfWeek.Sunday)]
-        [TestCase("22 winter Y22", ExpectedResult = System.DayOfWeek.Monday)]
-        [TestCase("23 winter Y23", ExpectedResult = System.DayOfWeek.Tuesday)]
-        [TestCase("24 winter Y24", ExpectedResult = System.DayOfWeek.Wednesday)]
-        [TestCase("25 winter Y25", ExpectedResult = System.DayOfWeek.Thursday)]
-        [TestCase("26 winter Y26", ExpectedResult = System.DayOfWeek.Friday)]
-        [TestCase("27 winter Y27", ExpectedResult = System.DayOfWeek.Saturday)]
-        [TestCase("28 winter Y28" + "", ExpectedResult = System.DayOfWeek.Sunday)]
-        public DayOfWeek DayOfWeek(string dateStr)
-        {
-            // act
-            return this.GetDate(dateStr).DayOfWeek;
-        }
-
-        /****
-        ** DaysSinceStart
-        ****/
-        [Test(Description = "Assert the number of days since 01 spring Y1 (inclusive).")]
-        [TestCase("01 spring Y1", ExpectedResult = 1)]
-        [TestCase("02 spring Y1", ExpectedResult = 2)]
-        [TestCase("28 spring Y1", ExpectedResult = 28)]
-        [TestCase("01 summer Y1", ExpectedResult = 29)]
-        [TestCase("01 summer Y2", ExpectedResult = 141)]
-        public int DaysSinceStart(string dateStr)
-        {
-            // act
-            return this.GetDate(dateStr).DaysSinceStart;
-        }
-
-        /****
-        ** ToString
-        ****/
-        [Test(Description = "Assert that ToString returns the expected string.")]
-        [TestCase("14 spring Y1", ExpectedResult = "14 spring Y1")]
-        [TestCase("01 summer Y16", ExpectedResult = "01 summer Y16")]
-        [TestCase("28 fall Y10", ExpectedResult = "28 fall Y10")]
-        [TestCase("01 winter Y1", ExpectedResult = "01 winter Y1")]
-        public string ToString(string dateStr)
-        {
-            return this.GetDate(dateStr).ToString();
-        }
-
-        /****
-        ** AddDays
-        ****/
-        [Test(Description = "Assert that AddDays returns the expected date.")]
-        [TestCase("01 spring Y1", 15, ExpectedResult = "16 spring Y1")] // day transition
-        [TestCase("01 spring Y1", 28, ExpectedResult = "01 summer Y1")] // season transition
-        [TestCase("01 spring Y1", 28 * 4, ExpectedResult = "01 spring Y2")] // year transition
-        [TestCase("01 spring Y1", 28 * 7 + 17, ExpectedResult = "18 winter Y2")] // year transition
-        [TestCase("15 spring Y1", -14, ExpectedResult = "01 spring Y1")] // negative day transition
-        [TestCase("15 summer Y1", -28, ExpectedResult = "15 spring Y1")] // negative season transition
-        [TestCase("15 summer Y2", -28 * 4, ExpectedResult = "15 summer Y1")] // negative year transition
-        [TestCase("01 spring Y3", -(28 * 7 + 17), ExpectedResult = "12 spring Y1")] // negative year transition
-        [TestCase("06 fall Y2", 50, ExpectedResult = "28 winter Y3")] // test for zero-index errors
-        [TestCase("06 fall Y2", 51, ExpectedResult = "01 spring Y3")] // test for zero-index errors
-        public string AddDays(string dateStr, int addDays)
-        {
-            return this.GetDate(dateStr).AddDays(addDays).ToString();
-        }
-
-        /****
-        ** GetHashCode
-        ****/
-        [Test(Description = "Assert that GetHashCode returns a unique ordered value for every date.")]
-        public void GetHashCode_ReturnsUniqueOrderedValue()
-        {
-            IDictionary<int, SDate> hashes = new Dictionary<int, SDate>();
-            int lastHash = int.MinValue;
-            for (int year = 1; year <= 4; year++)
-            {
-                foreach (string season in SDateTests.ValidSeasons)
-                {
-                    foreach (int day in SDateTests.ValidDays)
-                    {
-                        SDate date = new SDate(day, season, year);
-                        int hash = date.GetHashCode();
-                        if (hashes.TryGetValue(hash, out SDate otherDate))
-                            Assert.Fail($"Received identical hash code {hash} for dates {otherDate} and {date}.");
-                        if (hash < lastHash)
-                            Assert.Fail($"Received smaller hash code for date {date} ({hash}) relative to {hashes[lastHash]} ({lastHash}).");
-
-                        lastHash = hash;
-                        hashes[hash] = date;
-                    }
-                }
-            }
-        }
-
-        [Test(Description = "Assert that the == operator returns the expected values. We only need a few test cases, since it's based on GetHashCode which is tested more thoroughly.")]
-        [TestCase(Dates.Now, null, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevDay, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevMonth, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevYear, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.Now, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextDay, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextMonth, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextYear, ExpectedResult = false)]
-        public bool Operators_Equals(string now, string other)
-        {
-            return this.GetDate(now) == this.GetDate(other);
-        }
-
-        [Test(Description = "Assert that the != operator returns the expected values. We only need a few test cases, since it's based on GetHashCode which is tested more thoroughly.")]
-        [TestCase(Dates.Now, null, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.PrevDay, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.PrevMonth, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.PrevYear, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.Now, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextDay, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextMonth, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextYear, ExpectedResult = true)]
-        public bool Operators_NotEquals(string now, string other)
-        {
-            return this.GetDate(now) != this.GetDate(other);
-        }
-
-        [Test(Description = "Assert that the < operator returns the expected values. We only need a few test cases, since it's based on GetHashCode which is tested more thoroughly.")]
-        [TestCase(Dates.Now, null, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevDay, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevMonth, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevYear, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.Now, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextDay, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextMonth, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextYear, ExpectedResult = true)]
-        public bool Operators_LessThan(string now, string other)
-        {
-            return this.GetDate(now) < this.GetDate(other);
-        }
-
-        [Test(Description = "Assert that the <= operator returns the expected values. We only need a few test cases, since it's based on GetHashCode which is tested more thoroughly.")]
-        [TestCase(Dates.Now, null, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevDay, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevMonth, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevYear, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.Now, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextDay, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextMonth, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.NextYear, ExpectedResult = true)]
-        public bool Operators_LessThanOrEqual(string now, string other)
-        {
-            return this.GetDate(now) <= this.GetDate(other);
-        }
-
-        [Test(Description = "Assert that the > operator returns the expected values. We only need a few test cases, since it's based on GetHashCode which is tested more thoroughly.")]
-        [TestCase(Dates.Now, null, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevDay, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.PrevMonth, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.PrevYear, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.Now, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextDay, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextMonth, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextYear, ExpectedResult = false)]
-        public bool Operators_MoreThan(string now, string other)
-        {
-            return this.GetDate(now) > this.GetDate(other);
-        }
-
-        [Test(Description = "Assert that the > operator returns the expected values. We only need a few test cases, since it's based on GetHashCode which is tested more thoroughly.")]
-        [TestCase(Dates.Now, null, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.PrevDay, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.PrevMonth, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.PrevYear, ExpectedResult = true)]
-        [TestCase(Dates.Now, Dates.Now, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextDay, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextMonth, ExpectedResult = false)]
-        [TestCase(Dates.Now, Dates.NextYear, ExpectedResult = false)]
-        public bool Operators_MoreThanOrEqual(string now, string other)
-        {
-            return this.GetDate(now) > this.GetDate(other);
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Convert a string date into a game date, to make unit tests easier to read.</summary>
-        /// <param name="dateStr">The date string like "dd MMMM yy".</param>
-        private SDate GetDate(string dateStr)
-        {
-            if (dateStr == null)
-                return null;
-
-            void Fail(string reason) => throw new AssertionException($"Couldn't parse date '{dateStr}' because {reason}.");
-
-            // parse
-            Match match = Regex.Match(dateStr, @"^(?<day>\d+) (?<season>\w+) Y(?<year>\d+)$");
-            if (!match.Success)
-                Fail("it doesn't match expected pattern (should be like 28 spring Y1)");
-
-            // extract parts
-            string season = match.Groups["season"].Value;
-            if (!int.TryParse(match.Groups["day"].Value, out int day))
-                Fail($"'{match.Groups["day"].Value}' couldn't be parsed as a day.");
-            if (!int.TryParse(match.Groups["year"].Value, out int year))
-                Fail($"'{match.Groups["year"].Value}' couldn't be parsed as a year.");
-
-            // build date
-            return new SDate(day, season, year);
-        }
-    }
-}
diff --git a/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs b/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
deleted file mode 100644
index 2e7719eb..00000000
--- a/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
+++ /dev/null
@@ -1,337 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using Newtonsoft.Json;
-using NUnit.Framework;
-using StardewModdingAPI.Framework;
-
-namespace StardewModdingAPI.Tests.Utilities
-{
-    /// <summary>Unit tests for <see cref="SemanticVersion"/>.</summary>
-    [TestFixture]
-    internal class SemanticVersionTests
-    {
-        /*********
-        ** Unit tests
-        *********/
-        /****
-        ** Constructor
-        ****/
-        [Test(Description = "Assert that the constructor sets the expected values for all valid versions when constructed from a string.")]
-        [TestCase("1.0", ExpectedResult = "1.0")]
-        [TestCase("1.0.0", ExpectedResult = "1.0")]
-        [TestCase("3000.4000.5000", ExpectedResult = "3000.4000.5000")]
-        [TestCase("1.2-some-tag.4", ExpectedResult = "1.2-some-tag.4")]
-        [TestCase("1.2.3-some-tag.4", ExpectedResult = "1.2.3-some-tag.4")]
-        [TestCase("1.2.3-SoME-tAg.4", ExpectedResult = "1.2.3-SoME-tAg.4")]
-        [TestCase("1.2.3-some-tag.4      ", ExpectedResult = "1.2.3-some-tag.4")]
-        public string Constructor_FromString(string input)
-        {
-            return new SemanticVersion(input).ToString();
-        }
-
-        [Test(Description = "Assert that the constructor sets the expected values for all valid versions when constructed from the individual numbers.")]
-        [TestCase(1, 0, 0, null, ExpectedResult = "1.0")]
-        [TestCase(3000, 4000, 5000, null, ExpectedResult = "3000.4000.5000")]
-        [TestCase(1, 2, 3, "", ExpectedResult = "1.2.3")]
-        [TestCase(1, 2, 3, "    ", ExpectedResult = "1.2.3")]
-        [TestCase(1, 2, 3, "0", ExpectedResult = "1.2.3-0")]
-        [TestCase(1, 2, 3, "some-tag.4", ExpectedResult = "1.2.3-some-tag.4")]
-        [TestCase(1, 2, 3, "sOMe-TaG.4", ExpectedResult = "1.2.3-sOMe-TaG.4")]
-        [TestCase(1, 2, 3, "some-tag.4   ", ExpectedResult = "1.2.3-some-tag.4")]
-        public string Constructor_FromParts(int major, int minor, int patch, string tag)
-        {
-            // act
-            ISemanticVersion version = new SemanticVersion(major, minor, patch, tag);
-
-            // assert
-            Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value.");
-            Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value.");
-            Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value.");
-            Assert.AreEqual(string.IsNullOrWhiteSpace(tag) ? null : tag.Trim(), version.PrereleaseTag, "The tag doesn't match the given value.");
-            return version.ToString();
-        }
-
-        [Test(Description = "Assert that the constructor throws the expected exception for invalid versions when constructed from the individual numbers.")]
-        [TestCase(0, 0, 0, null)]
-        [TestCase(-1, 0, 0, null)]
-        [TestCase(0, -1, 0, null)]
-        [TestCase(0, 0, -1, null)]
-        [TestCase(1, 0, 0, "-tag")]
-        [TestCase(1, 0, 0, "tag spaces")]
-        [TestCase(1, 0, 0, "tag~")]
-        public void Constructor_FromParts_WithInvalidValues(int major, int minor, int patch, string tag)
-        {
-            this.AssertAndLogException<FormatException>(() => new SemanticVersion(major, minor, patch, tag));
-        }
-
-        [Test(Description = "Assert that the constructor sets the expected values for all valid versions when constructed from an assembly version.")]
-        [TestCase(1, 0, 0, ExpectedResult = "1.0")]
-        [TestCase(1, 2, 3, ExpectedResult = "1.2.3")]
-        [TestCase(3000, 4000, 5000, ExpectedResult = "3000.4000.5000")]
-        public string Constructor_FromAssemblyVersion(int major, int minor, int patch)
-        {
-            // act
-            ISemanticVersion version = new SemanticVersion(new Version(major, minor, patch));
-
-            // assert
-            Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value.");
-            Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value.");
-            Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value.");
-            return version.ToString();
-        }
-
-        [Test(Description = "Assert that the constructor throws the expected exception for invalid versions.")]
-        [TestCase(null)]
-        [TestCase("")]
-        [TestCase("   ")]
-        [TestCase("1")]
-        [TestCase("01.0")]
-        [TestCase("1.05")]
-        [TestCase("1.5.06")] // leading zeros specifically prohibited by spec
-        [TestCase("1.2.3.4")]
-        [TestCase("1.apple")]
-        [TestCase("1.2.apple")]
-        [TestCase("1.2.3.apple")]
-        [TestCase("1..2..3")]
-        [TestCase("1.2.3-")]
-        [TestCase("1.2.3--some-tag")]
-        [TestCase("1.2.3-some-tag...")]
-        [TestCase("1.2.3-some-tag...4")]
-        [TestCase("apple")]
-        [TestCase("-apple")]
-        [TestCase("-5")]
-        public void Constructor_FromString_WithInvalidValues(string input)
-        {
-            if (input == null)
-                this.AssertAndLogException<ArgumentNullException>(() => new SemanticVersion(input));
-            else
-                this.AssertAndLogException<FormatException>(() => new SemanticVersion(input));
-        }
-
-        /****
-        ** CompareTo
-        ****/
-        [Test(Description = "Assert that version.CompareTo returns the expected value.")]
-        // equal
-        [TestCase("0.5.7", "0.5.7", ExpectedResult = 0)]
-        [TestCase("1.0", "1.0", ExpectedResult = 0)]
-        [TestCase("1.0-beta", "1.0-beta", ExpectedResult = 0)]
-        [TestCase("1.0-beta.10", "1.0-beta.10", ExpectedResult = 0)]
-        [TestCase("1.0-beta", "1.0-beta   ", ExpectedResult = 0)]
-
-        // less than
-        [TestCase("0.5.7", "0.5.8", ExpectedResult = -1)]
-        [TestCase("1.0", "1.1", ExpectedResult = -1)]
-        [TestCase("1.0-beta", "1.0", ExpectedResult = -1)]
-        [TestCase("1.0-beta", "1.0-beta.2", ExpectedResult = -1)]
-        [TestCase("1.0-beta.1", "1.0-beta.2", ExpectedResult = -1)]
-        [TestCase("1.0-beta.2", "1.0-beta.10", ExpectedResult = -1)]
-        [TestCase("1.0-beta-2", "1.0-beta-10", ExpectedResult = -1)]
-        [TestCase("1.0-unofficial.1", "1.0-beta.1", ExpectedResult = -1)] // special case: 'unofficial' has lower priority than official releases
-
-        // more than
-        [TestCase("0.5.8", "0.5.7", ExpectedResult = 1)]
-        [TestCase("1.1", "1.0", ExpectedResult = 1)]
-        [TestCase("1.0", "1.0-beta", ExpectedResult = 1)]
-        [TestCase("1.0-beta.2", "1.0-beta", ExpectedResult = 1)]
-        [TestCase("1.0-beta.2", "1.0-beta.1", ExpectedResult = 1)]
-        [TestCase("1.0-beta.10", "1.0-beta.2", ExpectedResult = 1)]
-        [TestCase("1.0-beta-10", "1.0-beta-2", ExpectedResult = 1)]
-        public int CompareTo(string versionStrA, string versionStrB)
-        {
-            ISemanticVersion versionA = new SemanticVersion(versionStrA);
-            ISemanticVersion versionB = new SemanticVersion(versionStrB);
-            return versionA.CompareTo(versionB);
-        }
-
-        /****
-        ** IsOlderThan
-        ****/
-        [Test(Description = "Assert that version.IsOlderThan returns the expected value.")]
-        // keep test cases in sync with CompareTo for simplicity.
-        // equal
-        [TestCase("0.5.7", "0.5.7", ExpectedResult = false)]
-        [TestCase("1.0", "1.0", ExpectedResult = false)]
-        [TestCase("1.0-beta", "1.0-beta", ExpectedResult = false)]
-        [TestCase("1.0-beta.10", "1.0-beta.10", ExpectedResult = false)]
-        [TestCase("1.0-beta", "1.0-beta   ", ExpectedResult = false)]
-
-        // less than
-        [TestCase("0.5.7", "0.5.8", ExpectedResult = true)]
-        [TestCase("1.0", "1.1", ExpectedResult = true)]
-        [TestCase("1.0-beta", "1.0", ExpectedResult = true)]
-        [TestCase("1.0-beta", "1.0-beta.2", ExpectedResult = true)]
-        [TestCase("1.0-beta.1", "1.0-beta.2", ExpectedResult = true)]
-        [TestCase("1.0-beta.2", "1.0-beta.10", ExpectedResult = true)]
-        [TestCase("1.0-beta-2", "1.0-beta-10", ExpectedResult = true)]
-
-        // more than
-        [TestCase("0.5.8", "0.5.7", ExpectedResult = false)]
-        [TestCase("1.1", "1.0", ExpectedResult = false)]
-        [TestCase("1.0", "1.0-beta", ExpectedResult = false)]
-        [TestCase("1.0-beta.2", "1.0-beta", ExpectedResult = false)]
-        [TestCase("1.0-beta.2", "1.0-beta.1", ExpectedResult = false)]
-        [TestCase("1.0-beta.10", "1.0-beta.2", ExpectedResult = false)]
-        [TestCase("1.0-beta-10", "1.0-beta-2", ExpectedResult = false)]
-        public bool IsOlderThan(string versionStrA, string versionStrB)
-        {
-            ISemanticVersion versionA = new SemanticVersion(versionStrA);
-            ISemanticVersion versionB = new SemanticVersion(versionStrB);
-            return versionA.IsOlderThan(versionB);
-        }
-
-        /****
-        ** IsNewerThan
-        ****/
-        [Test(Description = "Assert that version.IsNewerThan returns the expected value.")]
-        // keep test cases in sync with CompareTo for simplicity.
-        // equal
-        [TestCase("0.5.7", "0.5.7", ExpectedResult = false)]
-        [TestCase("1.0", "1.0", ExpectedResult = false)]
-        [TestCase("1.0-beta", "1.0-beta", ExpectedResult = false)]
-        [TestCase("1.0-beta.10", "1.0-beta.10", ExpectedResult = false)]
-        [TestCase("1.0-beta", "1.0-beta   ", ExpectedResult = false)]
-
-        // less than
-        [TestCase("0.5.7", "0.5.8", ExpectedResult = false)]
-        [TestCase("1.0", "1.1", ExpectedResult = false)]
-        [TestCase("1.0-beta", "1.0", ExpectedResult = false)]
-        [TestCase("1.0-beta", "1.0-beta.2", ExpectedResult = false)]
-        [TestCase("1.0-beta.1", "1.0-beta.2", ExpectedResult = false)]
-        [TestCase("1.0-beta.2", "1.0-beta.10", ExpectedResult = false)]
-        [TestCase("1.0-beta-2", "1.0-beta-10", ExpectedResult = false)]
-
-        // more than
-        [TestCase("0.5.8", "0.5.7", ExpectedResult = true)]
-        [TestCase("1.1", "1.0", ExpectedResult = true)]
-        [TestCase("1.0", "1.0-beta", ExpectedResult = true)]
-        [TestCase("1.0-beta.2", "1.0-beta", ExpectedResult = true)]
-        [TestCase("1.0-beta.2", "1.0-beta.1", ExpectedResult = true)]
-        [TestCase("1.0-beta.10", "1.0-beta.2", ExpectedResult = true)]
-        [TestCase("1.0-beta-10", "1.0-beta-2", ExpectedResult = true)]
-        public bool IsNewerThan(string versionStrA, string versionStrB)
-        {
-            ISemanticVersion versionA = new SemanticVersion(versionStrA);
-            ISemanticVersion versionB = new SemanticVersion(versionStrB);
-            return versionA.IsNewerThan(versionB);
-        }
-
-        /****
-        ** IsBetween
-        ****/
-        [Test(Description = "Assert that version.IsNewerThan returns the expected value.")]
-        // is between
-        [TestCase("0.5.7-beta.3", "0.5.7-beta.3", "0.5.7-beta.3", ExpectedResult = true)]
-        [TestCase("1.0", "1.0", "1.1", ExpectedResult = true)]
-        [TestCase("1.0", "1.0-beta", "1.1", ExpectedResult = true)]
-        [TestCase("1.0", "0.5", "1.1", ExpectedResult = true)]
-        [TestCase("1.0-beta.2", "1.0-beta.1", "1.0-beta.3", ExpectedResult = true)]
-        [TestCase("1.0-beta-2", "1.0-beta-1", "1.0-beta-3", ExpectedResult = true)]
-
-        // is not between
-        [TestCase("1.0-beta", "1.0", "1.1", ExpectedResult = false)]
-        [TestCase("1.0", "1.1", "1.0", ExpectedResult = false)]
-        [TestCase("1.0-beta.2", "1.1", "1.0", ExpectedResult = false)]
-        [TestCase("1.0-beta.2", "1.0-beta.10", "1.0-beta.3", ExpectedResult = false)]
-        [TestCase("1.0-beta-2", "1.0-beta-10", "1.0-beta-3", ExpectedResult = false)]
-        public bool IsBetween(string versionStr, string lowerStr, string upperStr)
-        {
-            ISemanticVersion lower = new SemanticVersion(lowerStr);
-            ISemanticVersion upper = new SemanticVersion(upperStr);
-            ISemanticVersion version = new SemanticVersion(versionStr);
-            return version.IsBetween(lower, upper);
-        }
-
-        /****
-        ** Serialisable
-        ****/
-        [Test(Description = "Assert that SemanticVersion can be round-tripped through JSON with no special configuration.")]
-        [TestCase("1.0")]
-        public void Serialisable(string versionStr)
-        {
-            // act
-            string json = JsonConvert.SerializeObject(new SemanticVersion(versionStr));
-            SemanticVersion after = JsonConvert.DeserializeObject<SemanticVersion>(json);
-
-            // assert
-            Assert.IsNotNull(after, "The semantic version after deserialisation is unexpectedly null.");
-            Assert.AreEqual(versionStr, after.ToString(), "The semantic version after deserialisation doesn't match the input version.");
-        }
-
-        /****
-        ** GameVersion
-        ****/
-        [Test(Description = "Assert that the GameVersion subclass correctly parses legacy game versions.")]
-        [TestCase("1.0")]
-        [TestCase("1.01")]
-        [TestCase("1.02")]
-        [TestCase("1.03")]
-        [TestCase("1.04")]
-        [TestCase("1.05")]
-        [TestCase("1.051")]
-        [TestCase("1.051b")]
-        [TestCase("1.06")]
-        [TestCase("1.07")]
-        [TestCase("1.07a")]
-        [TestCase("1.08")]
-        [TestCase("1.1")]
-        [TestCase("1.11")]
-        [TestCase("1.2")]
-        [TestCase("1.2.15")]
-        public void GameVersion(string versionStr)
-        {
-            // act
-            GameVersion version = new GameVersion(versionStr);
-
-            // assert
-            Assert.AreEqual(versionStr, version.ToString(), "The game version did not round-trip to the same value.");
-            Assert.IsTrue(version.IsOlderThan(new SemanticVersion("1.2.30")), "The game version should be considered older than the later semantic versions.");
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Assert that the expected exception type is thrown, and log the action output and thrown exception.</summary>
-        /// <typeparam name="T">The expected exception type.</typeparam>
-        /// <param name="action">The action which may throw the exception.</param>
-        /// <param name="message">The message to log if the expected exception isn't thrown.</param>
-        [SuppressMessage("ReSharper", "UnusedParameter.Local", Justification = "The message argument is deliberately only used in precondition checks since this is an assertion method.")]
-        private void AssertAndLogException<T>(Func<object> action, string message = null)
-            where T : Exception
-        {
-            this.AssertAndLogException<T>(() =>
-            {
-                object result = action();
-                TestContext.WriteLine($"Func result: {result}");
-            });
-        }
-
-        /// <summary>Assert that the expected exception type is thrown, and log the thrown exception.</summary>
-        /// <typeparam name="T">The expected exception type.</typeparam>
-        /// <param name="action">The action which may throw the exception.</param>
-        /// <param name="message">The message to log if the expected exception isn't thrown.</param>
-        [SuppressMessage("ReSharper", "UnusedParameter.Local", Justification = "The message argument is deliberately only used in precondition checks since this is an assertion method.")]
-        private void AssertAndLogException<T>(Action action, string message = null)
-            where T : Exception
-        {
-            try
-            {
-                action();
-            }
-            catch (T ex)
-            {
-                TestContext.WriteLine($"Exception thrown:\n{ex}");
-                return;
-            }
-            catch (Exception ex) when (!(ex is AssertionException))
-            {
-                TestContext.WriteLine($"Exception thrown:\n{ex}");
-                Assert.Fail(message ?? $"Didn't throw the expected exception; expected {typeof(T).FullName}, got {ex.GetType().FullName}.");
-            }
-
-            // no exception thrown
-            Assert.Fail(message ?? "Didn't throw an exception.");
-        }
-    }
-}
diff --git a/src/SMAPI.Tests/app.config b/src/SMAPI.Tests/app.config
deleted file mode 100644
index 673b91c4..00000000
--- a/src/SMAPI.Tests/app.config
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Threading.Tasks.Extensions" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.2.0.0" newVersion="4.2.0.0" />
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.ValueTuple" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-</configuration>
\ No newline at end of file
diff --git a/src/SMAPI.Web/Controllers/IndexController.cs b/src/SMAPI.Web/Controllers/IndexController.cs
deleted file mode 100644
index 4e3602d5..00000000
--- a/src/SMAPI.Web/Controllers/IndexController.cs
+++ /dev/null
@@ -1,198 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using HtmlAgilityPack;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Options;
-using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Web.Framework.Clients.GitHub;
-using StardewModdingAPI.Web.Framework.ConfigModels;
-using StardewModdingAPI.Web.ViewModels;
-
-namespace StardewModdingAPI.Web.Controllers
-{
-    /// <summary>Provides an info/download page about SMAPI.</summary>
-    [Route("")]
-    [Route("install")]
-    internal class IndexController : Controller
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The site config settings.</summary>
-        private readonly SiteConfig SiteConfig;
-
-        /// <summary>The cache in which to store release data.</summary>
-        private readonly IMemoryCache Cache;
-
-        /// <summary>The GitHub API client.</summary>
-        private readonly IGitHubClient GitHub;
-
-        /// <summary>The cache time for release info.</summary>
-        private readonly TimeSpan CacheTime = TimeSpan.FromMinutes(10);
-
-        /// <summary>The GitHub repository name to check for update.</summary>
-        private readonly string RepositoryName = "Pathoschild/SMAPI";
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="cache">The cache in which to store release data.</param>
-        /// <param name="github">The GitHub API client.</param>
-        /// <param name="siteConfig">The context config settings.</param>
-        public IndexController(IMemoryCache cache, IGitHubClient github, IOptions<SiteConfig> siteConfig)
-        {
-            this.Cache = cache;
-            this.GitHub = github;
-            this.SiteConfig = siteConfig.Value;
-        }
-
-        /// <summary>Display the index page.</summary>
-        [HttpGet]
-        public async Task<ViewResult> Index()
-        {
-            // choose versions
-            ReleaseVersion[] versions = await this.GetReleaseVersionsAsync();
-            ReleaseVersion stableVersion = versions.LastOrDefault(version => !version.IsBeta && !version.IsForDevs);
-            ReleaseVersion stableVersionForDevs = versions.LastOrDefault(version => !version.IsBeta && version.IsForDevs);
-            ReleaseVersion betaVersion = versions.LastOrDefault(version => version.IsBeta && !version.IsForDevs);
-            ReleaseVersion betaVersionForDevs = versions.LastOrDefault(version => version.IsBeta && version.IsForDevs);
-
-            // render view
-            IndexVersionModel stableVersionModel = stableVersion != null
-                ? new IndexVersionModel(stableVersion.Version.ToString(), stableVersion.Release.Body, stableVersion.Asset.DownloadUrl, stableVersionForDevs?.Asset.DownloadUrl)
-                : new IndexVersionModel("unknown", "", "https://github.com/Pathoschild/SMAPI/releases", null); // just in case something goes wrong)
-            IndexVersionModel betaVersionModel = betaVersion != null && this.SiteConfig.BetaEnabled
-                ? new IndexVersionModel(betaVersion.Version.ToString(), betaVersion.Release.Body, betaVersion.Asset.DownloadUrl, betaVersionForDevs?.Asset.DownloadUrl)
-                : null;
-
-            // render view
-            var model = new IndexModel(stableVersionModel, betaVersionModel, this.SiteConfig.BetaBlurb);
-            return this.View(model);
-        }
-
-        /// <summary>Display the index page.</summary>
-        [HttpGet("/privacy")]
-        public ViewResult Privacy()
-        {
-            return this.View();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get a sorted, parsed list of SMAPI downloads for the latest releases.</summary>
-        private async Task<ReleaseVersion[]> GetReleaseVersionsAsync()
-        {
-            return await this.Cache.GetOrCreateAsync("available-versions", async entry =>
-            {
-                entry.AbsoluteExpiration = DateTimeOffset.UtcNow.Add(this.CacheTime);
-
-                // get latest release (whether preview or stable)
-                GitRelease stableRelease = await this.GitHub.GetLatestReleaseAsync(this.RepositoryName, includePrerelease: true);
-
-                // split stable/prerelease if applicable
-                GitRelease betaRelease = null;
-                if (stableRelease.IsPrerelease)
-                {
-                    GitRelease result = await this.GitHub.GetLatestReleaseAsync(this.RepositoryName, includePrerelease: false);
-                    if (result != null)
-                    {
-                        betaRelease = stableRelease;
-                        stableRelease = result;
-                    }
-                }
-
-                // strip 'noinclude' blocks from release descriptions
-                foreach (GitRelease release in new[] { stableRelease, betaRelease })
-                {
-                    if (release == null)
-                        continue;
-
-                    HtmlDocument doc = new HtmlDocument();
-                    doc.LoadHtml(release.Body);
-                    foreach (HtmlNode node in doc.DocumentNode.SelectNodes("//*[@class='noinclude']")?.ToArray() ?? new HtmlNode[0])
-                        node.Remove();
-                    release.Body = doc.DocumentNode.InnerHtml.Trim();
-                }
-
-                // get versions
-                ReleaseVersion[] stableVersions = this.ParseReleaseVersions(stableRelease).ToArray();
-                ReleaseVersion[] betaVersions = this.ParseReleaseVersions(betaRelease).ToArray();
-                return stableVersions
-                    .Concat(betaVersions)
-                    .OrderBy(p => p.Version)
-                    .ToArray();
-            });
-        }
-
-        /// <summary>Get a parsed list of SMAPI downloads for a release.</summary>
-        /// <param name="release">The GitHub release.</param>
-        private IEnumerable<ReleaseVersion> ParseReleaseVersions(GitRelease release)
-        {
-            if (release?.Assets == null)
-                yield break;
-
-            foreach (GitAsset asset in release.Assets)
-            {
-                if (asset.FileName.StartsWith("Z_"))
-                    continue;
-
-                Match match = Regex.Match(asset.FileName, @"SMAPI-(?<version>[\d\.]+(?:-.+)?)-installer(?<forDevs>-for-developers)?.zip");
-                if (!match.Success || !SemanticVersion.TryParse(match.Groups["version"].Value, out ISemanticVersion version))
-                    continue;
-                bool isBeta = version.IsPrerelease();
-                bool isForDevs = match.Groups["forDevs"].Success;
-
-                yield return new ReleaseVersion(release, asset, version, isBeta, isForDevs);
-            }
-        }
-
-        /// <summary>A parsed release download.</summary>
-        private class ReleaseVersion
-        {
-            /*********
-            ** Accessors
-            *********/
-            /// <summary>The underlying GitHub release.</summary>
-            public GitRelease Release { get; }
-
-            /// <summary>The underlying download asset.</summary>
-            public GitAsset Asset { get; }
-
-            /// <summary>The SMAPI version.</summary>
-            public ISemanticVersion Version { get; }
-
-            /// <summary>Whether this is a beta download.</summary>
-            public bool IsBeta { get; }
-
-            /// <summary>Whether this is a 'for developers' download.</summary>
-            public bool IsForDevs { get; }
-
-
-            /*********
-            ** Public methods
-            *********/
-            /// <summary>Construct an instance.</summary>
-            /// <param name="release">The underlying GitHub release.</param>
-            /// <param name="asset">The underlying download asset.</param>
-            /// <param name="version">The SMAPI version.</param>
-            /// <param name="isBeta">Whether this is a beta download.</param>
-            /// <param name="isForDevs">Whether this is a 'for developers' download.</param>
-            public ReleaseVersion(GitRelease release, GitAsset asset, ISemanticVersion version, bool isBeta, bool isForDevs)
-            {
-                this.Release = release;
-                this.Asset = asset;
-                this.Version = version;
-                this.IsBeta = isBeta;
-                this.IsForDevs = isForDevs;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Controllers/LogParserController.cs b/src/SMAPI.Web/Controllers/LogParserController.cs
deleted file mode 100644
index 21e4a56f..00000000
--- a/src/SMAPI.Web/Controllers/LogParserController.cs
+++ /dev/null
@@ -1,180 +0,0 @@
-using System;
-using System.IO;
-using System.IO.Compression;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Options;
-using StardewModdingAPI.Web.Framework;
-using StardewModdingAPI.Web.Framework.Clients.Pastebin;
-using StardewModdingAPI.Web.Framework.ConfigModels;
-using StardewModdingAPI.Web.Framework.LogParsing;
-using StardewModdingAPI.Web.Framework.LogParsing.Models;
-using StardewModdingAPI.Web.ViewModels;
-
-namespace StardewModdingAPI.Web.Controllers
-{
-    /// <summary>Provides a web UI and API for parsing SMAPI log files.</summary>
-    internal class LogParserController : Controller
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The site config settings.</summary>
-        private readonly SiteConfig Config;
-
-        /// <summary>The underlying Pastebin client.</summary>
-        private readonly IPastebinClient Pastebin;
-
-        /// <summary>The first bytes in a valid zip file.</summary>
-        /// <remarks>See <a href="https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers"/>.</remarks>
-        private const uint GzipLeadBytes = 0x8b1f;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /***
-        ** Constructor
-        ***/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="siteConfig">The context config settings.</param>
-        /// <param name="pastebin">The Pastebin API client.</param>
-        public LogParserController(IOptions<SiteConfig> siteConfig, IPastebinClient pastebin)
-        {
-            this.Config = siteConfig.Value;
-            this.Pastebin = pastebin;
-        }
-
-        /***
-        ** Web UI
-        ***/
-        /// <summary>Render the log parser UI.</summary>
-        /// <param name="id">The paste ID.</param>
-        /// <param name="raw">Whether to display the raw unparsed log.</param>
-        [HttpGet]
-        [Route("log")]
-        [Route("log/{id}")]
-        public async Task<ViewResult> Index(string id = null, bool raw = false)
-        {
-            // fresh page
-            if (string.IsNullOrWhiteSpace(id))
-                return this.View("Index", new LogParserModel(this.Config.LogParserUrl, id));
-
-            // log page
-            PasteInfo paste = await this.GetAsync(id);
-            ParsedLog log = paste.Success
-                ? new LogParser().Parse(paste.Content)
-                : new ParsedLog { IsValid = false, Error = "Pastebin error: " + paste.Error };
-            return this.View("Index", new LogParserModel(this.Config.LogParserUrl, id, log, raw));
-        }
-
-        /***
-        ** JSON
-        ***/
-        /// <summary>Save raw log data.</summary>
-        [HttpPost, AllowLargePosts]
-        [Route("log")]
-        public async Task<ActionResult> PostAsync()
-        {
-            // get raw log text
-            string input = this.Request.Form["input"].FirstOrDefault();
-            if (string.IsNullOrWhiteSpace(input))
-                return this.View("Index", new LogParserModel(this.Config.LogParserUrl, null) { UploadError = "The log file seems to be empty." });
-
-            // upload log
-            input = this.CompressString(input);
-            SavePasteResult result = await this.Pastebin.PostAsync(input);
-
-            // handle errors
-            if (!result.Success)
-                return this.View("Index", new LogParserModel(this.Config.LogParserUrl, result.ID) { UploadError = $"Pastebin error: {result.Error ?? "unknown error"}" });
-
-            // redirect to view
-            UriBuilder uri = new UriBuilder(new Uri(this.Config.LogParserUrl));
-            uri.Path = uri.Path.TrimEnd('/') + '/' + result.ID;
-            return this.Redirect(uri.Uri.ToString());
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Fetch raw text from Pastebin.</summary>
-        /// <param name="id">The Pastebin paste ID.</param>
-        private async Task<PasteInfo> GetAsync(string id)
-        {
-            PasteInfo response = await this.Pastebin.GetAsync(id);
-            response.Content = this.DecompressString(response.Content);
-            return response;
-        }
-
-        /// <summary>Compress a string.</summary>
-        /// <param name="text">The text to compress.</param>
-        /// <remarks>Derived from <a href="https://stackoverflow.com/a/17993002/262123"/>.</remarks>
-        private string CompressString(string text)
-        {
-            // get raw bytes
-            byte[] buffer = Encoding.UTF8.GetBytes(text);
-
-            // compressed
-            byte[] compressedData;
-            using (MemoryStream stream = new MemoryStream())
-            {
-                using (GZipStream zipStream = new GZipStream(stream, CompressionLevel.Optimal, leaveOpen: true))
-                    zipStream.Write(buffer, 0, buffer.Length);
-
-                stream.Position = 0;
-                compressedData = new byte[stream.Length];
-                stream.Read(compressedData, 0, compressedData.Length);
-            }
-
-            // prefix length
-            byte[] zipBuffer = new byte[compressedData.Length + 4];
-            Buffer.BlockCopy(compressedData, 0, zipBuffer, 4, compressedData.Length);
-            Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, zipBuffer, 0, 4);
-
-            // return string representation
-            return Convert.ToBase64String(zipBuffer);
-        }
-
-        /// <summary>Decompress a string.</summary>
-        /// <param name="rawText">The compressed text.</param>
-        /// <remarks>Derived from <a href="https://stackoverflow.com/a/17993002/262123"/>.</remarks>
-        private string DecompressString(string rawText)
-        {
-            // get raw bytes
-            byte[] zipBuffer;
-            try
-            {
-                zipBuffer = Convert.FromBase64String(rawText);
-            }
-            catch
-            {
-                return rawText; // not valid base64, wasn't compressed by the log parser
-            }
-
-            // skip if not gzip
-            if (BitConverter.ToUInt16(zipBuffer, 4) != LogParserController.GzipLeadBytes)
-                return rawText;
-
-            // decompress
-            using (MemoryStream memoryStream = new MemoryStream())
-            {
-                // read length prefix
-                int dataLength = BitConverter.ToInt32(zipBuffer, 0);
-                memoryStream.Write(zipBuffer, 4, zipBuffer.Length - 4);
-
-                // read data
-                byte[] buffer = new byte[dataLength];
-                memoryStream.Position = 0;
-                using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
-                    gZipStream.Read(buffer, 0, buffer.Length);
-
-                // return original string
-                return Encoding.UTF8.GetString(buffer);
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Controllers/ModsApiController.cs b/src/SMAPI.Web/Controllers/ModsApiController.cs
deleted file mode 100644
index 7e6f592c..00000000
--- a/src/SMAPI.Web/Controllers/ModsApiController.cs
+++ /dev/null
@@ -1,310 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Options;
-using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Toolkit.Framework.Clients.WebApi;
-using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
-using StardewModdingAPI.Toolkit.Framework.ModData;
-using StardewModdingAPI.Toolkit.Framework.UpdateData;
-using StardewModdingAPI.Web.Framework.Clients.Chucklefish;
-using StardewModdingAPI.Web.Framework.Clients.GitHub;
-using StardewModdingAPI.Web.Framework.Clients.ModDrop;
-using StardewModdingAPI.Web.Framework.Clients.Nexus;
-using StardewModdingAPI.Web.Framework.ConfigModels;
-using StardewModdingAPI.Web.Framework.ModRepositories;
-
-namespace StardewModdingAPI.Web.Controllers
-{
-    /// <summary>Provides an API to perform mod update checks.</summary>
-    [Produces("application/json")]
-    [Route("api/v{version:semanticVersion}/mods")]
-    internal class ModsApiController : Controller
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The mod repositories which provide mod metadata.</summary>
-        private readonly IDictionary<ModRepositoryKey, IModRepository> Repositories;
-
-        /// <summary>The cache in which to store mod metadata.</summary>
-        private readonly IMemoryCache Cache;
-
-        /// <summary>The number of minutes successful update checks should be cached before refetching them.</summary>
-        private readonly int SuccessCacheMinutes;
-
-        /// <summary>The number of minutes failed update checks should be cached before refetching them.</summary>
-        private readonly int ErrorCacheMinutes;
-
-        /// <summary>A regex which matches SMAPI-style semantic version.</summary>
-        private readonly string VersionRegex;
-
-        /// <summary>The internal mod metadata list.</summary>
-        private readonly ModDatabase ModDatabase;
-
-        /// <summary>The web URL for the compatibility list.</summary>
-        private readonly string CompatibilityPageUrl;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="environment">The web hosting environment.</param>
-        /// <param name="cache">The cache in which to store mod metadata.</param>
-        /// <param name="configProvider">The config settings for mod update checks.</param>
-        /// <param name="chucklefish">The Chucklefish API client.</param>
-        /// <param name="github">The GitHub API client.</param>
-        /// <param name="modDrop">The ModDrop API client.</param>
-        /// <param name="nexus">The Nexus API client.</param>
-        public ModsApiController(IHostingEnvironment environment, IMemoryCache cache, IOptions<ModUpdateCheckConfig> configProvider, IChucklefishClient chucklefish, IGitHubClient github, IModDropClient modDrop, INexusClient nexus)
-        {
-            this.ModDatabase = new ModToolkit().GetModDatabase(Path.Combine(environment.WebRootPath, "StardewModdingAPI.metadata.json"));
-            ModUpdateCheckConfig config = configProvider.Value;
-            this.CompatibilityPageUrl = config.CompatibilityPageUrl;
-
-            this.Cache = cache;
-            this.SuccessCacheMinutes = config.SuccessCacheMinutes;
-            this.ErrorCacheMinutes = config.ErrorCacheMinutes;
-            this.VersionRegex = config.SemanticVersionRegex;
-            this.Repositories =
-                new IModRepository[]
-                {
-                    new ChucklefishRepository(chucklefish),
-                    new GitHubRepository(github),
-                    new ModDropRepository(modDrop),
-                    new NexusRepository(nexus)
-                }
-                .ToDictionary(p => p.VendorKey);
-        }
-
-        /// <summary>Fetch version metadata for the given mods.</summary>
-        /// <param name="model">The mod search criteria.</param>
-        [HttpPost]
-        public async Task<IEnumerable<ModEntryModel>> PostAsync([FromBody] ModSearchModel model)
-        {
-            if (model?.Mods == null)
-                return new ModEntryModel[0];
-
-            // fetch wiki data
-            WikiModEntry[] wikiData = await this.GetWikiDataAsync();
-            IDictionary<string, ModEntryModel> mods = new Dictionary<string, ModEntryModel>(StringComparer.CurrentCultureIgnoreCase);
-            foreach (ModSearchEntryModel mod in model.Mods)
-            {
-                if (string.IsNullOrWhiteSpace(mod.ID))
-                    continue;
-
-                ModEntryModel result = await this.GetModData(mod, wikiData, model.IncludeExtendedMetadata);
-                mods[mod.ID] = result;
-            }
-
-            // return data
-            return mods.Values;
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the metadata for a mod.</summary>
-        /// <param name="search">The mod data to match.</param>
-        /// <param name="wikiData">The wiki data.</param>
-        /// <param name="includeExtendedMetadata">Whether to include extended metadata for each mod.</param>
-        /// <returns>Returns the mod data if found, else <c>null</c>.</returns>
-        private async Task<ModEntryModel> GetModData(ModSearchEntryModel search, WikiModEntry[] wikiData, bool includeExtendedMetadata)
-        {
-            // crossreference data
-            ModDataRecord record = this.ModDatabase.Get(search.ID);
-            WikiModEntry wikiEntry = wikiData.FirstOrDefault(entry => entry.ID.Contains(search.ID.Trim(), StringComparer.InvariantCultureIgnoreCase));
-            string[] updateKeys = this.GetUpdateKeys(search.UpdateKeys, record, wikiEntry).ToArray();
-
-            // get latest versions
-            ModEntryModel result = new ModEntryModel { ID = search.ID };
-            IList<string> errors = new List<string>();
-            foreach (string updateKey in updateKeys)
-            {
-                // fetch data
-                ModInfoModel data = await this.GetInfoForUpdateKeyAsync(updateKey);
-                if (data.Error != null)
-                {
-                    errors.Add(data.Error);
-                    continue;
-                }
-
-                // handle main version
-                if (data.Version != null)
-                {
-                    if (!SemanticVersion.TryParse(data.Version, out ISemanticVersion version))
-                    {
-                        errors.Add($"The update key '{updateKey}' matches a mod with invalid semantic version '{data.Version}'.");
-                        continue;
-                    }
-
-                    if (this.IsNewer(version, result.Main?.Version))
-                        result.Main = new ModEntryVersionModel(version, data.Url);
-                }
-
-                // handle optional version
-                if (data.PreviewVersion != null)
-                {
-                    if (!SemanticVersion.TryParse(data.PreviewVersion, out ISemanticVersion version))
-                    {
-                        errors.Add($"The update key '{updateKey}' matches a mod with invalid optional semantic version '{data.PreviewVersion}'.");
-                        continue;
-                    }
-
-                    if (this.IsNewer(version, result.Optional?.Version))
-                        result.Optional = new ModEntryVersionModel(version, data.Url);
-                }
-            }
-
-            // get unofficial version
-            if (wikiEntry?.Compatibility.UnofficialVersion != null && this.IsNewer(wikiEntry.Compatibility.UnofficialVersion, result.Main?.Version) && this.IsNewer(wikiEntry.Compatibility.UnofficialVersion, result.Optional?.Version))
-                result.Unofficial = new ModEntryVersionModel(wikiEntry.Compatibility.UnofficialVersion, $"{this.CompatibilityPageUrl}/#{wikiEntry.Anchor}");
-
-            // get unofficial version for beta
-            if (wikiEntry?.HasBetaInfo == true)
-            {
-                result.HasBetaInfo = true;
-                if (wikiEntry.BetaCompatibility.Status == WikiCompatibilityStatus.Unofficial)
-                {
-                    if (wikiEntry.BetaCompatibility.UnofficialVersion != null)
-                    {
-                        result.UnofficialForBeta = (wikiEntry.BetaCompatibility.UnofficialVersion != null && this.IsNewer(wikiEntry.BetaCompatibility.UnofficialVersion, result.Main?.Version) && this.IsNewer(wikiEntry.BetaCompatibility.UnofficialVersion, result.Optional?.Version))
-                            ? new ModEntryVersionModel(wikiEntry.BetaCompatibility.UnofficialVersion, $"{this.CompatibilityPageUrl}/#{wikiEntry.Anchor}")
-                            : null;
-                    }
-                    else
-                        result.UnofficialForBeta = result.Unofficial;
-                }
-            }
-
-            // fallback to preview if latest is invalid
-            if (result.Main == null && result.Optional != null)
-            {
-                result.Main = result.Optional;
-                result.Optional = null;
-            }
-
-            // special cases
-            if (result.ID == "Pathoschild.SMAPI")
-            {
-                if (result.Main != null)
-                    result.Main.Url = "https://smapi.io/";
-                if (result.Optional != null)
-                    result.Optional.Url = "https://smapi.io/";
-            }
-
-            // add extended metadata
-            if (includeExtendedMetadata && (wikiEntry != null || record != null))
-                result.Metadata = new ModExtendedMetadataModel(wikiEntry, record);
-
-            // add result
-            result.Errors = errors.ToArray();
-            return result;
-        }
-
-        /// <summary>Get whether a <paramref name="current"/> version is newer than an <paramref name="other"/> version.</summary>
-        /// <param name="current">The current version.</param>
-        /// <param name="other">The other version.</param>
-        private bool IsNewer(ISemanticVersion current, ISemanticVersion other)
-        {
-            return current != null && (other == null || other.IsOlderThan(current));
-        }
-
-        /// <summary>Get mod data from the wiki compatibility list.</summary>
-        private async Task<WikiModEntry[]> GetWikiDataAsync()
-        {
-            ModToolkit toolkit = new ModToolkit();
-            return await this.Cache.GetOrCreateAsync("_wiki", async entry =>
-            {
-                try
-                {
-                    WikiModEntry[] entries = (await toolkit.GetWikiCompatibilityListAsync()).Mods;
-                    entry.AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(this.SuccessCacheMinutes);
-                    return entries;
-                }
-                catch
-                {
-                    entry.AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(this.ErrorCacheMinutes);
-                    return new WikiModEntry[0];
-                }
-            });
-        }
-
-        /// <summary>Get the mod info for an update key.</summary>
-        /// <param name="updateKey">The namespaced update key.</param>
-        private async Task<ModInfoModel> GetInfoForUpdateKeyAsync(string updateKey)
-        {
-            // parse update key
-            UpdateKey parsed = UpdateKey.Parse(updateKey);
-            if (!parsed.LooksValid)
-                return new ModInfoModel($"The update key '{updateKey}' isn't in a valid format. It should contain the site key and mod ID like 'Nexus:541'.");
-
-            // get matching repository
-            if (!this.Repositories.TryGetValue(parsed.Repository, out IModRepository repository))
-                return new ModInfoModel($"There's no mod site with key '{parsed.Repository}'. Expected one of [{string.Join(", ", this.Repositories.Keys)}].");
-
-            // fetch mod info
-            return await this.Cache.GetOrCreateAsync($"{repository.VendorKey}:{parsed.ID}".ToLower(), async entry =>
-            {
-                ModInfoModel result = await repository.GetModInfoAsync(parsed.ID);
-                if (result.Error == null)
-                {
-                    if (result.Version == null)
-                        result.Error = $"The update key '{updateKey}' matches a mod with no version number.";
-                    else if (!Regex.IsMatch(result.Version, this.VersionRegex, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase))
-                        result.Error = $"The update key '{updateKey}' matches a mod with invalid semantic version '{result.Version}'.";
-                }
-                entry.AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(result.Error == null ? this.SuccessCacheMinutes : this.ErrorCacheMinutes);
-                return result;
-            });
-        }
-
-        /// <summary>Get update keys based on the available mod metadata, while maintaining the precedence order.</summary>
-        /// <param name="specifiedKeys">The specified update keys.</param>
-        /// <param name="record">The mod's entry in SMAPI's internal database.</param>
-        /// <param name="entry">The mod's entry in the wiki list.</param>
-        public IEnumerable<string> GetUpdateKeys(string[] specifiedKeys, ModDataRecord record, WikiModEntry entry)
-        {
-            IEnumerable<string> GetRaw()
-            {
-                // specified update keys
-                if (specifiedKeys != null)
-                {
-                    foreach (string key in specifiedKeys)
-                        yield return key?.Trim();
-                }
-
-                // default update key
-                string defaultKey = record?.GetDefaultUpdateKey();
-                if (defaultKey != null)
-                    yield return defaultKey;
-
-                // wiki metadata
-                if (entry != null)
-                {
-                    if (entry.NexusID.HasValue)
-                        yield return $"Nexus:{entry.NexusID}";
-                    if (entry.ChucklefishID.HasValue)
-                        yield return $"Chucklefish:{entry.ChucklefishID}";
-                    if (entry.ModDropID.HasValue)
-                        yield return $"ModDrop:{entry.ModDropID}";
-                }
-            }
-
-            HashSet<string> seen = new HashSet<string>(StringComparer.InvariantCulture);
-            foreach (string key in GetRaw())
-            {
-                if (!string.IsNullOrWhiteSpace(key) && seen.Add(key))
-                    yield return key;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Controllers/ModsController.cs b/src/SMAPI.Web/Controllers/ModsController.cs
deleted file mode 100644
index ca866a8d..00000000
--- a/src/SMAPI.Web/Controllers/ModsController.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-using System;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Options;
-using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
-using StardewModdingAPI.Web.Framework.ConfigModels;
-using StardewModdingAPI.Web.ViewModels;
-
-namespace StardewModdingAPI.Web.Controllers
-{
-    /// <summary>Provides user-friendly info about SMAPI mods.</summary>
-    internal class ModsController : Controller
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The cache in which to store mod metadata.</summary>
-        private readonly IMemoryCache Cache;
-
-        /// <summary>The number of minutes successful update checks should be cached before refetching them.</summary>
-        private readonly int CacheMinutes;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="cache">The cache in which to store mod metadata.</param>
-        /// <param name="configProvider">The config settings for mod update checks.</param>
-        public ModsController(IMemoryCache cache, IOptions<ModCompatibilityListConfig> configProvider)
-        {
-            ModCompatibilityListConfig config = configProvider.Value;
-
-            this.Cache = cache;
-            this.CacheMinutes = config.CacheMinutes;
-        }
-
-        /// <summary>Display information for all mods.</summary>
-        [HttpGet]
-        [Route("mods")]
-        public async Task<ViewResult> Index()
-        {
-            return this.View("Index", await this.FetchDataAsync());
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Asynchronously fetch mod metadata from the wiki.</summary>
-        public async Task<ModListModel> FetchDataAsync()
-        {
-            return await this.Cache.GetOrCreateAsync($"{nameof(ModsController)}_mod_list", async entry =>
-            {
-                WikiModList data = await new ModToolkit().GetWikiCompatibilityListAsync();
-                ModListModel model = new ModListModel(
-                    stableVersion: data.StableVersion,
-                    betaVersion: data.BetaVersion,
-                    mods: data
-                        .Mods
-                        .Select(mod => new ModModel(mod))
-                        .OrderBy(p => Regex.Replace(p.Name.ToLower(), "[^a-z0-9]", "")) // ignore case, spaces, and special characters when sorting
-                );
-
-                entry.AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(this.CacheMinutes);
-                return model;
-            });
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/AllowLargePostsAttribute.cs b/src/SMAPI.Web/Framework/AllowLargePostsAttribute.cs
deleted file mode 100644
index 5dc0feb6..00000000
--- a/src/SMAPI.Web/Framework/AllowLargePostsAttribute.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using System;
-using Microsoft.AspNetCore.Http.Features;
-using Microsoft.AspNetCore.Mvc.Filters;
-
-namespace StardewModdingAPI.Web.Framework
-{
-    /// <summary>A filter which increases the maximum request size for an endpoint.</summary>
-    /// <remarks>Derived from <a href="https://stackoverflow.com/a/38360093/262123"/>.</remarks>
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
-    public class AllowLargePostsAttribute : Attribute, IAuthorizationFilter, IOrderedFilter
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying form options.</summary>
-        private readonly FormOptions FormOptions;
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The attribute order.</summary>
-        public int Order { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public AllowLargePostsAttribute()
-        {
-            this.FormOptions = new FormOptions
-            {
-                ValueLengthLimit = 200 * 1024 * 1024 // 200MB
-            };
-        }
-
-        /// <summary>Called early in the filter pipeline to confirm request is authorized.</summary>
-        /// <param name="context">The authorisation filter context.</param>
-        public void OnAuthorization(AuthorizationFilterContext context)
-        {
-            IFeatureCollection features = context.HttpContext.Features;
-            IFormFeature formFeature = features.Get<IFormFeature>();
-
-            if (formFeature?.Form == null)
-            {
-                // Request form has not been read yet, so set the limits
-                features.Set<IFormFeature>(new FormFeature(context.HttpContext.Request, this.FormOptions));
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/BeanstalkEnvPropsConfigProvider.cs b/src/SMAPI.Web/Framework/BeanstalkEnvPropsConfigProvider.cs
deleted file mode 100644
index fe27fe2f..00000000
--- a/src/SMAPI.Web/Framework/BeanstalkEnvPropsConfigProvider.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using Microsoft.Extensions.Configuration;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace StardewModdingAPI.Web.Framework
-{
-    /// <summary>Reads configuration values from the AWS Beanstalk environment properties file (if present).</summary>
-    /// <remarks>This is a workaround for AWS Beanstalk injection not working with .NET Core apps.</remarks>
-    internal class BeanstalkEnvPropsConfigProvider : ConfigurationProvider, IConfigurationSource
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The absolute path to the container configuration file on an Amazon EC2 instance.</summary>
-        private const string ContainerConfigPath = @"C:\Program Files\Amazon\ElasticBeanstalk\config\containerconfiguration";
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Build the configuration provider for this source.</summary>
-        /// <param name="builder">The configuration builder.</param>
-        public IConfigurationProvider Build(IConfigurationBuilder builder)
-        {
-            return new BeanstalkEnvPropsConfigProvider();
-        }
-
-        /// <summary>Load the environment properties.</summary>
-        public override void Load()
-        {
-            this.Data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-
-            // get Beanstalk config file
-            FileInfo file = new FileInfo(BeanstalkEnvPropsConfigProvider.ContainerConfigPath);
-            if (!file.Exists)
-                return;
-
-            // parse JSON
-            JObject jsonRoot = (JObject)JsonConvert.DeserializeObject(File.ReadAllText(file.FullName));
-            if (jsonRoot["iis"]?["env"] is JArray jsonProps)
-            {
-                foreach (string prop in jsonProps.Values<string>())
-                {
-                    string[] parts = prop.Split('=', 2); // key=value
-                    if (parts.Length == 2)
-                        this.Data[parts[0]] = parts[1];
-                }
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishClient.cs b/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishClient.cs
deleted file mode 100644
index 2753e33a..00000000
--- a/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishClient.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-using System;
-using System.Net;
-using System.Threading.Tasks;
-using HtmlAgilityPack;
-using Pathoschild.Http.Client;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Chucklefish
-{
-    /// <summary>An HTTP client for fetching mod metadata from the Chucklefish mod site.</summary>
-    internal class ChucklefishClient : IChucklefishClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The URL for a mod page excluding the base URL, where {0} is the mod ID.</summary>
-        private readonly string ModPageUrlFormat;
-
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="userAgent">The user agent for the API client.</param>
-        /// <param name="baseUrl">The base URL for the Chucklefish mod site.</param>
-        /// <param name="modPageUrlFormat">The URL for a mod page excluding the <paramref name="baseUrl"/>, where {0} is the mod ID.</param>
-        public ChucklefishClient(string userAgent, string baseUrl, string modPageUrlFormat)
-        {
-            this.ModPageUrlFormat = modPageUrlFormat;
-            this.Client = new FluentClient(baseUrl).SetUserAgent(userAgent);
-        }
-
-        /// <summary>Get metadata about a mod.</summary>
-        /// <param name="id">The Chucklefish mod ID.</param>
-        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
-        public async Task<ChucklefishMod> GetModAsync(uint id)
-        {
-            // fetch HTML
-            string html;
-            try
-            {
-                html = await this.Client
-                    .GetAsync(string.Format(this.ModPageUrlFormat, id))
-                    .AsString();
-            }
-            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
-            {
-                return null;
-            }
-
-            // parse HTML
-            var doc = new HtmlDocument();
-            doc.LoadHtml(html);
-
-            // extract mod info
-            string url = this.GetModUrl(id);
-            string name = doc.DocumentNode.SelectSingleNode("//meta[@name='twitter:title']").Attributes["content"].Value;
-            if (name.StartsWith("[SMAPI] "))
-                name = name.Substring("[SMAPI] ".Length);
-            string version = doc.DocumentNode.SelectSingleNode("//h1/span").InnerText;
-
-            // create model
-            return new ChucklefishMod
-            {
-                Name = name,
-                Version = version,
-                Url = url
-            };
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public void Dispose()
-        {
-            this.Client?.Dispose();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the full mod page URL for a given ID.</summary>
-        /// <param name="id">The mod ID.</param>
-        private string GetModUrl(uint id)
-        {
-            UriBuilder builder = new UriBuilder(this.Client.BaseClient.BaseAddress);
-            builder.Path += string.Format(this.ModPageUrlFormat, id);
-            return builder.Uri.ToString();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishMod.cs b/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishMod.cs
deleted file mode 100644
index fd0101d4..00000000
--- a/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishMod.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.Clients.Chucklefish
-{
-    /// <summary>Mod metadata from the Chucklefish mod site.</summary>
-    internal class ChucklefishMod
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod name.</summary>
-        public string Name { get; set; }
-
-        /// <summary>The mod's semantic version number.</summary>
-        public string Version { get; set; }
-
-        /// <summary>The mod's web URL.</summary>
-        public string Url { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Chucklefish/IChucklefishClient.cs b/src/SMAPI.Web/Framework/Clients/Chucklefish/IChucklefishClient.cs
deleted file mode 100644
index 1d8b256e..00000000
--- a/src/SMAPI.Web/Framework/Clients/Chucklefish/IChucklefishClient.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Chucklefish
-{
-    /// <summary>An HTTP client for fetching mod metadata from the Chucklefish mod site.</summary>
-    internal interface IChucklefishClient : IDisposable
-    {
-        /*********
-        ** Methods
-        *********/
-        /// <summary>Get metadata about a mod.</summary>
-        /// <param name="id">The Chucklefish mod ID.</param>
-        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
-        Task<ChucklefishMod> GetModAsync(uint id);
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/GitAsset.cs b/src/SMAPI.Web/Framework/Clients/GitHub/GitAsset.cs
deleted file mode 100644
index 73ce4025..00000000
--- a/src/SMAPI.Web/Framework/Clients/GitHub/GitAsset.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using Newtonsoft.Json;
-
-namespace StardewModdingAPI.Web.Framework.Clients.GitHub
-{
-    /// <summary>A GitHub download attached to a release.</summary>
-    internal class GitAsset
-    {
-        /// <summary>The file name.</summary>
-        [JsonProperty("name")]
-        public string FileName { get; set; }
-
-        /// <summary>The file content type.</summary>
-        [JsonProperty("content_type")]
-        public string ContentType { get; set; }
-
-        /// <summary>The download URL.</summary>
-        [JsonProperty("browser_download_url")]
-        public string DownloadUrl { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/GitHubClient.cs b/src/SMAPI.Web/Framework/Clients/GitHub/GitHubClient.cs
deleted file mode 100644
index 22950db9..00000000
--- a/src/SMAPI.Web/Framework/Clients/GitHub/GitHubClient.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-using System;
-using System.Linq;
-using System.Net;
-using System.Threading.Tasks;
-using Pathoschild.Http.Client;
-
-namespace StardewModdingAPI.Web.Framework.Clients.GitHub
-{
-    /// <summary>An HTTP client for fetching metadata from GitHub.</summary>
-    internal class GitHubClient : IGitHubClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The URL for a GitHub API query for the latest stable release, excluding the base URL, where {0} is the organisation and project name.</summary>
-        private readonly string StableReleaseUrlFormat;
-
-        /// <summary>The URL for a GitHub API query for the latest release (including prerelease), excluding the base URL, where {0} is the organisation and project name.</summary>
-        private readonly string AnyReleaseUrlFormat;
-
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="baseUrl">The base URL for the GitHub API.</param>
-        /// <param name="stableReleaseUrlFormat">The URL for a GitHub API query for the latest stable release, excluding the <paramref name="baseUrl"/>, where {0} is the organisation and project name.</param>
-        /// <param name="anyReleaseUrlFormat">The URL for a GitHub API query for the latest release (including prerelease), excluding the <paramref name="baseUrl"/>, where {0} is the organisation and project name.</param>
-        /// <param name="userAgent">The user agent for the API client.</param>
-        /// <param name="acceptHeader">The Accept header value expected by the GitHub API.</param>
-        /// <param name="username">The username with which to authenticate to the GitHub API.</param>
-        /// <param name="password">The password with which to authenticate to the GitHub API.</param>
-        public GitHubClient(string baseUrl, string stableReleaseUrlFormat, string anyReleaseUrlFormat, string userAgent, string acceptHeader, string username, string password)
-        {
-            this.StableReleaseUrlFormat = stableReleaseUrlFormat;
-            this.AnyReleaseUrlFormat = anyReleaseUrlFormat;
-
-            this.Client = new FluentClient(baseUrl)
-                .SetUserAgent(userAgent)
-                .AddDefault(req => req.WithHeader("Accept", acceptHeader));
-            if (!string.IsNullOrWhiteSpace(username))
-                this.Client = this.Client.SetBasicAuthentication(username, password);
-        }
-
-        /// <summary>Get the latest release for a GitHub repository.</summary>
-        /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
-        /// <param name="includePrerelease">Whether to return a prerelease version if it's latest.</param>
-        /// <returns>Returns the release if found, else <c>null</c>.</returns>
-        public async Task<GitRelease> GetLatestReleaseAsync(string repo, bool includePrerelease = false)
-        {
-            this.AssetKeyFormat(repo);
-            try
-            {
-                if (includePrerelease)
-                {
-                    GitRelease[] results = await this.Client
-                        .GetAsync(string.Format(this.AnyReleaseUrlFormat, repo))
-                        .AsArray<GitRelease>();
-                    return results.FirstOrDefault(p => !p.IsDraft);
-                }
-
-                return await this.Client
-                    .GetAsync(string.Format(this.StableReleaseUrlFormat, repo))
-                    .As<GitRelease>();
-            }
-            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
-            {
-                return null;
-            }
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public void Dispose()
-        {
-            this.Client?.Dispose();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Assert that a repository key is formatted correctly.</summary>
-        /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
-        /// <exception cref="ArgumentException">The repository key is invalid.</exception>
-        private void AssetKeyFormat(string repo)
-        {
-            if (repo == null || !repo.Contains("/") || repo.IndexOf("/", StringComparison.InvariantCultureIgnoreCase) != repo.LastIndexOf("/", StringComparison.InvariantCultureIgnoreCase))
-                throw new ArgumentException($"The value '{repo}' isn't a valid GitHub repository key, must be a username and project name like 'Pathoschild/SMAPI'.", nameof(repo));
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/GitRelease.cs b/src/SMAPI.Web/Framework/Clients/GitHub/GitRelease.cs
deleted file mode 100644
index d0db5297..00000000
--- a/src/SMAPI.Web/Framework/Clients/GitHub/GitRelease.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using Newtonsoft.Json;
-
-namespace StardewModdingAPI.Web.Framework.Clients.GitHub
-{
-    /// <summary>A GitHub project release.</summary>
-    internal class GitRelease
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The display name.</summary>
-        [JsonProperty("name")]
-        public string Name { get; set; }
-
-        /// <summary>The semantic version string.</summary>
-        [JsonProperty("tag_name")]
-        public string Tag { get; set; }
-
-        /// <summary>The Markdown description for the release.</summary>
-        public string Body { get; set; }
-
-        /// <summary>Whether this is a draft version.</summary>
-        [JsonProperty("draft")]
-        public bool IsDraft { get; set; }
-
-        /// <summary>Whether this is a prerelease version.</summary>
-        [JsonProperty("prerelease")]
-        public bool IsPrerelease { get; set; }
-
-        /// <summary>The attached files.</summary>
-        public GitAsset[] Assets { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/IGitHubClient.cs b/src/SMAPI.Web/Framework/Clients/GitHub/IGitHubClient.cs
deleted file mode 100644
index 9519c26f..00000000
--- a/src/SMAPI.Web/Framework/Clients/GitHub/IGitHubClient.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace StardewModdingAPI.Web.Framework.Clients.GitHub
-{
-    /// <summary>An HTTP client for fetching metadata from GitHub.</summary>
-    internal interface IGitHubClient : IDisposable
-    {
-        /*********
-        ** Methods
-        *********/
-        /// <summary>Get the latest release for a GitHub repository.</summary>
-        /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
-        /// <param name="includePrerelease">Whether to return a prerelease version if it's latest.</param>
-        /// <returns>Returns the release if found, else <c>null</c>.</returns>
-        Task<GitRelease> GetLatestReleaseAsync(string repo, bool includePrerelease = false);
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/IModDropClient.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/IModDropClient.cs
deleted file mode 100644
index 3ede46e2..00000000
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/IModDropClient.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace StardewModdingAPI.Web.Framework.Clients.ModDrop
-{
-    /// <summary>An HTTP client for fetching mod metadata from the ModDrop API.</summary>
-    internal interface IModDropClient : IDisposable
-    {
-        /*********
-        ** Methods
-        *********/
-        /// <summary>Get metadata about a mod.</summary>
-        /// <param name="id">The ModDrop mod ID.</param>
-        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
-        Task<ModDropMod> GetModAsync(long id);
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropClient.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropClient.cs
deleted file mode 100644
index 5ad2d2f8..00000000
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropClient.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-using System.Threading.Tasks;
-using Pathoschild.Http.Client;
-using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Web.Framework.Clients.ModDrop.ResponseModels;
-
-namespace StardewModdingAPI.Web.Framework.Clients.ModDrop
-{
-    /// <summary>An HTTP client for fetching mod metadata from the ModDrop API.</summary>
-    internal class ModDropClient : IModDropClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IClient Client;
-
-        /// <summary>The URL for a ModDrop mod page for the user, where {0} is the mod ID.</summary>
-        private readonly string ModUrlFormat;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="userAgent">The user agent for the API client.</param>
-        /// <param name="apiUrl">The base URL for the ModDrop API.</param>
-        /// <param name="modUrlFormat">The URL for a ModDrop mod page for the user, where {0} is the mod ID.</param>
-        public ModDropClient(string userAgent, string apiUrl, string modUrlFormat)
-        {
-            this.Client = new FluentClient(apiUrl).SetUserAgent(userAgent);
-            this.ModUrlFormat = modUrlFormat;
-        }
-
-        /// <summary>Get metadata about a mod.</summary>
-        /// <param name="id">The ModDrop mod ID.</param>
-        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
-        public async Task<ModDropMod> GetModAsync(long id)
-        {
-            // get raw data
-            ModListModel response = await this.Client
-                .PostAsync("")
-                .WithBody(new
-                {
-                    ModIDs = new[] { id },
-                    Files = true,
-                    Mods = true
-                })
-                .As<ModListModel>();
-            ModModel mod = response.Mods[id];
-            if (mod.Mod?.Title == null || mod.Mod.ErrorCode.HasValue)
-                return null;
-
-            // get latest versions
-            ISemanticVersion latest = null;
-            ISemanticVersion optional = null;
-            foreach (FileDataModel file in mod.Files)
-            {
-                if (file.IsOld || file.IsDeleted || file.IsHidden)
-                    continue;
-
-                if (!SemanticVersion.TryParse(file.Version, out ISemanticVersion version))
-                    continue;
-
-                if (file.IsDefault)
-                {
-                    if (latest == null || version.IsNewerThan(latest))
-                        latest = version;
-                }
-                else if (optional == null || version.IsNewerThan(optional))
-                    optional = version;
-            }
-            if (latest == null)
-            {
-                latest = optional;
-                optional = null;
-            }
-            if (optional != null && latest.IsNewerThan(optional))
-                optional = null;
-
-            // generate result
-            return new ModDropMod
-            {
-                Name = mod.Mod?.Title,
-                LatestDefaultVersion = latest,
-                LatestOptionalVersion = optional,
-                Url = string.Format(this.ModUrlFormat, id)
-            };
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public void Dispose()
-        {
-            this.Client?.Dispose();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropMod.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropMod.cs
deleted file mode 100644
index 291fb353..00000000
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropMod.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.Clients.ModDrop
-{
-    /// <summary>Mod metadata from the ModDrop API.</summary>
-    internal class ModDropMod
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod name.</summary>
-        public string Name { get; set; }
-
-        /// <summary>The latest default file version.</summary>
-        public ISemanticVersion LatestDefaultVersion { get; set; }
-
-        /// <summary>The latest optional file version.</summary>
-        public ISemanticVersion LatestOptionalVersion { get; set; }
-
-        /// <summary>The mod's web URL.</summary>
-        public string Url { get; set; }
-
-        /// <summary>A user-friendly error which indicates why fetching the mod info failed (if applicable).</summary>
-        public string Error { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/FileDataModel.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/FileDataModel.cs
deleted file mode 100644
index fa84b287..00000000
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/FileDataModel.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.Clients.ModDrop.ResponseModels
-{
-    /// <summary>Metadata from the ModDrop API about a mod file.</summary>
-    public class FileDataModel
-    {
-        /// <summary>Whether the file is deleted.</summary>
-        public bool IsDeleted { get; set; }
-
-        /// <summary>Whether the file is hidden from users.</summary>
-        public bool IsHidden { get; set; }
-
-        /// <summary>Whether this is the default file for the mod.</summary>
-        public bool IsDefault { get; set; }
-
-        /// <summary>Whether this is an archived file.</summary>
-        public bool IsOld { get; set; }
-
-        /// <summary>The file version.</summary>
-        public string Version { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModDataModel.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModDataModel.cs
deleted file mode 100644
index cfdd6a4e..00000000
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModDataModel.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.Clients.ModDrop.ResponseModels
-{
-    /// <summary>Metadata about a mod from the ModDrop API.</summary>
-    public class ModDataModel
-    {
-        /// <summary>The mod's unique ID on ModDrop.</summary>
-        public int ID { get; set; }
-
-        /// <summary>The error code, if any.</summary>
-        public int? ErrorCode { get; set; }
-
-        /// <summary>The mod name.</summary>
-        public string Title { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModListModel.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModListModel.cs
deleted file mode 100644
index 7f692ca1..00000000
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModListModel.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System.Collections.Generic;
-
-namespace StardewModdingAPI.Web.Framework.Clients.ModDrop.ResponseModels
-{
-    /// <summary>A list of mods from the ModDrop API.</summary>
-    public class ModListModel
-    {
-        /// <summary>The mod data.</summary>
-        public IDictionary<long, ModModel> Mods { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModModel.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModModel.cs
deleted file mode 100644
index 9f4b2c6f..00000000
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/ResponseModels/ModModel.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.Clients.ModDrop.ResponseModels
-{
-    /// <summary>An entry in a mod list from the ModDrop API.</summary>
-    public class ModModel
-    {
-        /// <summary>The available file downloads.</summary>
-        public FileDataModel[] Files { get; set; }
-
-        /// <summary>The mod metadata.</summary>
-        public ModDataModel Mod { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Nexus/INexusClient.cs b/src/SMAPI.Web/Framework/Clients/Nexus/INexusClient.cs
deleted file mode 100644
index e56e7af4..00000000
--- a/src/SMAPI.Web/Framework/Clients/Nexus/INexusClient.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Nexus
-{
-    /// <summary>An HTTP client for fetching mod metadata from Nexus Mods.</summary>
-    internal interface INexusClient : IDisposable
-    {
-        /*********
-        ** Methods
-        *********/
-        /// <summary>Get metadata about a mod.</summary>
-        /// <param name="id">The Nexus mod ID.</param>
-        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
-        Task<NexusMod> GetModAsync(uint id);
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Nexus/NexusMod.cs b/src/SMAPI.Web/Framework/Clients/Nexus/NexusMod.cs
deleted file mode 100644
index f4909155..00000000
--- a/src/SMAPI.Web/Framework/Clients/Nexus/NexusMod.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using Newtonsoft.Json;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Nexus
-{
-    /// <summary>Mod metadata from Nexus Mods.</summary>
-    internal class NexusMod
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod name.</summary>
-        public string Name { get; set; }
-
-        /// <summary>The mod's semantic version number.</summary>
-        public string Version { get; set; }
-
-        /// <summary>The latest file version.</summary>
-        public ISemanticVersion LatestFileVersion { get; set; }
-
-        /// <summary>The mod's web URL.</summary>
-        [JsonProperty("mod_page_uri")]
-        public string Url { get; set; }
-
-        /// <summary>A user-friendly error which indicates why fetching the mod info failed (if applicable).</summary>
-        [JsonIgnore]
-        public string Error { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Nexus/NexusWebScrapeClient.cs b/src/SMAPI.Web/Framework/Clients/Nexus/NexusWebScrapeClient.cs
deleted file mode 100644
index e83a6041..00000000
--- a/src/SMAPI.Web/Framework/Clients/Nexus/NexusWebScrapeClient.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Threading.Tasks;
-using HtmlAgilityPack;
-using Pathoschild.Http.Client;
-using StardewModdingAPI.Toolkit;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Nexus
-{
-    /// <summary>An HTTP client for fetching mod metadata from the Nexus website.</summary>
-    internal class NexusWebScrapeClient : INexusClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The URL for a Nexus mod page for the user, excluding the base URL, where {0} is the mod ID.</summary>
-        private readonly string ModUrlFormat;
-
-        /// <summary>The URL for a Nexus mod page to scrape for versions, excluding the base URL, where {0} is the mod ID.</summary>
-        public string ModScrapeUrlFormat { get; set; }
-
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="userAgent">The user agent for the Nexus Mods API client.</param>
-        /// <param name="baseUrl">The base URL for the Nexus Mods site.</param>
-        /// <param name="modUrlFormat">The URL for a Nexus Mods mod page for the user, excluding the <paramref name="baseUrl"/>, where {0} is the mod ID.</param>
-        /// <param name="modScrapeUrlFormat">The URL for a Nexus mod page to scrape for versions, excluding the base URL, where {0} is the mod ID.</param>
-        public NexusWebScrapeClient(string userAgent, string baseUrl, string modUrlFormat, string modScrapeUrlFormat)
-        {
-            this.ModUrlFormat = modUrlFormat;
-            this.ModScrapeUrlFormat = modScrapeUrlFormat;
-            this.Client = new FluentClient(baseUrl).SetUserAgent(userAgent);
-        }
-
-        /// <summary>Get metadata about a mod.</summary>
-        /// <param name="id">The Nexus mod ID.</param>
-        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
-        public async Task<NexusMod> GetModAsync(uint id)
-        {
-            // fetch HTML
-            string html;
-            try
-            {
-                html = await this.Client
-                    .GetAsync(string.Format(this.ModScrapeUrlFormat, id))
-                    .AsString();
-            }
-            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
-            {
-                return null;
-            }
-
-            // parse HTML
-            var doc = new HtmlDocument();
-            doc.LoadHtml(html);
-
-            // handle Nexus error message
-            HtmlNode node = doc.DocumentNode.SelectSingleNode("//div[contains(@class, 'site-notice')][contains(@class, 'warning')]");
-            if (node != null)
-            {
-                string[] errorParts = node.InnerText.Trim().Split(new[] { '\n' }, 2, System.StringSplitOptions.RemoveEmptyEntries);
-                string errorCode = errorParts[0];
-                string errorText = errorParts.Length > 1 ? errorParts[1] : null;
-                switch (errorCode.Trim().ToLower())
-                {
-                    case "not found":
-                        return null;
-
-                    default:
-                        return new NexusMod { Error = $"Nexus error: {errorCode} ({errorText})." };
-                }
-            }
-
-            // extract mod info
-            string url = this.GetModUrl(id);
-            string name = doc.DocumentNode.SelectSingleNode("//h1")?.InnerText.Trim();
-            string version = doc.DocumentNode.SelectSingleNode("//ul[contains(@class, 'stats')]//li[@class='stat-version']//div[@class='stat']")?.InnerText.Trim();
-            SemanticVersion.TryParse(version, out ISemanticVersion parsedVersion);
-
-            // extract file versions
-            List<string> rawVersions = new List<string>();
-            foreach (var fileSection in doc.DocumentNode.SelectNodes("//div[contains(@class, 'files-tabs')]"))
-            {
-                string sectionName = fileSection.Descendants("h2").First().InnerText;
-                if (sectionName != "Main files" && sectionName != "Optional files")
-                    continue;
-
-                rawVersions.AddRange(
-                    from statBox in fileSection.Descendants().Where(p => p.HasClass("stat-version"))
-                    from versionStat in statBox.Descendants().Where(p => p.HasClass("stat"))
-                    select versionStat.InnerText.Trim()
-                );
-            }
-
-            // choose latest file version
-            ISemanticVersion latestFileVersion = null;
-            foreach (string rawVersion in rawVersions)
-            {
-                if (!SemanticVersion.TryParse(rawVersion, out ISemanticVersion cur))
-                    continue;
-                if (parsedVersion != null && !cur.IsNewerThan(parsedVersion))
-                    continue;
-                if (latestFileVersion != null && !cur.IsNewerThan(latestFileVersion))
-                    continue;
-
-                latestFileVersion = cur;
-            }
-
-            // yield info
-            return new NexusMod
-            {
-                Name = name,
-                Version = parsedVersion?.ToString() ?? version,
-                LatestFileVersion = latestFileVersion,
-                Url = url
-            };
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public void Dispose()
-        {
-            this.Client?.Dispose();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the full mod page URL for a given ID.</summary>
-        /// <param name="id">The mod ID.</param>
-        private string GetModUrl(uint id)
-        {
-            UriBuilder builder = new UriBuilder(this.Client.BaseClient.BaseAddress);
-            builder.Path += string.Format(this.ModUrlFormat, id);
-            return builder.Uri.ToString();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Pastebin/IPastebinClient.cs b/src/SMAPI.Web/Framework/Clients/Pastebin/IPastebinClient.cs
deleted file mode 100644
index 630dfb76..00000000
--- a/src/SMAPI.Web/Framework/Clients/Pastebin/IPastebinClient.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
-{
-    /// <summary>An API client for Pastebin.</summary>
-    internal interface IPastebinClient : IDisposable
-    {
-        /// <summary>Fetch a saved paste.</summary>
-        /// <param name="id">The paste ID.</param>
-        Task<PasteInfo> GetAsync(string id);
-
-        /// <summary>Save a paste to Pastebin.</summary>
-        /// <param name="content">The paste content.</param>
-        Task<SavePasteResult> PostAsync(string content);
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Pastebin/PasteInfo.cs b/src/SMAPI.Web/Framework/Clients/Pastebin/PasteInfo.cs
deleted file mode 100644
index 955156eb..00000000
--- a/src/SMAPI.Web/Framework/Clients/Pastebin/PasteInfo.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
-{
-    /// <summary>The response for a get-paste request.</summary>
-    internal class PasteInfo
-    {
-        /// <summary>Whether the log was successfully fetched.</summary>
-        public bool Success { get; set; }
-
-        /// <summary>The fetched paste content (if <see cref="Success"/> is <c>true</c>).</summary>
-        public string Content { get; set; }
-
-        /// <summary>The error message (if saving failed).</summary>
-        public string Error { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Pastebin/PastebinClient.cs b/src/SMAPI.Web/Framework/Clients/Pastebin/PastebinClient.cs
deleted file mode 100644
index 12c3e83f..00000000
--- a/src/SMAPI.Web/Framework/Clients/Pastebin/PastebinClient.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
-using System.Web;
-using Pathoschild.Http.Client;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
-{
-    /// <summary>An API client for Pastebin.</summary>
-    internal class PastebinClient : IPastebinClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IClient Client;
-
-        /// <summary>The user key used to authenticate with the Pastebin API.</summary>
-        private readonly string UserKey;
-
-        /// <summary>The developer key used to authenticate with the Pastebin API.</summary>
-        private readonly string DevKey;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="baseUrl">The base URL for the Pastebin API.</param>
-        /// <param name="userAgent">The user agent for the API client.</param>
-        /// <param name="userKey">The user key used to authenticate with the Pastebin API.</param>
-        /// <param name="devKey">The developer key used to authenticate with the Pastebin API.</param>
-        public PastebinClient(string baseUrl, string userAgent, string userKey, string devKey)
-        {
-            this.Client = new FluentClient(baseUrl).SetUserAgent(userAgent);
-            this.UserKey = userKey;
-            this.DevKey = devKey;
-        }
-
-        /// <summary>Fetch a saved paste.</summary>
-        /// <param name="id">The paste ID.</param>
-        public async Task<PasteInfo> GetAsync(string id)
-        {
-            try
-            {
-                // get from API
-                string content = await this.Client
-                    .GetAsync($"raw/{id}")
-                    .AsString();
-
-                // handle Pastebin errors
-                if (string.IsNullOrWhiteSpace(content))
-                    return new PasteInfo { Error = "Received an empty response from Pastebin." };
-                if (content.StartsWith("<!DOCTYPE"))
-                    return new PasteInfo { Error = $"Received a captcha challenge from Pastebin. Please visit https://pastebin.com/{id} in a new window to solve it." };
-                return new PasteInfo { Success = true, Content = content };
-            }
-            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
-            {
-                return new PasteInfo { Error = "There's no log with that ID." };
-            }
-            catch (Exception ex)
-            {
-                return new PasteInfo { Error = ex.ToString() };
-            }
-        }
-
-        /// <summary>Save a paste to Pastebin.</summary>
-        /// <param name="content">The paste content.</param>
-        public async Task<SavePasteResult> PostAsync(string content)
-        {
-            try
-            {
-                // validate
-                if (string.IsNullOrWhiteSpace(content))
-                    return new SavePasteResult { Error = "The log content can't be empty." };
-
-                // post to API
-                string response = await this.Client
-                    .PostAsync("api/api_post.php")
-                    .WithBodyContent(this.GetFormUrlEncodedContent(new Dictionary<string, string>
-                    {
-                        ["api_option"] = "paste",
-                        ["api_user_key"] = this.UserKey,
-                        ["api_dev_key"] = this.DevKey,
-                        ["api_paste_private"] = "1", // unlisted
-                        ["api_paste_name"] = $"SMAPI log {DateTime.UtcNow:s}",
-                        ["api_paste_expire_date"] = "N", // never expire
-                        ["api_paste_code"] = content
-                    }))
-                    .AsString();
-
-                // handle Pastebin errors
-                if (string.IsNullOrWhiteSpace(response))
-                    return new SavePasteResult { Error = "Received an empty response from Pastebin." };
-                if (response.StartsWith("Bad API request"))
-                    return new SavePasteResult { Error = response };
-                if (!response.Contains("/"))
-                    return new SavePasteResult { Error = $"Received an unknown response: {response}" };
-
-                // return paste ID
-                string pastebinID = response.Split("/").Last();
-                return new SavePasteResult { Success = true, ID = pastebinID };
-            }
-            catch (Exception ex)
-            {
-                return new SavePasteResult { Success = false, Error = ex.ToString() };
-            }
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public void Dispose()
-        {
-            this.Client.Dispose();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Build an HTTP content body with form-url-encoded content.</summary>
-        /// <param name="data">The content to encode.</param>
-        /// <remarks>This bypasses an issue where <see cref="FormUrlEncodedContent"/> restricts the body length to the maximum size of a URL, which isn't applicable here.</remarks>
-        private HttpContent GetFormUrlEncodedContent(IDictionary<string, string> data)
-        {
-            string body = string.Join("&", from arg in data select $"{HttpUtility.UrlEncode(arg.Key)}={HttpUtility.UrlEncode(arg.Value)}");
-            return new StringContent(body, Encoding.UTF8, "application/x-www-form-urlencoded");
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Pastebin/SavePasteResult.cs b/src/SMAPI.Web/Framework/Clients/Pastebin/SavePasteResult.cs
deleted file mode 100644
index 89dab697..00000000
--- a/src/SMAPI.Web/Framework/Clients/Pastebin/SavePasteResult.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
-{
-    /// <summary>The response for a save-log request.</summary>
-    internal class SavePasteResult
-    {
-        /// <summary>Whether the log was successfully saved.</summary>
-        public bool Success { get; set; }
-
-        /// <summary>The saved paste ID (if <see cref="Success"/> is <c>true</c>).</summary>
-        public string ID { get; set; }
-
-        /// <summary>The error message (if saving failed).</summary>
-        public string Error { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ConfigModels/ApiClientsConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/ApiClientsConfig.cs
deleted file mode 100644
index c27cadab..00000000
--- a/src/SMAPI.Web/Framework/ConfigModels/ApiClientsConfig.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.ConfigModels
-{
-    /// <summary>The config settings for the API clients.</summary>
-    internal class ApiClientsConfig
-    {
-        /*********
-        ** Accessors
-        *********/
-        /****
-        ** Generic
-        ****/
-        /// <summary>The user agent for API clients, where {0} is the SMAPI version.</summary>
-        public string UserAgent { get; set; }
-
-
-        /****
-        ** Chucklefish
-        ****/
-        /// <summary>The base URL for the Chucklefish mod site.</summary>
-        public string ChucklefishBaseUrl { get; set; }
-
-        /// <summary>The URL for a mod page on the Chucklefish mod site excluding the <see cref="GitHubBaseUrl"/>, where {0} is the mod ID.</summary>
-        public string ChucklefishModPageUrlFormat { get; set; }
-
-
-        /****
-        ** GitHub
-        ****/
-        /// <summary>The base URL for the GitHub API.</summary>
-        public string GitHubBaseUrl { get; set; }
-
-        /// <summary>The URL for a GitHub API query for the latest stable release, excluding the <see cref="GitHubBaseUrl"/>, where {0} is the organisation and project name.</summary>
-        public string GitHubStableReleaseUrlFormat { get; set; }
-
-        /// <summary>The URL for a GitHub API query for the latest release (including prerelease), excluding the <see cref="GitHubBaseUrl"/>, where {0} is the organisation and project name.</summary>
-        public string GitHubAnyReleaseUrlFormat { get; set; }
-
-        /// <summary>The Accept header value expected by the GitHub API.</summary>
-        public string GitHubAcceptHeader { get; set; }
-
-        /// <summary>The username with which to authenticate to the GitHub API (if any).</summary>
-        public string GitHubUsername { get; set; }
-
-        /// <summary>The password with which to authenticate to the GitHub API (if any).</summary>
-        public string GitHubPassword { get; set; }
-
-        /****
-        ** ModDrop
-        ****/
-        /// <summary>The base URL for the ModDrop API.</summary>
-        public string ModDropApiUrl { get; set; }
-
-        /// <summary>The URL for a ModDrop mod page for the user, where {0} is the mod ID.</summary>
-        public string ModDropModPageUrl { get; set; }
-
-        /****
-        ** Nexus Mods
-        ****/
-        /// <summary>The base URL for the Nexus Mods API.</summary>
-        public string NexusBaseUrl { get; set; }
-
-        /// <summary>The URL for a Nexus mod page for the user, excluding the <see cref="NexusBaseUrl"/>, where {0} is the mod ID.</summary>
-        public string NexusModUrlFormat { get; set; }
-
-        /// <summary>The URL for a Nexus mod page to scrape for versions, excluding the <see cref="NexusBaseUrl"/>, where {0} is the mod ID.</summary>
-        public string NexusModScrapeUrlFormat { get; set; }
-
-        /****
-        ** Pastebin
-        ****/
-        /// <summary>The base URL for the Pastebin API.</summary>
-        public string PastebinBaseUrl { get; set; }
-
-        /// <summary>The user key used to authenticate with the Pastebin API.</summary>
-        public string PastebinUserKey { get; set; }
-
-        /// <summary>The developer key used to authenticate with the Pastebin API.</summary>
-        public string PastebinDevKey { get; set; }
-
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ConfigModels/ModCompatibilityListConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/ModCompatibilityListConfig.cs
deleted file mode 100644
index d9ac9f02..00000000
--- a/src/SMAPI.Web/Framework/ConfigModels/ModCompatibilityListConfig.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.ConfigModels
-{
-    /// <summary>The config settings for mod compatibility list.</summary>
-    internal class ModCompatibilityListConfig
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The number of minutes data from the wiki should be cached before refetching it.</summary>
-        public int CacheMinutes { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ConfigModels/ModUpdateCheckConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/ModUpdateCheckConfig.cs
deleted file mode 100644
index bde566c0..00000000
--- a/src/SMAPI.Web/Framework/ConfigModels/ModUpdateCheckConfig.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.ConfigModels
-{
-    /// <summary>The config settings for mod update checks.</summary>
-    internal class ModUpdateCheckConfig
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The number of minutes successful update checks should be cached before refetching them.</summary>
-        public int SuccessCacheMinutes { get; set; }
-
-        /// <summary>The number of minutes failed update checks should be cached before refetching them.</summary>
-        public int ErrorCacheMinutes { get; set; }
-
-        /// <summary>A regex which matches SMAPI-style semantic version.</summary>
-        /// <remarks>Derived from SMAPI's SemanticVersion implementation.</remarks>
-        public string SemanticVersionRegex { get; set; }
-
-        /// <summary>The web URL for the wiki compatibility list.</summary>
-        public string CompatibilityPageUrl { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ConfigModels/SiteConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/SiteConfig.cs
deleted file mode 100644
index d89a4260..00000000
--- a/src/SMAPI.Web/Framework/ConfigModels/SiteConfig.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.ConfigModels
-{
-    /// <summary>The site config settings.</summary>
-    public class SiteConfig // must be public to pass into views
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The root URL for the app.</summary>
-        public string RootUrl { get; set; }
-
-        /// <summary>The root URL for the log parser.</summary>
-        public string LogParserUrl { get; set; }
-
-        /// <summary>The root URL for the mod list.</summary>
-        public string ModListUrl { get; set; }
-
-        /// <summary>Whether to show SMAPI beta versions on the main page, if any.</summary>
-        public bool BetaEnabled { get; set; }
-
-        /// <summary>A short sentence shown under the beta download button, if any.</summary>
-        public string BetaBlurb { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/InternalControllerFeatureProvider.cs b/src/SMAPI.Web/Framework/InternalControllerFeatureProvider.cs
deleted file mode 100644
index 2c24c610..00000000
--- a/src/SMAPI.Web/Framework/InternalControllerFeatureProvider.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using System;
-using System.Reflection;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Controllers;
-
-namespace StardewModdingAPI.Web.Framework
-{
-    /// <summary>Discovers controllers with support for non-public controllers.</summary>
-    internal class InternalControllerFeatureProvider : ControllerFeatureProvider
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Determines if a given type is a controller.</summary>
-        /// <param name="type">The <see cref="T:System.Reflection.TypeInfo" /> candidate.</param>
-        /// <returns><code>true</code> if the type is a controller; otherwise <code>false</code>.</returns>
-        protected override bool IsController(TypeInfo type)
-        {
-            return
-                type.IsClass
-                && !type.IsAbstract
-                && (/*type.IsPublic &&*/ !type.ContainsGenericParameters)
-                && (!type.IsDefined(typeof(NonControllerAttribute))
-                && (type.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase) || type.IsDefined(typeof(ControllerAttribute))));
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/LogParsing/LogParseException.cs b/src/SMAPI.Web/Framework/LogParsing/LogParseException.cs
deleted file mode 100644
index 5d4c8c08..00000000
--- a/src/SMAPI.Web/Framework/LogParsing/LogParseException.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System;
-
-namespace StardewModdingAPI.Web.Framework.LogParsing
-{
-    /// <summary>An error while parsing the log file which doesn't require a stack trace to troubleshoot.</summary>
-    internal class LogParseException : Exception
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="message">The user-friendly error message.</param>
-        public LogParseException(string message) : base(message) { }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/LogParsing/LogParser.cs b/src/SMAPI.Web/Framework/LogParsing/LogParser.cs
deleted file mode 100644
index 3f33c0c1..00000000
--- a/src/SMAPI.Web/Framework/LogParsing/LogParser.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Web.Framework.LogParsing.Models;
-
-namespace StardewModdingAPI.Web.Framework.LogParsing
-{
-    /// <summary>Parses SMAPI log files.</summary>
-    public class LogParser
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>A regex pattern matching the start of a SMAPI message.</summary>
-        private readonly Regex MessageHeaderPattern = new Regex(@"^\[(?<time>\d\d:\d\d:\d\d) (?<level>[a-z]+) +(?<modName>[^\]]+)\] ", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching SMAPI's initial platform info message.</summary>
-        private readonly Regex InfoLinePattern = new Regex(@"^SMAPI (?<apiVersion>.+) with Stardew Valley (?<gameVersion>.+) on (?<os>.+)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching SMAPI's mod folder path line.</summary>
-        private readonly Regex ModPathPattern = new Regex(@"^Mods go here: (?<path>.+)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching SMAPI's log timestamp line.</summary>
-        private readonly Regex LogStartedAtPattern = new Regex(@"^Log started at (?<timestamp>.+) UTC", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching the start of SMAPI's mod list.</summary>
-        private readonly Regex ModListStartPattern = new Regex(@"^Loaded \d+ mods:$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching an entry in SMAPI's mod list.</summary>
-        /// <remarks>The author name and description are optional.</remarks>
-        private readonly Regex ModListEntryPattern = new Regex(@"^   (?<name>.+?) (?<version>" + SemanticVersion.UnboundedVersionPattern + @")(?: by (?<author>[^\|]+))?(?: \| (?<description>.+))?$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching the start of SMAPI's content pack list.</summary>
-        private readonly Regex ContentPackListStartPattern = new Regex(@"^Loaded \d+ content packs:$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching an entry in SMAPI's content pack list.</summary>
-        private readonly Regex ContentPackListEntryPattern = new Regex(@"^   (?<name>.+) (?<version>.+) by (?<author>.+) \| for (?<for>.+?)(?: \| (?<description>.+))?$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching the start of SMAPI's mod update list.</summary>
-        private readonly Regex ModUpdateListStartPattern = new Regex(@"^You can update \d+ mods?:$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching an entry in SMAPI's mod update list.</summary>
-        private readonly Regex ModUpdateListEntryPattern = new Regex(@"^   (?<name>.+?) (?<version>" + SemanticVersion.UnboundedVersionPattern + @"): (?<link>.+)$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        /// <summary>A regex pattern matching SMAPI's update line.</summary>
-        private readonly Regex SMAPIUpdatePattern = new Regex(@"^You can update SMAPI to (?<version>" + SemanticVersion.UnboundedVersionPattern + @"): (?<link>.+)$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Parse SMAPI log text.</summary>
-        /// <param name="logText">The SMAPI log text.</param>
-        public ParsedLog Parse(string logText)
-        {
-            try
-            {
-                // skip if empty
-                if (string.IsNullOrWhiteSpace(logText))
-                {
-                    return new ParsedLog
-                    {
-                        IsValid = false,
-                        RawText = logText,
-                        Error = "The log is empty."
-                    };
-                }
-
-                // init log
-                ParsedLog log = new ParsedLog
-                {
-                    IsValid = true,
-                    RawText = logText,
-                    Messages = this.CollapseRepeats(this.GetMessages(logText)).ToArray()
-                };
-
-                // parse log messages
-                LogModInfo smapiMod = new LogModInfo { Name = "SMAPI", Author = "Pathoschild", Description = "", Loaded = true };
-                LogModInfo gameMod = new LogModInfo { Name = "game", Author = "", Description = "", Loaded = true };
-                IDictionary<string, LogModInfo> mods = new Dictionary<string, LogModInfo>();
-                bool inModList = false;
-                bool inContentPackList = false;
-                bool inModUpdateList = false;
-                foreach (LogMessage message in log.Messages)
-                {
-                    // collect stats
-                    if (message.Level == LogLevel.Error)
-                    {
-                        switch (message.Mod)
-                        {
-                            case "SMAPI":
-                                smapiMod.Errors++;
-                                break;
-
-                            case "game":
-                                gameMod.Errors++;
-                                break;
-
-                            default:
-                                if (mods.ContainsKey(message.Mod))
-                                    mods[message.Mod].Errors++;
-                                break;
-                        }
-                    }
-
-                    // collect SMAPI metadata
-                    if (message.Mod == "SMAPI")
-                    {
-                        // update flags
-                        if (inModList && !this.ModListEntryPattern.IsMatch(message.Text))
-                            inModList = false;
-                        if (inContentPackList && !this.ContentPackListEntryPattern.IsMatch(message.Text))
-                            inContentPackList = false;
-                        if (inModUpdateList && !this.ModUpdateListEntryPattern.IsMatch(message.Text))
-                            inModUpdateList = false;
-
-                        // mod list
-                        if (!inModList && message.Level == LogLevel.Info && this.ModListStartPattern.IsMatch(message.Text))
-                        {
-                            inModList = true;
-                            message.IsStartOfSection = true;
-                            message.Section = LogSection.ModsList;
-                        }
-                        else if (inModList)
-                        {
-                            Match match = this.ModListEntryPattern.Match(message.Text);
-                            string name = match.Groups["name"].Value;
-                            string version = match.Groups["version"].Value;
-                            string author = match.Groups["author"].Value;
-                            string description = match.Groups["description"].Value;
-                            mods[name] = new LogModInfo { Name = name, Author = author, Version = version, Description = description, Loaded = true };
-
-                            message.Section = LogSection.ModsList;
-                        }
-
-                        // content pack list
-                        else if (!inContentPackList && message.Level == LogLevel.Info && this.ContentPackListStartPattern.IsMatch(message.Text))
-                        {
-                            inContentPackList = true;
-                            message.IsStartOfSection = true;
-                            message.Section = LogSection.ContentPackList;
-                        }
-                        else if (inContentPackList)
-                        {
-                            Match match = this.ContentPackListEntryPattern.Match(message.Text);
-                            string name = match.Groups["name"].Value;
-                            string version = match.Groups["version"].Value;
-                            string author = match.Groups["author"].Value;
-                            string description = match.Groups["description"].Value;
-                            string forMod = match.Groups["for"].Value;
-                            mods[name] = new LogModInfo { Name = name, Author = author, Version = version, Description = description, ContentPackFor = forMod, Loaded = true };
-
-                            message.Section = LogSection.ContentPackList;
-                        }
-
-                        // mod update list
-                        else if (!inModUpdateList && message.Level == LogLevel.Alert && this.ModUpdateListStartPattern.IsMatch(message.Text))
-                        {
-                            inModUpdateList = true;
-                            message.IsStartOfSection = true;
-                            message.Section = LogSection.ModUpdateList;
-                        }
-                        else if (inModUpdateList)
-                        {
-                            Match match = this.ModUpdateListEntryPattern.Match(message.Text);
-                            string name = match.Groups["name"].Value;
-                            string version = match.Groups["version"].Value;
-                            string link = match.Groups["link"].Value;
-                            if (mods.ContainsKey(name))
-                            {
-                                mods[name].UpdateLink = link;
-                                mods[name].UpdateVersion = version;
-                            }
-                            else
-                            {
-                                mods[name] = new LogModInfo { Name = name, UpdateVersion = version, UpdateLink = link, Loaded = false };
-                            }
-
-                            message.Section = LogSection.ModUpdateList;
-                        }
-
-                        else if (message.Level == LogLevel.Alert && this.SMAPIUpdatePattern.IsMatch(message.Text))
-                        {
-                            Match match = this.SMAPIUpdatePattern.Match(message.Text);
-                            string version = match.Groups["version"].Value;
-                            string link = match.Groups["link"].Value;
-                            smapiMod.UpdateVersion = version;
-                            smapiMod.UpdateLink = link;
-                        }
-
-                        // platform info line
-                        else if (message.Level == LogLevel.Info && this.InfoLinePattern.IsMatch(message.Text))
-                        {
-                            Match match = this.InfoLinePattern.Match(message.Text);
-                            log.ApiVersion = match.Groups["apiVersion"].Value;
-                            log.GameVersion = match.Groups["gameVersion"].Value;
-                            log.OperatingSystem = match.Groups["os"].Value;
-                            smapiMod.Version = log.ApiVersion;
-                        }
-
-                        // mod path line
-                        else if (message.Level == LogLevel.Debug && this.ModPathPattern.IsMatch(message.Text))
-                        {
-                            Match match = this.ModPathPattern.Match(message.Text);
-                            log.ModPath = match.Groups["path"].Value;
-                            int lastDelimiterPos = log.ModPath.LastIndexOfAny(new char[] { '/', '\\' });
-                            log.GamePath = lastDelimiterPos >= 0
-                                ? log.ModPath.Substring(0, lastDelimiterPos)
-                                : log.ModPath;
-                        }
-
-                        // log UTC timestamp line
-                        else if (message.Level == LogLevel.Trace && this.LogStartedAtPattern.IsMatch(message.Text))
-                        {
-                            Match match = this.LogStartedAtPattern.Match(message.Text);
-                            log.Timestamp = DateTime.Parse(match.Groups["timestamp"].Value + "Z");
-                        }
-                    }
-                }
-
-                // finalise log
-                gameMod.Version = log.GameVersion;
-                log.Mods = new[] { gameMod, smapiMod }.Concat(mods.Values.OrderBy(p => p.Name)).ToArray();
-                return log;
-            }
-            catch (LogParseException ex)
-            {
-                return new ParsedLog
-                {
-                    IsValid = false,
-                    Error = ex.Message,
-                    RawText = logText
-                };
-            }
-            catch (Exception ex)
-            {
-                return new ParsedLog
-                {
-                    IsValid = false,
-                    Error = $"Parsing the log file failed. Technical details:\n{ex}",
-                    RawText = logText
-                };
-            }
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Collapse consecutive repeats into the previous message.</summary>
-        /// <param name="messages">The messages to filter.</param>
-        private IEnumerable<LogMessage> CollapseRepeats(IEnumerable<LogMessage> messages)
-        {
-            LogMessage next = null;
-            foreach (LogMessage message in messages)
-            {
-                // new message
-                if (next == null)
-                {
-                    next = message;
-                    continue;
-                }
-
-                // repeat
-                if (next.Level == message.Level && next.Mod == message.Mod && next.Text == message.Text)
-                {
-                    next.Repeated++;
-                    continue;
-                }
-
-                // non-repeat message
-                yield return next;
-                next = message;
-            }
-            yield return next;
-        }
-
-        /// <summary>Split a SMAPI log into individual log messages.</summary>
-        /// <param name="logText">The SMAPI log text.</param>
-        /// <exception cref="LogParseException">The log text can't be parsed successfully.</exception>
-        private IEnumerable<LogMessage> GetMessages(string logText)
-        {
-            LogMessage message = new LogMessage();
-            using (StringReader reader = new StringReader(logText))
-            {
-                while (true)
-                {
-                    // read data
-                    string line = reader.ReadLine();
-                    if (line == null)
-                        break;
-                    Match header = this.MessageHeaderPattern.Match(line);
-
-                    // validate
-                    if (message.Text == null && !header.Success)
-                        throw new LogParseException("Found a log message with no SMAPI metadata. Is this a SMAPI log file?");
-
-                    // start or continue message
-                    if (header.Success)
-                    {
-                        if (message.Text != null)
-                            yield return message;
-
-                        message = new LogMessage
-                        {
-                            Time = header.Groups["time"].Value,
-                            Level = Enum.Parse<LogLevel>(header.Groups["level"].Value, ignoreCase: true),
-                            Mod = header.Groups["modName"].Value,
-                            Text = line.Substring(header.Length)
-                        };
-                    }
-                    else
-                        message.Text += "\n" + line;
-                }
-
-                // end last message
-                if (message.Text != null)
-                    yield return message;
-            }
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/LogParsing/Models/LogLevel.cs b/src/SMAPI.Web/Framework/LogParsing/Models/LogLevel.cs
deleted file mode 100644
index 759f15db..00000000
--- a/src/SMAPI.Web/Framework/LogParsing/Models/LogLevel.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using StardewModdingAPI.Internal.ConsoleWriting;
-
-namespace StardewModdingAPI.Web.Framework.LogParsing.Models
-{
-    /// <summary>The log severity levels.</summary>
-    public enum LogLevel
-    {
-        /// <summary>Tracing info intended for developers.</summary>
-        Trace = ConsoleLogLevel.Trace,
-
-        /// <summary>Troubleshooting info that may be relevant to the player.</summary>
-        Debug = ConsoleLogLevel.Debug,
-
-        /// <summary>Info relevant to the player. This should be used judiciously.</summary>
-        Info = ConsoleLogLevel.Info,
-
-        /// <summary>An issue the player should be aware of. This should be used rarely.</summary>
-        Warn = ConsoleLogLevel.Warn,
-
-        /// <summary>A message indicating something went wrong.</summary>
-        Error = ConsoleLogLevel.Error,
-
-        /// <summary>Important information to highlight for the player when player action is needed (e.g. new version available). This should be used rarely to avoid alert fatigue.</summary>
-        Alert = ConsoleLogLevel.Alert,
-
-        /// <summary>A critical issue that generally signals an immediate end to the application.</summary>
-        Critical = ConsoleLogLevel.Critical
-    }
-}
diff --git a/src/SMAPI.Web/Framework/LogParsing/Models/LogMessage.cs b/src/SMAPI.Web/Framework/LogParsing/Models/LogMessage.cs
deleted file mode 100644
index f7c99d02..00000000
--- a/src/SMAPI.Web/Framework/LogParsing/Models/LogMessage.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.LogParsing.Models
-{
-    /// <summary>A parsed log message.</summary>
-    public class LogMessage
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The local time when the log was posted.</summary>
-        public string Time { get; set; }
-
-        /// <summary>The log level.</summary>
-        public LogLevel Level { get; set; }
-
-        /// <summary>The mod name.</summary>
-        public string Mod { get; set; }
-
-        /// <summary>The log text.</summary>
-        public string Text { get; set; }
-
-        /// <summary>The number of times this message was repeated consecutively.</summary>
-        public int Repeated { get; set; }
-
-        /// <summary>The section that this log message belongs to.</summary>
-        public LogSection? Section { get; set; }
-
-        /// <summary>Whether this message is the first one of its section.</summary>
-        public bool IsStartOfSection { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/LogParsing/Models/LogModInfo.cs b/src/SMAPI.Web/Framework/LogParsing/Models/LogModInfo.cs
deleted file mode 100644
index 067e4df4..00000000
--- a/src/SMAPI.Web/Framework/LogParsing/Models/LogModInfo.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.LogParsing.Models
-{
-    /// <summary>Metadata about a mod or content pack in the log.</summary>
-    public class LogModInfo
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod name.</summary>
-        public string Name { get; set; }
-
-        /// <summary>The mod author.</summary>
-        public string Author { get; set; }
-
-        /// <summary>The update version.</summary>
-        public string UpdateVersion { get; set; }
-
-        /// <summary>The update link.</summary>
-        public string UpdateLink { get; set; }
-
-        /// <summary>The mod version.</summary>
-        public string Version { get; set; }
-
-        /// <summary>The mod description.</summary>
-        public string Description { get; set; }
-
-        /// <summary>The name of the mod for which this is a content pack (if applicable).</summary>
-        public string ContentPackFor { get; set; }
-
-        /// <summary>The number of errors logged by this mod.</summary>
-        public int Errors { get; set; }
-
-        /// <summary>Whether the mod was loaded into the game.</summary>
-        public bool Loaded { get; set; }
-
-        /// <summary>Whether the mod has an update available.</summary>
-        public bool HasUpdate => this.UpdateVersion != null && this.Version != this.UpdateVersion;
-    }
-}
diff --git a/src/SMAPI.Web/Framework/LogParsing/Models/LogSection.cs b/src/SMAPI.Web/Framework/LogParsing/Models/LogSection.cs
deleted file mode 100644
index 218d546c..00000000
--- a/src/SMAPI.Web/Framework/LogParsing/Models/LogSection.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.LogParsing.Models
-{
-    /// <summary>The different sections of a log.</summary>
-    public enum LogSection
-    {
-        /// <summary>The list of mods the user has.</summary>
-        ModsList,
-
-        /// <summary>The list of content packs the user has.</summary>
-        ContentPackList,
-
-        /// <summary>The list of mod updates SMAPI has found.</summary>
-        ModUpdateList
-    }
-}
diff --git a/src/SMAPI.Web/Framework/LogParsing/Models/ParsedLog.cs b/src/SMAPI.Web/Framework/LogParsing/Models/ParsedLog.cs
deleted file mode 100644
index 87b20eb0..00000000
--- a/src/SMAPI.Web/Framework/LogParsing/Models/ParsedLog.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-using System;
-
-namespace StardewModdingAPI.Web.Framework.LogParsing.Models
-{
-    /// <summary>Parsed metadata for a log.</summary>
-    public class ParsedLog
-    {
-        /*********
-        ** Accessors
-        *********/
-        /****
-        ** Metadata
-        ****/
-        /// <summary>Whether the log file was successfully parsed.</summary>
-        public bool IsValid { get; set; }
-
-        /// <summary>An error message indicating why the log file is invalid.</summary>
-        public string Error { get; set; }
-
-        /// <summary>The raw log text.</summary>
-        public string RawText { get; set; }
-
-        /****
-        ** Log data
-        ****/
-        /// <summary>The SMAPI version.</summary>
-        public string ApiVersion { get; set; }
-
-        /// <summary>The game version.</summary>
-        public string GameVersion { get; set; }
-
-        /// <summary>The player's operating system.</summary>
-        public string OperatingSystem { get; set; }
-
-        /// <summary>The game install path.</summary>
-        public string GamePath { get; set; }
-
-        /// <summary>The mod folder path.</summary>
-        public string ModPath { get; set; }
-
-        /// <summary>The ISO 8601 timestamp when the log was started.</summary>
-        public DateTimeOffset Timestamp { get; set; }
-
-        /// <summary>Metadata about installed mods and content packs.</summary>
-        public LogModInfo[] Mods { get; set; } = new LogModInfo[0];
-
-        /// <summary>The log messages.</summary>
-        public LogMessage[] Messages { get; set; }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/BaseRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/BaseRepository.cs
deleted file mode 100644
index 94256005..00000000
--- a/src/SMAPI.Web/Framework/ModRepositories/BaseRepository.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using StardewModdingAPI.Toolkit.Framework.UpdateData;
-
-namespace StardewModdingAPI.Web.Framework.ModRepositories
-{
-    internal abstract class RepositoryBase : IModRepository
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The unique key for this vendor.</summary>
-        public ModRepositoryKey VendorKey { get; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public abstract void Dispose();
-
-        /// <summary>Get metadata about a mod in the repository.</summary>
-        /// <param name="id">The mod ID in this repository.</param>
-        public abstract Task<ModInfoModel> GetModInfoAsync(string id);
-
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="vendorKey">The unique key for this vendor.</param>
-        protected RepositoryBase(ModRepositoryKey vendorKey)
-        {
-            this.VendorKey = vendorKey;
-        }
-
-        /// <summary>Normalise a version string.</summary>
-        /// <param name="version">The version to normalise.</param>
-        protected string NormaliseVersion(string version)
-        {
-            if (string.IsNullOrWhiteSpace(version))
-                return null;
-
-            version = version.Trim();
-            if (Regex.IsMatch(version, @"^v\d", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase)) // common version prefix
-                version = version.Substring(1);
-
-            return version;
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/ChucklefishRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/ChucklefishRepository.cs
deleted file mode 100644
index 87e29a2f..00000000
--- a/src/SMAPI.Web/Framework/ModRepositories/ChucklefishRepository.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using StardewModdingAPI.Toolkit.Framework.UpdateData;
-using StardewModdingAPI.Web.Framework.Clients.Chucklefish;
-
-namespace StardewModdingAPI.Web.Framework.ModRepositories
-{
-    /// <summary>An HTTP client for fetching mod metadata from the Chucklefish mod site.</summary>
-    internal class ChucklefishRepository : RepositoryBase
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IChucklefishClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="client">The underlying HTTP client.</param>
-        public ChucklefishRepository(IChucklefishClient client)
-            : base(ModRepositoryKey.Chucklefish)
-        {
-            this.Client = client;
-        }
-
-        /// <summary>Get metadata about a mod in the repository.</summary>
-        /// <param name="id">The mod ID in this repository.</param>
-        public override async Task<ModInfoModel> GetModInfoAsync(string id)
-        {
-            // validate ID format
-            if (!uint.TryParse(id, out uint realID))
-                return new ModInfoModel($"The value '{id}' isn't a valid Chucklefish mod ID, must be an integer ID.");
-
-            // fetch info
-            try
-            {
-                var mod = await this.Client.GetModAsync(realID);
-                if (mod == null)
-                    return new ModInfoModel("Found no mod with this ID.");
-
-                // create model
-                return new ModInfoModel(name: mod.Name, version: this.NormaliseVersion(mod.Version), url: mod.Url);
-            }
-            catch (Exception ex)
-            {
-                return new ModInfoModel(ex.ToString());
-            }
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public override void Dispose()
-        {
-            this.Client.Dispose();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/GitHubRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/GitHubRepository.cs
deleted file mode 100644
index 14f44dc0..00000000
--- a/src/SMAPI.Web/Framework/ModRepositories/GitHubRepository.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using StardewModdingAPI.Toolkit.Framework.UpdateData;
-using StardewModdingAPI.Web.Framework.Clients.GitHub;
-
-namespace StardewModdingAPI.Web.Framework.ModRepositories
-{
-    /// <summary>An HTTP client for fetching mod metadata from GitHub project releases.</summary>
-    internal class GitHubRepository : RepositoryBase
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying GitHub API client.</summary>
-        private readonly IGitHubClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="client">The underlying GitHub API client.</param>
-        public GitHubRepository(IGitHubClient client)
-            : base(ModRepositoryKey.GitHub)
-        {
-            this.Client = client;
-        }
-
-        /// <summary>Get metadata about a mod in the repository.</summary>
-        /// <param name="id">The mod ID in this repository.</param>
-        public override async Task<ModInfoModel> GetModInfoAsync(string id)
-        {
-            // validate ID format
-            if (!id.Contains("/") || id.IndexOf("/", StringComparison.InvariantCultureIgnoreCase) != id.LastIndexOf("/", StringComparison.InvariantCultureIgnoreCase))
-                return new ModInfoModel($"The value '{id}' isn't a valid GitHub mod ID, must be a username and project name like 'Pathoschild/LookupAnything'.");
-
-            // fetch info
-            try
-            {
-                // get latest release (whether preview or stable)
-                GitRelease latest = await this.Client.GetLatestReleaseAsync(id, includePrerelease: true);
-                if (latest == null)
-                    return new ModInfoModel("Found no mod with this ID.");
-
-                // split stable/prerelease if applicable
-                GitRelease preview = null;
-                if (latest.IsPrerelease)
-                {
-                    GitRelease result = await this.Client.GetLatestReleaseAsync(id, includePrerelease: false);
-                    if (result != null)
-                    {
-                        preview = latest;
-                        latest = result;
-                    }
-                }
-
-                // return data
-                return new ModInfoModel(name: id, version: this.NormaliseVersion(latest.Tag), previewVersion: this.NormaliseVersion(preview?.Tag), url: $"https://github.com/{id}/releases");
-            }
-            catch (Exception ex)
-            {
-                return new ModInfoModel(ex.ToString());
-            }
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public override void Dispose()
-        {
-            this.Client.Dispose();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/IModRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/IModRepository.cs
deleted file mode 100644
index 68f754ae..00000000
--- a/src/SMAPI.Web/Framework/ModRepositories/IModRepository.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using StardewModdingAPI.Toolkit.Framework.UpdateData;
-
-namespace StardewModdingAPI.Web.Framework.ModRepositories
-{
-    /// <summary>A repository which provides mod metadata.</summary>
-    internal interface IModRepository : IDisposable
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The unique key for this vendor.</summary>
-        ModRepositoryKey VendorKey { get; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Get metadata about a mod in the repository.</summary>
-        /// <param name="id">The mod ID in this repository.</param>
-        Task<ModInfoModel> GetModInfoAsync(string id);
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/ModDropRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/ModDropRepository.cs
deleted file mode 100644
index 1994f515..00000000
--- a/src/SMAPI.Web/Framework/ModRepositories/ModDropRepository.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using StardewModdingAPI.Toolkit.Framework.UpdateData;
-using StardewModdingAPI.Web.Framework.Clients.ModDrop;
-
-namespace StardewModdingAPI.Web.Framework.ModRepositories
-{
-    /// <summary>An HTTP client for fetching mod metadata from the ModDrop API.</summary>
-    internal class ModDropRepository : RepositoryBase
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying ModDrop API client.</summary>
-        private readonly IModDropClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="client">The underlying Nexus Mods API client.</param>
-        public ModDropRepository(IModDropClient client)
-            : base(ModRepositoryKey.ModDrop)
-        {
-            this.Client = client;
-        }
-
-        /// <summary>Get metadata about a mod in the repository.</summary>
-        /// <param name="id">The mod ID in this repository.</param>
-        public override async Task<ModInfoModel> GetModInfoAsync(string id)
-        {
-            // validate ID format
-            if (!long.TryParse(id, out long modDropID))
-                return new ModInfoModel($"The value '{id}' isn't a valid ModDrop mod ID, must be an integer ID.");
-
-            // fetch info
-            try
-            {
-                ModDropMod mod = await this.Client.GetModAsync(modDropID);
-                if (mod == null)
-                    return new ModInfoModel("Found no mod with this ID.");
-                if (mod.Error != null)
-                    return new ModInfoModel(mod.Error);
-                return new ModInfoModel(name: mod.Name, version: mod.LatestDefaultVersion?.ToString(), previewVersion: mod.LatestOptionalVersion?.ToString(), url: mod.Url);
-            }
-            catch (Exception ex)
-            {
-                return new ModInfoModel(ex.ToString());
-            }
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public override void Dispose()
-        {
-            this.Client.Dispose();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/ModInfoModel.cs b/src/SMAPI.Web/Framework/ModRepositories/ModInfoModel.cs
deleted file mode 100644
index 18252298..00000000
--- a/src/SMAPI.Web/Framework/ModRepositories/ModInfoModel.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-namespace StardewModdingAPI.Web.Framework.ModRepositories
-{
-    /// <summary>Generic metadata about a mod.</summary>
-    internal class ModInfoModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod name.</summary>
-        public string Name { get; set; }
-
-        /// <summary>The mod's latest release number.</summary>
-        public string Version { get; set; }
-
-        /// <summary>The mod's latest optional release, if newer than <see cref="Version"/>.</summary>
-        public string PreviewVersion { get; set; }
-
-        /// <summary>The mod's web URL.</summary>
-        public string Url { get; set; }
-
-        /// <summary>The error message indicating why the mod is invalid (if applicable).</summary>
-        public string Error { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an empty instance.</summary>
-        public ModInfoModel()
-        {
-            // needed for JSON deserialising
-        }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="name">The mod name.</param>
-        /// <param name="version">The semantic version for the mod's latest release.</param>
-        /// <param name="previewVersion">The semantic version for the mod's latest preview release, if available and different from <see cref="Version"/>.</param>
-        /// <param name="url">The mod's web URL.</param>
-        /// <param name="error">The error message indicating why the mod is invalid (if applicable).</param>
-        public ModInfoModel(string name, string version, string url, string previewVersion = null, string error = null)
-        {
-            this.Name = name;
-            this.Version = version;
-            this.PreviewVersion = previewVersion;
-            this.Url = url;
-            this.Error = error;
-        }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="error">The error message indicating why the mod is invalid.</param>
-        public ModInfoModel(string error)
-        {
-            this.Error = error;
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/NexusRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/NexusRepository.cs
deleted file mode 100644
index 4c5fe9bf..00000000
--- a/src/SMAPI.Web/Framework/ModRepositories/NexusRepository.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using StardewModdingAPI.Toolkit.Framework.UpdateData;
-using StardewModdingAPI.Web.Framework.Clients.Nexus;
-
-namespace StardewModdingAPI.Web.Framework.ModRepositories
-{
-    /// <summary>An HTTP client for fetching mod metadata from Nexus Mods.</summary>
-    internal class NexusRepository : RepositoryBase
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying Nexus Mods API client.</summary>
-        private readonly INexusClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="client">The underlying Nexus Mods API client.</param>
-        public NexusRepository(INexusClient client)
-            : base(ModRepositoryKey.Nexus)
-        {
-            this.Client = client;
-        }
-
-        /// <summary>Get metadata about a mod in the repository.</summary>
-        /// <param name="id">The mod ID in this repository.</param>
-        public override async Task<ModInfoModel> GetModInfoAsync(string id)
-        {
-            // validate ID format
-            if (!uint.TryParse(id, out uint nexusID))
-                return new ModInfoModel($"The value '{id}' isn't a valid Nexus mod ID, must be an integer ID.");
-
-            // fetch info
-            try
-            {
-                NexusMod mod = await this.Client.GetModAsync(nexusID);
-                if (mod == null)
-                    return new ModInfoModel("Found no mod with this ID.");
-                if (mod.Error != null)
-                    return new ModInfoModel(mod.Error);
-                return new ModInfoModel(name: mod.Name, version: this.NormaliseVersion(mod.Version), previewVersion: mod.LatestFileVersion?.ToString(), url: mod.Url);
-            }
-            catch (Exception ex)
-            {
-                return new ModInfoModel(ex.ToString());
-            }
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public override void Dispose()
-        {
-            this.Client.Dispose();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/RewriteRules/ConditionalRedirectToHttpsRule.cs b/src/SMAPI.Web/Framework/RewriteRules/ConditionalRedirectToHttpsRule.cs
deleted file mode 100644
index 36effd82..00000000
--- a/src/SMAPI.Web/Framework/RewriteRules/ConditionalRedirectToHttpsRule.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-using System;
-using System.Net;
-using System.Text;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Rewrite;
-
-namespace StardewModdingAPI.Web.Framework.RewriteRules
-{
-    /// <summary>Redirect requests to HTTPS.</summary>
-    /// <remarks>Derived from <a href="https://stackoverflow.com/a/44526747/262123" /> and <see cref="Microsoft.AspNetCore.Rewrite.Internal.RedirectToHttpsRule"/>.</remarks>
-    internal class ConditionalRedirectToHttpsRule : IRule
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>A predicate which indicates when the rule should be applied.</summary>
-        private readonly Func<HttpRequest, bool> ShouldRewrite;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="shouldRewrite">A predicate which indicates when the rule should be applied.</param>
-        public ConditionalRedirectToHttpsRule(Func<HttpRequest, bool> shouldRewrite = null)
-        {
-            this.ShouldRewrite = shouldRewrite ?? (req => true);
-        }
-
-        /// <summary>Applies the rule. Implementations of ApplyRule should set the value for <see cref="RewriteContext.Result" /> (defaults to RuleResult.ContinueRules).</summary>
-        /// <param name="context">The rewrite context.</param>
-        public void ApplyRule(RewriteContext context)
-        {
-            HttpRequest request = context.HttpContext.Request;
-
-            // check condition
-            if (this.IsSecure(request) || !this.ShouldRewrite(request))
-                return;
-
-            // redirect request
-            HttpResponse response = context.HttpContext.Response;
-            response.StatusCode = (int)HttpStatusCode.RedirectKeepVerb;
-            response.Headers["Location"] = new StringBuilder()
-                .Append("https://")
-                .Append(request.Host.Host)
-                .Append(request.PathBase)
-                .Append(request.Path)
-                .Append(request.QueryString)
-                .ToString();
-            context.Result = RuleResult.EndResponse;
-        }
-
-        /// <summary>Get whether the request was received over HTTPS.</summary>
-        /// <param name="request">The request to check.</param>
-        public bool IsSecure(HttpRequest request)
-        {
-            return
-                request.IsHttps // HTTPS to server
-                || string.Equals(request.Headers["x-forwarded-proto"], "HTTPS", StringComparison.OrdinalIgnoreCase); // HTTPS to AWS load balancer
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/RewriteRules/ConditionalRewriteSubdomainRule.cs b/src/SMAPI.Web/Framework/RewriteRules/ConditionalRewriteSubdomainRule.cs
deleted file mode 100644
index 920632ab..00000000
--- a/src/SMAPI.Web/Framework/RewriteRules/ConditionalRewriteSubdomainRule.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-using System;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Rewrite;
-
-namespace StardewModdingAPI.Web.Framework.RewriteRules
-{
-    /// <summary>Rewrite requests to prepend the subdomain portion (if any) to the path.</summary>
-    /// <remarks>Derived from <a href="https://stackoverflow.com/a/44526747/262123" />.</remarks>
-    internal class ConditionalRewriteSubdomainRule : IRule
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A predicate which indicates when the rule should be applied.</summary>
-        private readonly Func<HttpRequest, bool> ShouldRewrite;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="shouldRewrite">A predicate which indicates when the rule should be applied.</param>
-        public ConditionalRewriteSubdomainRule(Func<HttpRequest, bool> shouldRewrite = null)
-        {
-            this.ShouldRewrite = shouldRewrite ?? (req => true);
-        }
-
-        /// <summary>Applies the rule. Implementations of ApplyRule should set the value for <see cref="RewriteContext.Result" /> (defaults to RuleResult.ContinueRules).</summary>
-        /// <param name="context">The rewrite context.</param>
-        public void ApplyRule(RewriteContext context)
-        {
-            HttpRequest request = context.HttpContext.Request;
-
-            // check condition
-            if (!this.ShouldRewrite(request))
-                return;
-
-            // get host parts
-            string host = request.Host.Host;
-            string[] parts = host.Split('.');
-            if (parts.Length < 2)
-                return;
-
-            // prepend to path
-            request.Path = $"/{parts[0]}{request.Path}";
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/RewriteRules/RedirectToUrlRule.cs b/src/SMAPI.Web/Framework/RewriteRules/RedirectToUrlRule.cs
deleted file mode 100644
index ab9e019c..00000000
--- a/src/SMAPI.Web/Framework/RewriteRules/RedirectToUrlRule.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-using System;
-using System.Net;
-using System.Text.RegularExpressions;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Rewrite;
-
-namespace StardewModdingAPI.Web.Framework.RewriteRules
-{
-    /// <summary>Redirect requests to an external URL if they match a condition.</summary>
-    internal class RedirectToUrlRule : IRule
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Get the new URL to which to redirect (or <c>null</c> to skip).</summary>
-        private readonly Func<HttpRequest, string> NewUrl;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="shouldRewrite">A predicate which indicates when the rule should be applied.</param>
-        /// <param name="url">The new URL to which to redirect.</param>
-        public RedirectToUrlRule(Func<HttpRequest, bool> shouldRewrite, string url)
-        {
-            this.NewUrl = req => shouldRewrite(req) ? url : null;
-        }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="pathRegex">A case-insensitive regex to match against the path.</param>
-        /// <param name="url">The external URL.</param>
-        public RedirectToUrlRule(string pathRegex, string url)
-        {
-            Regex regex = new Regex(pathRegex, RegexOptions.IgnoreCase | RegexOptions.Compiled);
-            this.NewUrl = req => req.Path.HasValue ? regex.Replace(req.Path.Value, url) : null;
-        }
-
-        /// <summary>Applies the rule. Implementations of ApplyRule should set the value for <see cref="RewriteContext.Result" /> (defaults to RuleResult.ContinueRules).</summary>
-        /// <param name="context">The rewrite context.</param>
-        public void ApplyRule(RewriteContext context)
-        {
-            HttpRequest request = context.HttpContext.Request;
-
-            // check rewrite
-            string newUrl = this.NewUrl(request);
-            if (newUrl == null || newUrl == request.Path.Value)
-                return;
-
-            // redirect request
-            HttpResponse response = context.HttpContext.Response;
-            response.StatusCode = (int)HttpStatusCode.Redirect;
-            response.Headers["Location"] = newUrl;
-            context.Result = RuleResult.EndResponse;
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/VersionConstraint.cs b/src/SMAPI.Web/Framework/VersionConstraint.cs
deleted file mode 100644
index 2d6ec603..00000000
--- a/src/SMAPI.Web/Framework/VersionConstraint.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using Microsoft.AspNetCore.Routing.Constraints;
-using StardewModdingAPI.Toolkit;
-
-namespace StardewModdingAPI.Web.Framework
-{
-    /// <summary>Constrains a route value to a valid semantic version.</summary>
-    internal class VersionConstraint : RegexRouteConstraint
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public VersionConstraint()
-            : base(SemanticVersion.Regex) { }
-    }
-}
diff --git a/src/SMAPI.Web/Program.cs b/src/SMAPI.Web/Program.cs
deleted file mode 100644
index 5856fc98..00000000
--- a/src/SMAPI.Web/Program.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using Microsoft.AspNetCore;
-using Microsoft.AspNetCore.Hosting;
-
-namespace StardewModdingAPI.Web
-{
-    /// <summary>The main app entry point.</summary>
-    public class Program
-    {
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>The main app entry point.</summary>
-        /// <param name="args">The command-line arguments.</param>
-        public static void Main(string[] args)
-        {
-            // configure web server
-            WebHost
-                .CreateDefaultBuilder(args)
-                .UseStartup<Startup>()
-                .Build()
-                .Run();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Properties/AssemblyInfo.cs b/src/SMAPI.Web/Properties/AssemblyInfo.cs
deleted file mode 100644
index 31e6fc30..00000000
--- a/src/SMAPI.Web/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("SMAPI.Web")]
-[assembly: AssemblyDescription("")]
diff --git a/src/SMAPI.Web/Properties/launchSettings.json b/src/SMAPI.Web/Properties/launchSettings.json
deleted file mode 100644
index 88179044..00000000
--- a/src/SMAPI.Web/Properties/launchSettings.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:59482/",
-      "sslPort": 0
-    }
-  },
-  "profiles": {
-    "IIS Express": {
-      "commandName": "IISExpress",
-      "launchBrowser": true,
-      "launchUrl": "",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      }
-    }
-  }
-}
diff --git a/src/SMAPI.Web/StardewModdingAPI.Web.csproj b/src/SMAPI.Web/StardewModdingAPI.Web.csproj
deleted file mode 100644
index db3bd14e..00000000
--- a/src/SMAPI.Web/StardewModdingAPI.Web.csproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs" Link="Properties\GlobalAssemblyInfo.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="HtmlAgilityPack" Version="1.8.11" />
-    <PackageReference Include="Markdig" Version="0.15.6" />
-    <PackageReference Include="Microsoft.AspNetCore" Version="2.1.4" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.1.3" />
-    <PackageReference Include="Microsoft.AspNetCore.Rewrite" Version="2.1.1" />
-    <PackageReference Include="Microsoft.AspNetCore.StaticFiles" Version="2.1.1" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="2.1.1" />
-    <PackageReference Include="Pathoschild.Http.FluentClient" Version="3.2.0" />
-  </ItemGroup>
-  <ItemGroup>
-    <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="1.0.1" />
-  </ItemGroup>
-  <Import Project="..\SMAPI.Internal\SMAPI.Internal.projitems" Label="Shared" />
-  <ItemGroup>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit\StardewModdingAPI.Toolkit.csproj" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Update="Views\Index\Privacy.cshtml">
-      <Pack>$(IncludeRazorContentInPack)</Pack>
-    </Content>
-    <Content Update="Views\Mods\Index.cshtml">
-      <Pack>$(IncludeRazorContentInPack)</Pack>
-    </Content>
-    <Content Update="wwwroot\StardewModdingAPI.metadata.json">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-
-</Project>
diff --git a/src/SMAPI.Web/Startup.cs b/src/SMAPI.Web/Startup.cs
deleted file mode 100644
index a2e47482..00000000
--- a/src/SMAPI.Web/Startup.cs
+++ /dev/null
@@ -1,195 +0,0 @@
-using System.Collections.Generic;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Rewrite;
-using Microsoft.AspNetCore.Routing;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
-using StardewModdingAPI.Toolkit.Serialisation;
-using StardewModdingAPI.Web.Framework;
-using StardewModdingAPI.Web.Framework.Clients.Chucklefish;
-using StardewModdingAPI.Web.Framework.Clients.GitHub;
-using StardewModdingAPI.Web.Framework.Clients.ModDrop;
-using StardewModdingAPI.Web.Framework.Clients.Nexus;
-using StardewModdingAPI.Web.Framework.Clients.Pastebin;
-using StardewModdingAPI.Web.Framework.ConfigModels;
-using StardewModdingAPI.Web.Framework.RewriteRules;
-
-namespace StardewModdingAPI.Web
-{
-    /// <summary>The web app startup configuration.</summary>
-    internal class Startup
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The web app configuration.</summary>
-        public IConfigurationRoot Configuration { get; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="env">The hosting environment.</param>
-        public Startup(IHostingEnvironment env)
-        {
-            this.Configuration = new ConfigurationBuilder()
-                .SetBasePath(env.ContentRootPath)
-                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
-                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
-                .Add(new BeanstalkEnvPropsConfigProvider())
-                .Build();
-        }
-
-        /// <summary>The method called by the runtime to add services to the container.</summary>
-        /// <param name="services">The service injection container.</param>
-        public void ConfigureServices(IServiceCollection services)
-        {
-            // init configuration
-            services
-                .Configure<ModCompatibilityListConfig>(this.Configuration.GetSection("ModCompatibilityList"))
-                .Configure<ModUpdateCheckConfig>(this.Configuration.GetSection("ModUpdateCheck"))
-                .Configure<SiteConfig>(this.Configuration.GetSection("Site"))
-                .Configure<RouteOptions>(options => options.ConstraintMap.Add("semanticVersion", typeof(VersionConstraint)))
-                .AddMemoryCache()
-                .AddMvc()
-                .ConfigureApplicationPartManager(manager => manager.FeatureProviders.Add(new InternalControllerFeatureProvider()))
-                .AddJsonOptions(options =>
-                {
-                    foreach (JsonConverter converter in new JsonHelper().JsonSettings.Converters)
-                        options.SerializerSettings.Converters.Add(converter);
-
-                    options.SerializerSettings.Formatting = Formatting.Indented;
-                    options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
-                });
-
-            // init API clients
-            {
-                ApiClientsConfig api = this.Configuration.GetSection("ApiClients").Get<ApiClientsConfig>();
-                string version = this.GetType().Assembly.GetName().Version.ToString(3);
-                string userAgent = string.Format(api.UserAgent, version);
-
-                services.AddSingleton<IChucklefishClient>(new ChucklefishClient(
-                    userAgent: userAgent,
-                    baseUrl: api.ChucklefishBaseUrl,
-                    modPageUrlFormat: api.ChucklefishModPageUrlFormat
-                ));
-
-                services.AddSingleton<IGitHubClient>(new GitHubClient(
-                    baseUrl: api.GitHubBaseUrl,
-                    stableReleaseUrlFormat: api.GitHubStableReleaseUrlFormat,
-                    anyReleaseUrlFormat: api.GitHubAnyReleaseUrlFormat,
-                    userAgent: userAgent,
-                    acceptHeader: api.GitHubAcceptHeader,
-                    username: api.GitHubUsername,
-                    password: api.GitHubPassword
-                ));
-
-                services.AddSingleton<IModDropClient>(new ModDropClient(
-                    userAgent: userAgent,
-                    apiUrl: api.ModDropApiUrl,
-                    modUrlFormat: api.ModDropModPageUrl
-                ));
-
-                services.AddSingleton<INexusClient>(new NexusWebScrapeClient(
-                    userAgent: userAgent,
-                    baseUrl: api.NexusBaseUrl,
-                    modUrlFormat: api.NexusModUrlFormat,
-                    modScrapeUrlFormat: api.NexusModScrapeUrlFormat
-                ));
-
-                services.AddSingleton<IPastebinClient>(new PastebinClient(
-                    baseUrl: api.PastebinBaseUrl,
-                    userAgent: userAgent,
-                    userKey: api.PastebinUserKey,
-                    devKey: api.PastebinDevKey
-                ));
-            }
-        }
-
-        /// <summary>The method called by the runtime to configure the HTTP request pipeline.</summary>
-        /// <param name="app">The application builder.</param>
-        /// <param name="env">The hosting environment.</param>
-        /// <param name="loggerFactory">The logger factory.</param>
-        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
-        {
-            loggerFactory.AddConsole(this.Configuration.GetSection("Logging"));
-            loggerFactory.AddDebug();
-
-            if (env.IsDevelopment())
-                app.UseDeveloperExceptionPage();
-
-            app
-                .UseCors(policy => policy
-                    .AllowAnyHeader()
-                    .AllowAnyMethod()
-                    .WithOrigins("https://smapi.io", "https://*.smapi.io", "https://*.edge.smapi.io")
-                    .SetIsOriginAllowedToAllowWildcardSubdomains()
-                )
-                .UseRewriter(this.GetRedirectRules())
-                .UseStaticFiles() // wwwroot folder
-                .UseMvc();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the redirect rules to apply.</summary>
-        private RewriteOptions GetRedirectRules()
-        {
-            var redirects = new RewriteOptions();
-
-            // redirect to HTTPS (except API for Linux/Mac Mono compatibility)
-            redirects.Add(new ConditionalRedirectToHttpsRule(
-                shouldRewrite: req =>
-                    req.Host.Host != "localhost"
-                    && !req.Path.StartsWithSegments("/api")
-                    && !req.Host.Host.StartsWith("api.")
-            ));
-
-            // convert subdomain.smapi.io => smapi.io/subdomain for routing
-            redirects.Add(new ConditionalRewriteSubdomainRule(
-                shouldRewrite: req =>
-                    req.Host.Host != "localhost"
-                    && (req.Host.Host.StartsWith("api.") || req.Host.Host.StartsWith("log.") || req.Host.Host.StartsWith("mods."))
-                    && !req.Path.StartsWithSegments("/content")
-                    && !req.Path.StartsWithSegments("/favicon.ico")
-            ));
-
-            // shortcut redirects
-            redirects.Add(new RedirectToUrlRule(@"^/3\.0\.?$", "https://stardewvalleywiki.com/Modding:Migrate_to_SMAPI_3.0"));
-            redirects.Add(new RedirectToUrlRule(@"^/buildmsg(?:/?(.*))$", "https://github.com/Pathoschild/SMAPI/blob/develop/docs/mod-build-config.md#$1"));
-            redirects.Add(new RedirectToUrlRule(@"^/compat\.?$", "https://mods.smapi.io"));
-            redirects.Add(new RedirectToUrlRule(@"^/docs\.?$", "https://stardewvalleywiki.com/Modding:Index"));
-            redirects.Add(new RedirectToUrlRule(@"^/install\.?$", "https://stardewvalleywiki.com/Modding:Player_Guide/Getting_Started#Install_SMAPI"));
-            redirects.Add(new RedirectToUrlRule(@"^/troubleshoot(.*)$", "https://stardewvalleywiki.com/Modding:Player_Guide/Troubleshooting$1"));
-            redirects.Add(new RedirectToUrlRule(@"^/xnb\.?$", "https://stardewvalleywiki.com/Modding:Using_XNB_mods"));
-
-            // redirect legacy canimod.com URLs
-            var wikiRedirects = new Dictionary<string, string[]>
-            {
-                ["Modding:Index#Migration_guides"] = new[] { "^/for-devs/updating-a-smapi-mod", "^/guides/updating-a-smapi-mod" },
-                ["Modding:Modder_Guide"] = new[] { "^/for-devs/creating-a-smapi-mod", "^/guides/creating-a-smapi-mod", "^/for-devs/creating-a-smapi-mod-advanced-config" },
-                ["Modding:Player_Guide"] = new[] { "^/for-players/install-smapi", "^/guides/using-mods", "^/for-players/faqs", "^/for-players/intro", "^/for-players/use-mods", "^/guides/asking-for-help", "^/guides/smapi-faq" },
-
-                ["Modding:Editing_XNB_files"] = new[] { "^/for-devs/creating-an-xnb-mod", "^/guides/creating-an-xnb-mod" },
-                ["Modding:Event_data"] = new[] { "^/for-devs/events", "^/guides/events" },
-                ["Modding:Gift_taste_data"] = new[] { "^/for-devs/npc-gift-tastes", "^/guides/npc-gift-tastes" },
-                ["Modding:IDE_reference"] = new[] { "^/for-devs/creating-a-smapi-mod-ide-primer" },
-                ["Modding:Object_data"] = new[] { "^/for-devs/object-data", "^/guides/object-data" },
-                ["Modding:Weather_data"] = new[] { "^/for-devs/weather", "^/guides/weather" }
-            };
-            foreach (KeyValuePair<string, string[]> pair in wikiRedirects)
-            {
-                foreach (string pattern in pair.Value)
-                    redirects.Add(new RedirectToUrlRule(pattern, "https://stardewvalleywiki.com/" + pair.Key));
-            }
-
-            return redirects;
-        }
-    }
-}
diff --git a/src/SMAPI.Web/ViewModels/IndexModel.cs b/src/SMAPI.Web/ViewModels/IndexModel.cs
deleted file mode 100644
index 82c4e06f..00000000
--- a/src/SMAPI.Web/ViewModels/IndexModel.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-namespace StardewModdingAPI.Web.ViewModels
-{
-    /// <summary>The view model for the index page.</summary>
-    public class IndexModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The latest stable SMAPI version.</summary>
-        public IndexVersionModel StableVersion { get; set; }
-
-        /// <summary>The latest prerelease SMAPI version (if newer than <see cref="StableVersion"/>).</summary>
-        public IndexVersionModel BetaVersion { get; set; }
-
-        /// <summary>A short sentence shown under the beta download button, if any.</summary>
-        public string BetaBlurb { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public IndexModel() { }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="stableVersion">The latest stable SMAPI version.</param>
-        /// <param name="betaVersion">The latest prerelease SMAPI version (if newer than <paramref name="stableVersion"/>).</param>
-        /// <param name="betaBlurb">A short sentence shown under the beta download button, if any.</param>
-        internal IndexModel(IndexVersionModel stableVersion, IndexVersionModel betaVersion, string betaBlurb)
-        {
-            this.StableVersion = stableVersion;
-            this.BetaVersion = betaVersion;
-            this.BetaBlurb = betaBlurb;
-        }
-    }
-}
diff --git a/src/SMAPI.Web/ViewModels/IndexVersionModel.cs b/src/SMAPI.Web/ViewModels/IndexVersionModel.cs
deleted file mode 100644
index 4f63b979..00000000
--- a/src/SMAPI.Web/ViewModels/IndexVersionModel.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-namespace StardewModdingAPI.Web.ViewModels
-{
-    /// <summary>The fields for a SMAPI version.</summary>
-    public class IndexVersionModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The release version.</summary>
-        public string Version { get; set; }
-
-        /// <summary>The Markdown description for the release.</summary>
-        public string Description { get; set; }
-
-        /// <summary>The main download URL.</summary>
-        public string DownloadUrl { get; set; }
-
-        /// <summary>The for-developers download URL (not applicable for prerelease versions).</summary>
-        public string DevDownloadUrl { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public IndexVersionModel() { }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="version">The release number.</param>
-        /// <param name="description">The Markdown description for the release.</param>
-        /// <param name="downloadUrl">The main download URL.</param>
-        /// <param name="devDownloadUrl">The for-developers download URL (not applicable for prerelease versions).</param>
-        internal IndexVersionModel(string version, string description, string downloadUrl, string devDownloadUrl)
-        {
-            this.Version = version;
-            this.Description = description;
-            this.DownloadUrl = downloadUrl;
-            this.DevDownloadUrl = devDownloadUrl;
-        }
-    }
-}
diff --git a/src/SMAPI.Web/ViewModels/LogParserModel.cs b/src/SMAPI.Web/ViewModels/LogParserModel.cs
deleted file mode 100644
index 41864c99..00000000
--- a/src/SMAPI.Web/ViewModels/LogParserModel.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
-using StardewModdingAPI.Web.Framework.LogParsing.Models;
-
-namespace StardewModdingAPI.Web.ViewModels
-{
-    /// <summary>The view model for the log parser page.</summary>
-    public class LogParserModel
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>A regex pattern matching characters to remove from a mod name to create the slug ID.</summary>
-        private readonly Regex SlugInvalidCharPattern = new Regex("[^a-z0-9]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The root URL for the log parser controller.</summary>
-        public string SectionUrl { get; set; }
-
-        /// <summary>The paste ID.</summary>
-        public string PasteID { get; set; }
-
-        /// <summary>The parsed log info.</summary>
-        public ParsedLog ParsedLog { get; set; }
-
-        /// <summary>Whether to show the raw unparsed log.</summary>
-        public bool ShowRaw { get; set; }
-
-        /// <summary>An error which occurred while uploading the log to Pastebin.</summary>
-        public string UploadError { get; set; }
-
-        /// <summary>An error which occurred while parsing the log file.</summary>
-        public string ParseError => this.ParsedLog?.Error;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public LogParserModel() { }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="sectionUrl">The root URL for the log parser controller.</param>
-        /// <param name="pasteID">The paste ID.</param>
-        public LogParserModel(string sectionUrl, string pasteID)
-        {
-            this.SectionUrl = sectionUrl;
-            this.PasteID = pasteID;
-            this.ParsedLog = null;
-            this.ShowRaw = false;
-        }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="sectionUrl">The root URL for the log parser controller.</param>
-        /// <param name="pasteID">The paste ID.</param>
-        /// <param name="parsedLog">The parsed log info.</param>
-        /// <param name="showRaw">Whether to show the raw unparsed log.</param>
-        public LogParserModel(string sectionUrl, string pasteID, ParsedLog parsedLog, bool showRaw)
-            : this(sectionUrl, pasteID)
-        {
-            this.ParsedLog = parsedLog;
-            this.ShowRaw = showRaw;
-        }
-
-        /// <summary>Get all content packs in the log grouped by the mod they're for.</summary>
-        public IDictionary<string, LogModInfo[]> GetContentPacksByMod()
-        {
-            // get all mods & content packs
-            LogModInfo[] mods = this.ParsedLog?.Mods;
-            if (mods == null || !mods.Any())
-                return new Dictionary<string, LogModInfo[]>();
-
-            // group by mod
-            return mods
-                .Where(mod => mod.ContentPackFor != null)
-                .GroupBy(mod => mod.ContentPackFor)
-                .ToDictionary(group => group.Key, group => group.ToArray());
-        }
-
-        /// <summary>Get a sanitised mod name that's safe to use in anchors, attributes, and URLs.</summary>
-        /// <param name="modName">The mod name.</param>
-        public string GetSlug(string modName)
-        {
-            return this.SlugInvalidCharPattern.Replace(modName, "");
-        }
-    }
-}
diff --git a/src/SMAPI.Web/ViewModels/ModCompatibilityModel.cs b/src/SMAPI.Web/ViewModels/ModCompatibilityModel.cs
deleted file mode 100644
index 85bf1e46..00000000
--- a/src/SMAPI.Web/ViewModels/ModCompatibilityModel.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
-
-namespace StardewModdingAPI.Web.ViewModels
-{
-    /// <summary>Metadata about a mod's compatibility with the latest versions of SMAPI and Stardew Valley.</summary>
-    public class ModCompatibilityModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The compatibility status, as a string like <c>"Broken"</c>.</summary>
-        public string Status { get; set; }
-
-        /// <summary>The human-readable summary, as an HTML block.</summary>
-        public string Summary { get; set; }
-
-        /// <summary>The game or SMAPI version which broke this mod (if applicable).</summary>
-        public string BrokeIn { get; set; }
-
-        /// <summary>A link to the unofficial version which fixes compatibility, if any.</summary>
-        public ModLinkModel UnofficialVersion { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="info">The mod metadata.</param>
-        public ModCompatibilityModel(WikiCompatibilityInfo info)
-        {
-            this.Status = info.Status.ToString();
-            this.Status = this.Status.Substring(0, 1).ToLower() + this.Status.Substring(1);
-
-            this.Summary = info.Summary;
-            this.BrokeIn = info.BrokeIn;
-            if (info.UnofficialVersion != null)
-                this.UnofficialVersion = new ModLinkModel(info.UnofficialUrl, info.UnofficialVersion.ToString());
-        }
-    }
-}
diff --git a/src/SMAPI.Web/ViewModels/ModLinkModel.cs b/src/SMAPI.Web/ViewModels/ModLinkModel.cs
deleted file mode 100644
index 97dd215c..00000000
--- a/src/SMAPI.Web/ViewModels/ModLinkModel.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-namespace StardewModdingAPI.Web.ViewModels
-{
-    /// <summary>Metadata about a link.</summary>
-    public class ModLinkModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The URL of the linked page.</summary>
-        public string Url { get; set; }
-
-        /// <summary>The suggested link text.</summary>
-        public string Text { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="url">The URL of the linked page.</param>
-        /// <param name="text">The suggested link text.</param>
-        public ModLinkModel(string url, string text)
-        {
-            this.Url = url;
-            this.Text = text;
-        }
-    }
-}
diff --git a/src/SMAPI.Web/ViewModels/ModListModel.cs b/src/SMAPI.Web/ViewModels/ModListModel.cs
deleted file mode 100644
index 3b87d393..00000000
--- a/src/SMAPI.Web/ViewModels/ModListModel.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-
-namespace StardewModdingAPI.Web.ViewModels
-{
-    /// <summary>Metadata for the mod list page.</summary>
-    public class ModListModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The current stable version of the game.</summary>
-        public string StableVersion { get; set; }
-
-        /// <summary>The current beta version of the game (if any).</summary>
-        public string BetaVersion { get; set; }
-
-        /// <summary>The mods to display.</summary>
-        public ModModel[] Mods { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="stableVersion">The current stable version of the game.</param>
-        /// <param name="betaVersion">The current beta version of the game (if any).</param>
-        /// <param name="mods">The mods to display.</param>
-        public ModListModel(string stableVersion, string betaVersion, IEnumerable<ModModel> mods)
-        {
-            this.StableVersion = stableVersion;
-            this.BetaVersion = betaVersion;
-            this.Mods = mods.ToArray();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/ViewModels/ModModel.cs b/src/SMAPI.Web/ViewModels/ModModel.cs
deleted file mode 100644
index ae81acf5..00000000
--- a/src/SMAPI.Web/ViewModels/ModModel.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
-
-namespace StardewModdingAPI.Web.ViewModels
-{
-    /// <summary>Metadata about a mod.</summary>
-    public class ModModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod name.</summary>
-        public string Name { get; set; }
-
-        /// <summary>The mod's alternative names, if any.</summary>
-        public string AlternateNames { get; set; }
-
-        /// <summary>The mod author's name.</summary>
-        public string Author { get; set; }
-
-        /// <summary>The mod author's alternative names, if any.</summary>
-        public string AlternateAuthors { get; set; }
-
-        /// <summary>The URL to the mod's source code, if any.</summary>
-        public string SourceUrl { get; set; }
-
-        /// <summary>The compatibility status for the stable version of the game.</summary>
-        public ModCompatibilityModel Compatibility { get; set; }
-
-        /// <summary>The compatibility status for the beta version of the game.</summary>
-        public ModCompatibilityModel BetaCompatibility { get; set; }
-
-        /// <summary>Whether the mod is ready for the upcoming SMAPI 3.0.</summary>
-        public string Smapi3Status { get; set; }
-
-        /// <summary>A URL related to the <see cref="Smapi3Status"/>.</summary>
-        public string Smapi3Url { get; set; }
-
-        /// <summary>Links to the available mod pages.</summary>
-        public ModLinkModel[] ModPages { get; set; }
-
-        /// <summary>The human-readable warnings for players about this mod.</summary>
-        public string[] Warnings { get; set; }
-
-        /// <summary>A unique identifier for the mod that can be used in an anchor URL.</summary>
-        public string Slug { get; set; }
-
-        /// <summary>The sites where the mod can be downloaded.</summary>
-        public string[] ModPageSites => this.ModPages.Select(p => p.Text).ToArray();
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="entry">The mod metadata.</param>
-        public ModModel(WikiModEntry entry)
-        {
-            // basic info
-            this.Name = entry.Name.FirstOrDefault();
-            this.AlternateNames = string.Join(", ", entry.Name.Skip(1).ToArray());
-            this.Author = entry.Author.FirstOrDefault();
-            this.AlternateAuthors = string.Join(", ", entry.Author.Skip(1).ToArray());
-            this.SourceUrl = this.GetSourceUrl(entry);
-            this.Compatibility = new ModCompatibilityModel(entry.Compatibility);
-            this.BetaCompatibility = entry.BetaCompatibility != null ? new ModCompatibilityModel(entry.BetaCompatibility) : null;
-            this.Smapi3Status = entry.Smapi3Status.ToString().ToLower();
-            this.Smapi3Url = entry.Smapi3Url;
-            this.ModPages = this.GetModPageUrls(entry).ToArray();
-            this.Warnings = entry.Warnings;
-            this.Slug = entry.Anchor;
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the web URL for the mod's source code repository, if any.</summary>
-        /// <param name="entry">The mod metadata.</param>
-        private string GetSourceUrl(WikiModEntry entry)
-        {
-            if (!string.IsNullOrWhiteSpace(entry.GitHubRepo))
-                return $"https://github.com/{entry.GitHubRepo}";
-            if (!string.IsNullOrWhiteSpace(entry.CustomSourceUrl))
-                return entry.CustomSourceUrl;
-            return null;
-        }
-
-        /// <summary>Get the web URLs for the mod pages, if any.</summary>
-        /// <param name="entry">The mod metadata.</param>
-        private IEnumerable<ModLinkModel> GetModPageUrls(WikiModEntry entry)
-        {
-            bool anyFound = false;
-
-            // normal mod pages
-            if (entry.NexusID.HasValue)
-            {
-                anyFound = true;
-                yield return new ModLinkModel($"https://www.nexusmods.com/stardewvalley/mods/{entry.NexusID}", "Nexus");
-            }
-            if (entry.ChucklefishID.HasValue)
-            {
-                anyFound = true;
-                yield return new ModLinkModel($"https://community.playstarbound.com/resources/{entry.ChucklefishID}", "Chucklefish");
-            }
-            if (entry.ModDropID.HasValue)
-            {
-                anyFound = true;
-                yield return new ModLinkModel($"https://www.moddrop.com/sdv/mod/{entry.ModDropID}", "ModDrop");
-            }
-
-            // fallback
-            if (!anyFound && !string.IsNullOrWhiteSpace(entry.CustomUrl))
-            {
-                anyFound = true;
-                yield return new ModLinkModel(entry.CustomUrl, "custom");
-            }
-            if (!anyFound && !string.IsNullOrWhiteSpace(entry.GitHubRepo))
-                yield return new ModLinkModel($"https://github.com/{entry.GitHubRepo}/releases", "GitHub");
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Views/Index/Index.cshtml b/src/SMAPI.Web/Views/Index/Index.cshtml
deleted file mode 100644
index 24b42e09..00000000
--- a/src/SMAPI.Web/Views/Index/Index.cshtml
+++ /dev/null
@@ -1,123 +0,0 @@
-@using Microsoft.Extensions.Options
-@using StardewModdingAPI.Web.Framework.ConfigModels
-@inject IOptions<SiteConfig> SiteConfig
-@model StardewModdingAPI.Web.ViewModels.IndexModel
-@{
-    ViewData["Title"] = "SMAPI";
-}
-@section Head {
-    <link rel="stylesheet" href="~/Content/css/index.css?r=20180615" />
-    <script src="https://cdn.jsdelivr.net/npm/jquery@3.3.1/dist/jquery.min.js" crossorigin="anonymous"></script>
-    <script src="~/Content/js/index.js?r=20180615"></script>
-}
-
-<p id="blurb">
-    The mod loader for Stardew Valley. It works fine with GOG and Steam achievements, it's
-    compatible with Linux/Mac/Windows, you can uninstall it anytime, and there's a friendly
-    community if you need help. It's a cool pufferchick.
-</p>
-
-<div id="call-to-action">
-    <div class="cta-dropdown">
-        <a href="@Model.StableVersion.DownloadUrl" class="main-cta download">Download SMAPI @Model.StableVersion.Version</a><br />
-        <div class="dropdown-content">
-            <a href="https://www.nexusmods.com/stardewvalley/mods/2400"><img src="Content/images/nexus-icon.png" /> Download from Nexus</a>
-            <a href="@Model.StableVersion.DownloadUrl"><img src="Content/images/direct-download-icon.png" /> Direct download</a>
-        </div>
-    </div><br />
-
-    @if (Model.BetaVersion != null)
-    {
-        <div class="cta-dropdown secondary-cta-dropdown">
-            <a href="@Model.BetaVersion.DownloadUrl" class="secondary-cta download">
-                Download SMAPI @Model.BetaVersion.Version
-                @if (!string.IsNullOrWhiteSpace(Model.BetaBlurb))
-                {
-                    <br /><small>@Model.BetaBlurb</small>
-                }
-            </a><br />
-            <div class="dropdown-content">
-                <a href="https://www.nexusmods.com/stardewvalley/mods/2400"><img src="Content/images/nexus-icon.png" /> Download from Nexus</a>
-                <a href="@Model.BetaVersion.DownloadUrl"><img src="Content/images/direct-download-icon.png" /> Direct download</a>
-            </div>
-        </div><br />
-    }
-    <div><a href="https://stardewvalleywiki.com/Modding:Player_Guide" class="secondary-cta">Player guide</a></div>
-    <div class="sublinks">
-        <a href="https://github.com/Pathoschild/SMAPI">source code</a> | <a href="@(new UriBuilder(SiteConfig.Value.RootUrl) { Path = "privacy" }.Uri)">privacy</a>
-    </div>
-    <img id="pufferchick" src="Content/images/pufferchick.png" />
-</div>
-
-<h2 id="help">Get help</h2>
-<ul>
-    <li><a href="@SiteConfig.Value.ModListUrl">Mod compatibility list</a></li>
-    <li>Get help <a href="https://stardewvalleywiki.com/Modding:Community#Discord">on Discord</a> or <a href="https://community.playstarbound.com/threads/smapi-stardew-modding-api.108375/">in the forums</a></li>
-</ul>
-
-@if (Model.BetaVersion == null)
-{
-    <h2 id="whatsnew">What's new in SMAPI @Model.StableVersion.Version?</h2>
-    <div class="github-description">
-        @Html.Raw(Markdig.Markdown.ToHtml(Model.StableVersion.Description))
-    </div>
-    <p>See the <a href="https://github.com/Pathoschild/SMAPI/blob/develop/docs/release-notes.md#release-notes">release notes</a> and <a href="@SiteConfig.Value.ModListUrl">mod compatibility list</a> for more info.</p>
-}
-else
-{
-    <h2 id="whatsnew">What's new in...</h2>
-    <h3>SMAPI @Model.StableVersion.Version?</h3>
-    <div class="github-description">
-        @Html.Raw(Markdig.Markdown.ToHtml(Model.StableVersion.Description))
-    </div>
-    <p>See the <a href="https://github.com/Pathoschild/SMAPI/blob/develop/docs/release-notes.md#release-notes">release notes</a> and <a href="@SiteConfig.Value.ModListUrl">mod compatibility list</a> for more info.</p>
-
-    <h3>SMAPI @Model.BetaVersion.Version?</h3>
-    <div class="github-description">
-        @Html.Raw(Markdig.Markdown.ToHtml(Model.BetaVersion.Description))
-    </div>
-    <p>See the <a href="https://github.com/Pathoschild/SMAPI/blob/develop/docs/release-notes.md#release-notes">release notes</a> and <a href="@SiteConfig.Value.ModListUrl">mod compatibility list</a> for more info.</p>
-}
-
-<h2 id="donate">Donate to support SMAPI ♥</h2>
-<p>
-    SMAPI is an open-source project by Pathoschild. It will always be free, but donations
-    are much appreciated to help pay for development, server hosting, domain fees, coffee, etc.
-</p>
-<ul id="support-links">
-    <li><a href="https://www.paypal.me/pathoschild">Donate once</a></li>
-    <li>
-        <a href="https://www.patreon.com/pathoschild">Donate $1 per month (or more)</a><br />
-        <small>
-            You can cancel anytime. You'll have access to all private posts with behind-the-scenes
-            info, upcoming features, and early previews of SMAPI updates. You can optionally
-            provide early feedback on SMAPI features to influence development. Donate $5/month and
-            you'll be publicly credited (with optional link) below!
-        </small>
-    </li>
-</ul>
-
-<p>
-    Special thanks to
-    acerbicon,
-    <a href="https://www.nexusmods.com/stardewvalley/users/31393530">ChefRude</a>,
-    <a href="https://github.com/dittusch">dittusch</a>,
-    hawkfalcon,
-    <a href="https://twitter.com/iKeychain">iKeychain</a>,
-    jwdred,
-    <a href="https://www.nexusmods.com/users/12252523">Karmylla</a>,
-    Pucklynn,
-    Robby LaFarge,
-    and a few anonymous users for their ongoing support; you're awesome! 🏅
-</p>
-
-<h2 id="modcreators">For mod creators</h2>
-<ul>
-    <li><a href="@Model.StableVersion.DevDownloadUrl">SMAPI @Model.StableVersion.Version for developers</a> (includes <a href="https://docs.microsoft.com/en-us/visualstudio/ide/using-intellisense">intellisense</a> and full console output)</li>
-    @if (Model.BetaVersion != null)
-    {
-        <li><a href="@Model.BetaVersion.DevDownloadUrl">SMAPI @Model.BetaVersion.Version for developers</a> (includes <a href="https://docs.microsoft.com/en-us/visualstudio/ide/using-intellisense">intellisense</a> and full console output)</li>
-    }
-    <li><a href="https://stardewvalleywiki.com/Modding:Index">Modding documentation</a></li>
-    <li>Need help? Come <a href="https://stardewvalleywiki.com/Modding:Community#Discord">chat on Discord</a>.</li>
-</ul>
diff --git a/src/SMAPI.Web/Views/Index/Privacy.cshtml b/src/SMAPI.Web/Views/Index/Privacy.cshtml
deleted file mode 100644
index ca99eef6..00000000
--- a/src/SMAPI.Web/Views/Index/Privacy.cshtml
+++ /dev/null
@@ -1,43 +0,0 @@
-@using Microsoft.Extensions.Options
-@using StardewModdingAPI.Web.Framework.ConfigModels
-@inject IOptions<SiteConfig> SiteConfig
-@{
-    ViewData["Title"] = "SMAPI privacy notes";
-}
-@section Head {
-    <link rel="stylesheet" href="~/Content/css/privacy.css" />
-}
-
-&larr; <a href="@SiteConfig.Value.RootUrl">back to SMAPI page</a>
-
-<p>SMAPI is an <a href="https://github.com/Pathoschild/SMAPI">open-source</a> and non-profit project. Your privacy is important, so this page explains what information SMAPI uses and transmits. <strong>This page is informational only, it's not a legal document.</strong></p>
-
-<h2>Principles</h2>
-<ol>
-    <li>SMAPI collects the minimum information needed to enable its features (see below).</li>
-    <li>SMAPI does not collect telemetry, analytics, etc.</li>
-    <li>SMAPI will never sell your information.</li>
-</ol>
-
-<h2>Data collected and transmitted</h2>
-<h3 id="web-logging">Web logging</h3>
-<p>This website and SMAPI's web API are hosted by Amazon Web Services. Their servers may automatically collect diagnostics like your IP address, but this information is not visible to SMAPI's web application or developers. For more information, see the <a href="https://aws.amazon.com/privacy/">Amazon Privacy Notice</a>.</p>
-
-<h3>Update checks</h3>
-<p>SMAPI notifies you when there's a new version of SMAPI or your mods available. To do so, it sends your SMAPI and mod versions to its web API. No personal information is stored by the web application, but see <em><a href="#web-logging">web logging</a></em>.</p>
-
-<p>You can disable update checks, and no information will be transmitted to the web API. To do so:</p>
-<ol>
-    <li><a href="https://stardewvalleywiki.com/Modding:Game_folder">find your game folder</a>;</li>
-    <li>open the <code>smapi-internal/StardewModdingAPI.config.json</code> file in a text editor;</li>
-    <li>change <code>"CheckForUpdates": true</code> to <code>"CheckForUpdates": false</code>.</li>
-</ol>
-
-<h3>Log parser</h3>
-<p>The <a href="https://log.smapi.io/">log parser page</a> lets you store a log file for analysis and sharing. The log data is stored indefinitely in an obfuscated form as unlisted pastes in <a href="https://pastebin.com/">Pastebin</a>. No personal information is stored by the log parser beyond what you choose to upload, but see <em><a href="#web-logging">web logging</a></em> and the <a href="https://pastebin.com/doc_privacy_statement">Pastebin Privacy Statement</a>.</p>
-
-<h3>Multiplayer sync</h3>
-<p>As part of its multiplayer API, SMAPI transmits basic context to players you connect to (mainly your OS, SMAPI version, game version, and installed mods). This is used to enable multiplayer features like inter-mod messages, compatibility checks, etc. Although this information is normally hidden from players, it may be visible due to mods or configuration changes.</p>
-
-<h3>Custom mods</h3>
-<p><strong>Mods may collect and transmit any information. Mods (except those provided as part of the SMAPI download) are not covered by this page. Install third-party mods at your own risk.</strong></p>
diff --git a/src/SMAPI.Web/Views/LogParser/Index.cshtml b/src/SMAPI.Web/Views/LogParser/Index.cshtml
deleted file mode 100644
index babd0bd3..00000000
--- a/src/SMAPI.Web/Views/LogParser/Index.cshtml
+++ /dev/null
@@ -1,311 +0,0 @@
-@using Newtonsoft.Json
-@using StardewModdingAPI.Web.Framework.LogParsing.Models
-@model StardewModdingAPI.Web.ViewModels.LogParserModel
-
-@{
-    ViewData["Title"] = "SMAPI log parser";
-    IDictionary<string, LogModInfo[]> contentPacks = Model.GetContentPacksByMod();
-    IDictionary<string, bool> defaultFilters = Enum
-        .GetValues(typeof(LogLevel))
-        .Cast<LogLevel>()
-        .ToDictionary(level => level.ToString().ToLower(), level => level != LogLevel.Trace);
-    JsonSerializerSettings noFormatting = new JsonSerializerSettings { Formatting = Formatting.None };
-}
-
-@section Head {
-    @if (Model.PasteID != null)
-    {
-        <meta name="robots" content="noindex" />
-    }
-    <link rel="stylesheet" href="~/Content/css/log-parser.css?r=20190314" />
-    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.17/dist/vue.min.js" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/jquery@3.3.1/dist/jquery.min.js" crossorigin="anonymous"></script>
-    <script src="~/Content/js/log-parser.js?r=20190310"></script>
-    <script>
-        $(function() {
-            smapi.logParser({
-                logStarted: new Date(@Json.Serialize(Model.ParsedLog?.Timestamp)),
-                showPopup: @Json.Serialize(Model.ParsedLog == null),
-                showMods: @Json.Serialize(Model.ParsedLog?.Mods?.Select(p => Model.GetSlug(p.Name)).Distinct().ToDictionary(slug => slug, slug => true), noFormatting),
-                showSections: @Json.Serialize(Enum.GetNames(typeof(LogSection)).ToDictionary(section => section, section => false), noFormatting),
-                showLevels: @Json.Serialize(defaultFilters, noFormatting),
-                enableFilters: @Json.Serialize(!Model.ShowRaw)
-            }, '@Model.SectionUrl');
-        });
-    </script>
-}
-
-@* upload result banner *@
-@if (Model.UploadError != null)
-{
-    <div class="banner error" v-pre>
-        <strong>Oops, the server ran into trouble saving that file.</strong><br />
-        <small v-pre>Error details: @Model.UploadError</small>
-    </div>
-}
-else if (Model.ParseError != null)
-{
-    <div class="banner error" v-pre>
-        <strong>Oops, couldn't parse that log. (Make sure you upload the log file, not the console text.)</strong><br />
-        Share this URL when asking for help: <code>@(new Uri(new Uri(Model.SectionUrl), Model.PasteID))</code><br />
-        (Or <a href="@Model.SectionUrl">upload a new log</a>.)<br />
-        <br />
-        <small v-pre>Error details: @Model.ParseError</small>
-    </div>
-}
-else if (Model.ParsedLog?.IsValid == true)
-{
-    <div class="banner success" v-pre>
-        <strong>Share this link to let someone else see the log:</strong> <code>@(new Uri(new Uri(Model.SectionUrl), Model.PasteID))</code><br />
-        (Or <a href="@Model.SectionUrl">upload a new log</a>.)
-    </div>
-}
-
-@* upload new log *@
-@if (Model.ParsedLog == null)
-{
-    <h2>Where do I find my SMAPI log?</h2>
-    <div>What system do you use?</div>
-    <ul id="os-list">
-        <li><input type="radio" name="os" value="linux" id="os-linux" /> <label for="os-linux">Linux</label></li>
-        <li><input type="radio" name="os" value="mac" id="os-mac" /> <label for="os-mac">Mac</label></li>
-        <li><input type="radio" name="os" value="windows" id="os-windows" /> <label for="os-windows">Windows</label></li>
-    </ul>
-    <div data-os="linux">
-        On Linux:
-        <ol>
-            <li>Open the Files app.</li>
-            <li>Click the options menu (might be labeled <em>Go</em> or <code>⋮</code>).</li>
-            <li>Choose <em>Enter Location</em>.</li>
-            <li>Enter this exact text: <pre>~/.config/StardewValley/ErrorLogs</pre></li>
-            <li>The log file is <code>SMAPI-crash.txt</code> if it exists, otherwise <code>SMAPI-latest.txt</code>.</li>
-        </ol>
-    </div>
-    <div data-os="mac">
-        On Mac:
-        <ol>
-            <li>Open the Finder app.</li>
-            <li>Click <em>Go</em> at the top, then <em>Go to Folder</em>.</li>
-            <li>Enter this exact text: <pre>~/.config/StardewValley/ErrorLogs</pre></li>
-            <li>The log file is <code>SMAPI-crash.txt</code> if it exists, otherwise <code>SMAPI-latest.txt</code>.</li>
-        </ol>
-    </div>
-    <div data-os="windows">
-        On Windows:
-        <ol>
-            <li>Press the <code>Windows</code> and <code>R</code> buttons at the same time.</li>
-            <li>In the 'run' box that appears, enter this exact text: <pre>%appdata%\StardewValley\ErrorLogs</pre></li>
-            <li>The log file is <code>SMAPI-crash.txt</code> if it exists, otherwise <code>SMAPI-latest.txt</code>.</li>
-        </ol>
-    </div>
-
-    <h2>How do I share my log?</h2>
-    <form action="@Model.SectionUrl" method="post">
-        <ol>
-            <li>
-                Drag the file onto this textbox (or paste the text in):<br />
-                <textarea id="input" name="input" placeholder="paste log here"></textarea>
-            </li>
-            <li>
-                Click this button:<br />
-                <input type="submit" id="submit" value="save log" />
-            </li>
-            <li>On the new page, copy the URL and send it to the person helping you.</li>
-        </ol>
-    </form>
-}
-
-@* parsed log *@
-@if (Model.ParsedLog?.IsValid == true)
-{
-    <div id="output">
-        @if (Model.ParsedLog.Mods.Any(mod => mod.HasUpdate))
-        {
-            <h2>Suggested fixes</h2>
-            <ul id="fix-list">
-                <li>
-                    Consider updating these mods to fix problems:
-
-                    <table id="updates" class="table">
-                        @foreach (LogModInfo mod in Model.ParsedLog.Mods.Where(mod => (mod.HasUpdate && mod.ContentPackFor == null) || (contentPacks != null && contentPacks.TryGetValue(mod.Name, out LogModInfo[] contentPackList) && contentPackList.Any(pack => pack.HasUpdate))))
-                        {
-                            <tr class="mod-entry">
-                                <td>
-                                    <strong class=@(!mod.HasUpdate ? "hidden" : "")>@mod.Name</strong>
-                                    @if (contentPacks != null && contentPacks.TryGetValue(mod.Name, out LogModInfo[] contentPackList))
-                                    {
-                                        <div class="content-packs">
-                                            @foreach (LogModInfo contentPack in contentPackList.Where(pack => pack.HasUpdate))
-                                            {
-                                                <text>+ @contentPack.Name</text><br/>
-                                            }
-                                        </div>
-                                    }
-                                </td>
-                                <td>
-                                    @if (mod.HasUpdate)
-                                    {
-                                        <a href="@mod.UpdateLink" target="_blank">
-                                            @(mod.Version == null ? @mod.UpdateVersion : $"{mod.Version} → {mod.UpdateVersion}")
-                                        </a>
-                                    }
-                                    else
-                                    {
-                                        <text>&nbsp;</text>
-                                    }
-
-                                    @if (contentPacks != null && contentPacks.TryGetValue(mod.Name, out contentPackList))
-                                    {
-                                        <div>
-                                            @foreach (LogModInfo contentPack in contentPackList.Where(pack => pack.HasUpdate))
-                                            {
-                                                <a href="@contentPack.UpdateLink" target="_blank">@contentPack.Version → @contentPack.UpdateVersion</a><br/>
-                                            }
-                                        </div>
-                                    }
-                                </td>
-                            </tr>
-                        }
-                    </table>
-                </li>
-            </ul>
-        }
-
-        <h2>Log info</h2>
-        <table id="metadata" class="table">
-            <caption>Game info:</caption>
-            <tr>
-                <th>Stardew Valley:</th>
-                <td v-pre>@Model.ParsedLog.GameVersion on @Model.ParsedLog.OperatingSystem</td>
-            </tr>
-            <tr>
-                <th>SMAPI:</th>
-                <td v-pre>@Model.ParsedLog.ApiVersion</td>
-            </tr>
-            <tr>
-                <th>Folder:</th>
-                <td v-pre>@Model.ParsedLog.GamePath</td>
-            </tr>
-            <tr>
-                <th>Log started:</th>
-                <td>@Model.ParsedLog.Timestamp.UtcDateTime.ToString("yyyy-MM-dd HH:mm") UTC ({{localTimeStarted}} your time)</td>
-            </tr>
-        </table>
-        <br />
-        <table id="mods" class="@(Model.ShowRaw ? "filters-disabled" : null) table">
-            <caption>
-                Installed mods:
-                @if (!Model.ShowRaw)
-                {
-                    <span class="notice txt"><i>click any mod to filter</i></span>
-                    <span class="notice btn txt" v-on:click="showAllMods" v-bind:class="{ invisible: !anyModsHidden }">show all</span>
-                    <span class="notice btn txt" v-on:click="hideAllMods" v-bind:class="{ invisible: !anyModsShown || !anyModsHidden }">hide all</span>
-                }
-            </caption>
-            @foreach (var mod in Model.ParsedLog.Mods.Where(p => p.Loaded && p.ContentPackFor == null))
-            {
-                <tr v-on:click="toggleMod('@Model.GetSlug(mod.Name)')" class="mod-entry" v-bind:class="{ hidden: !showMods['@Model.GetSlug(mod.Name)'] }">
-                    <td><input type="checkbox" v-bind:checked="showMods['@Model.GetSlug(mod.Name)']" v-bind:class="{ invisible: !anyModsHidden }" /></td>
-                    <td v-pre>
-                        <strong>@mod.Name</strong> @mod.Version
-                        @if (contentPacks != null && contentPacks.TryGetValue(mod.Name, out LogModInfo[] contentPackList))
-                        {
-                            <div class="content-packs">
-                                @foreach (var contentPack in contentPackList)
-                                {
-                                    <text>+ @contentPack.Name @contentPack.Version</text><br />
-                                }
-                            </div>
-                        }
-                    </td>
-                    <td v-pre>
-                        @mod.Author
-                        @if (contentPacks != null && contentPacks.TryGetValue(mod.Name, out contentPackList))
-                        {
-                            <div class="content-packs">
-                                @foreach (var contentPack in contentPackList)
-                                {
-                                    <text>+ @contentPack.Author</text><br />
-                                }
-                            </div>
-                        }
-                    </td>
-                    @if (mod.Errors == 0)
-                    {
-                        <td v-pre class="color-green">no errors</td>
-                    }
-                    else if (mod.Errors == 1)
-                    {
-                        <td v-pre class="color-red">@mod.Errors error</td>
-                    }
-                    else
-                    {
-                        <td v-pre class="color-red">@mod.Errors errors</td>
-                    }
-                </tr>
-            }
-        </table>
-
-        @if (!Model.ShowRaw)
-        {
-            <div id="filters">
-                Filter messages:
-                <span v-bind:class="{ active: showLevels['trace'] }" v-on:click="toggleLevel('trace')">TRACE</span> |
-                <span v-bind:class="{ active: showLevels['debug'] }" v-on:click="toggleLevel('debug')">DEBUG</span> |
-                <span v-bind:class="{ active: showLevels['info'] }" v-on:click="toggleLevel('info')">INFO</span> |
-                <span v-bind:class="{ active: showLevels['alert'] }" v-on:click="toggleLevel('alert')">ALERT</span> |
-                <span v-bind:class="{ active: showLevels['warn'] }" v-on:click="toggleLevel('warn')">WARN</span> |
-                <span v-bind:class="{ active: showLevels['error'] }" v-on:click="toggleLevel('error')">ERROR</span>
-            </div>
-
-            <table id="log">
-                @foreach (var message in Model.ParsedLog.Messages)
-                {
-                    string levelStr = message.Level.ToString().ToLower();
-                    string sectionStartClass = message.IsStartOfSection ? "section-start" : null;
-                    string sectionFilter = message.Section != null && !message.IsStartOfSection ? $"&& sectionsAllow('{message.Section}')" : null; // filter the message by section if applicable
-
-                    <tr class="mod @levelStr @sectionStartClass"
-                        @if (message.IsStartOfSection)
-                        {
-                            <text>v-on:click="toggleSection('@message.Section')"</text>
-                        }
-                        v-show="filtersAllow('@Model.GetSlug(message.Mod)', '@levelStr') @sectionFilter">
-                        <td v-pre>@message.Time</td>
-                        <td v-pre>@message.Level.ToString().ToUpper()</td>
-                        <td v-pre data-title="@message.Mod">@message.Mod</td>
-                        <td>
-                            <span v-pre class="log-message-text">@message.Text</span>
-                            @if (message.IsStartOfSection)
-                            {
-                                <span class="section-toggle-message">
-                                    <template v-if="sectionsAllow('@message.Section')">This section is shown. Click here to hide it.</template>
-                                    <template v-else>This section is hidden. Click here to show it.</template>
-                                </span>
-                            }
-                        </td>
-                    </tr>
-                    if (message.Repeated > 0)
-                    {
-                        <tr class="@levelStr mod mod-repeat" v-show="filtersAllow('@Model.GetSlug(message.Mod)', '@levelStr') @sectionFilter">
-                            <td colspan="3"></td>
-                            <td v-pre><i>repeats [@message.Repeated] times.</i></td>
-                        </tr>
-                    }
-                }
-            </table>
-
-            <small><a href="@(new Uri(new Uri(Model.SectionUrl), Model.PasteID))?raw=true">view raw log</a></small>
-        }
-        else
-        {
-            <pre v-pre>@Model.ParsedLog.RawText</pre>
-            <small><a href="@(new Uri(new Uri(Model.SectionUrl), Model.PasteID))">view parsed log</a></small>
-        }
-    </div>
-}
-else if (Model.ParsedLog?.IsValid == false)
-{
-    <h3>Raw log</h3>
-    <pre v-pre>@Model.ParsedLog.RawText</pre>
-}
diff --git a/src/SMAPI.Web/Views/Mods/Index.cshtml b/src/SMAPI.Web/Views/Mods/Index.cshtml
deleted file mode 100644
index 5592078c..00000000
--- a/src/SMAPI.Web/Views/Mods/Index.cshtml
+++ /dev/null
@@ -1,108 +0,0 @@
-@using Newtonsoft.Json
-@model StardewModdingAPI.Web.ViewModels.ModListModel
-@{
-    ViewData["Title"] = "Mod compatibility";
-}
-@section Head {
-    <link rel="stylesheet" href="~/Content/css/mods.css?r=20190302" />
-    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.17/dist/vue.min.js" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/jquery@3.3.1/dist/jquery.min.js" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/tablesorter@2.31.0/dist/js/jquery.tablesorter.combined.min.js" crossorigin="anonymous"></script>
-    <script src="~/Content/js/mods.js?r=20190302"></script>
-    <script>
-        $(function() {
-            var data = @Json.Serialize(Model.Mods, new JsonSerializerSettings { Formatting = Formatting.None });
-            var enableBeta = @Json.Serialize(Model.BetaVersion != null);
-            smapi.modList(data, enableBeta);
-        });
-    </script>
-}
-
-<div id="intro">
-    <p>This page shows all known SMAPI mods and (incompatible) content packs, whether they work with the latest versions of Stardew Valley and SMAPI, and how to fix them if not. If a mod doesn't work after following the instructions below, check <a href="https://stardewvalleywiki.com/Modding:Player_Guide/Troubleshooting">the troubleshooting guide</a> or <a href="https://stardewvalleywiki.com/Modding:Player_Guide/Troubleshooting#Ask_for_help">ask for help</a>.</p>
-
-    <p>The list is updated every few days (you can help <a href="https://stardewvalleywiki.com/Modding:Mod_compatibility">update it</a>!). It doesn't include XNB mods (see <a href="https://stardewvalleywiki.com/Modding:Using_XNB_mods"><em>using XNB mods</em> on the wiki</a> instead) or compatible content packs.</p>
-
-    @if (Model.BetaVersion != null)
-    {
-        <p id="beta-blurb"><strong>Note:</strong> "SDV beta only" means Stardew Valley @Model.BetaVersion-beta; if you didn't opt in to the beta, you have the stable version and can ignore that line. If a mod doesn't have a "SDV beta only" line, the compatibility applies to both versions of the game.</p>
-    }
-</div>
-
-<div id="app">
-    <div id="options">
-        <div>
-            <label for="search-box">Search: </label>
-            <input type="text" id="search-box" v-model="search" v-on:input="applyFilters" />
-        </div>
-        <div id="filter-area">
-            <input type="checkbox" id="show-advanced" v-model="showAdvanced" />
-            <label for="show-advanced">show advanced info and options</label>
-            <div id="filters" v-show="showAdvanced">
-                <div v-for="(filterGroup, key) in filters">
-                    {{filterGroup.label}}: <span v-for="filter in filterGroup.value" v-bind:class="{ active: filter.value }"><input type="checkbox" v-bind:id="filter.id" v-model="filter.value" v-on:change="applyFilters" /> <label v-bind:for="filter.id">{{filter.label}}</label></span>
-                </div>
-            </div>
-        </div>
-    </div>
-    <div id="mod-count" v-show="showAdvanced">
-        <div v-if="visibleStats.total > 0">
-            {{visibleStats.total}} mods shown ({{Math.round((visibleStats.compatible + visibleStats.workaround) / visibleStats.total * 100)}}% compatible or have a workaround, {{Math.round((visibleStats.soon + visibleStats.broken) / visibleStats.total * 100)}}% broken, {{Math.round(visibleStats.abandoned / visibleStats.total * 100)}}% obsolete).<br />
-            SMAPI 3.0 (upcoming): {{Math.round(visibleStats.smapi3_ok / visibleStats.total * 100)}}% ready, {{Math.round(visibleStats.smapi3_soon / visibleStats.total * 100)}}% soon, {{Math.round(visibleStats.smapi3_broken / visibleStats.total * 100)}}% broken, {{Math.round(visibleStats.smapi3_unknown / visibleStats.total * 100)}}% unknown.
-        </div>
-        <span v-else>No matching mods found.</span>
-    </div>
-    <table class="wikitable" id="mod-list">
-        <thead>
-            <tr>
-                <th>mod name</th>
-                <th>links</th>
-                <th>author</th>
-                <th>compatibility</th>
-                <th v-show="showAdvanced">broke in</th>
-                <th v-show="showAdvanced">code</th>
-                <th><small><a href="http://smapi.io/3.0">3.0 ready</a></small></th>
-                <th>&nbsp;</th>
-            </tr>
-        </thead>
-        <tbody>
-            <tr v-for="mod in mods" :key="mod.Name" v-bind:id="mod.Slug" :key="mod.Slug" v-bind:data-status="mod.LatestCompatibility.Status" v-show="mod.Visible">
-                <td>
-                    {{mod.Name}}
-                    <small class="mod-alt-names" v-if="mod.AlternateNames">(aka {{mod.AlternateNames}})</small>
-                </td>
-                <td class="mod-page-links">
-                    <span v-for="(link, i) in mod.ModPages">
-                        <a v-bind:href="link.Url">{{link.Text}}</a>{{i < mod.ModPages.length - 1 ? ', ' : ''}}
-                    </span>
-                </td>
-                <td>
-                    {{mod.Author}}
-                    <small class="mod-alt-authors" v-if="mod.AlternateAuthors">(aka {{mod.AlternateAuthors}})</small>
-                </td>
-                <td>
-                    <div v-html="mod.Compatibility.Summary"></div>
-                    <div v-if="mod.BetaCompatibility">
-                        <strong v-if="mod.BetaCompatibility">SDV beta only:</strong>
-                        <span v-html="mod.BetaCompatibility.Summary"></span>
-                    </div>
-                    <div v-for="(warning, i) in mod.Warnings">⚠ {{warning}}</div>
-                </td>
-                <td class="mod-broke-in" v-html="mod.LatestCompatibility.BrokeIn" v-show="showAdvanced"></td>
-                <td v-show="showAdvanced">
-                    <span v-if="mod.SourceUrl"><a v-bind:href="mod.SourceUrl">source</a></span>
-                    <span v-else class="mod-closed-source">no source</span>
-                </td>
-                <td class="smapi-3-col">
-                    <small v-if="mod.LatestCompatibility.Status == 'ok' || mod.LatestCompatibility.Status == 'unofficial' || mod.LatestCompatibility.Status == 'optional' || mod.Smapi3Status == 'ok' || mod.Smapi3Status == 'soon' || mod.Smapi3Url">
-                        <a v-if="mod.Smapi3Url" v-bind:href="mod.Smapi3Url" v-bind:title="mod.Smapi3Tooltip">{{mod.Smapi3DisplayText}}</a>
-                        <span v-else v-bind:title="mod.Smapi3Tooltip">{{mod.Smapi3DisplayText}}</span>
-                    </small>
-                </td>
-                <td>
-                    <small><a v-bind:href="'#' + mod.Slug">#</a></small>
-                </td>
-            </tr>
-        </tbody>
-    </table>
-</div>
diff --git a/src/SMAPI.Web/Views/Shared/_Layout.cshtml b/src/SMAPI.Web/Views/Shared/_Layout.cshtml
deleted file mode 100644
index 4c602b29..00000000
--- a/src/SMAPI.Web/Views/Shared/_Layout.cshtml
+++ /dev/null
@@ -1,36 +0,0 @@
-@using Microsoft.Extensions.Options
-@using StardewModdingAPI.Web.Framework.ConfigModels
-@inject IOptions<SiteConfig> SiteConfig
-
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>@ViewData["Title"] - SMAPI.io</title>
-    <link rel="stylesheet" href="~/Content/css/main.css" />
-    @RenderSection("Head", required: false)
-</head>
-<body>
-    <div id="sidebar">
-        <h4>SMAPI</h4>
-        <ul>
-            <li><a href="@SiteConfig.Value.RootUrl">About SMAPI</a></li>
-            <li><a href="@SiteConfig.Value.ModListUrl">Mod compatibility</a></li>
-            <li><a href="@SiteConfig.Value.LogParserUrl">Log parser</a></li>
-            <li><a href="https://stardewvalleywiki.com/Modding:Index">Docs</a></li>
-        </ul>
-    </div>
-    <div id="content-column">
-        <div id="content">
-            <h1>@ViewData["Title"]</h1>
-            @RenderBody()
-        </div>
-        <div id="footer">
-            <div id="license">
-                Hi! You can <a href="https://github.com/pathoschild/SMAPI" title="view source">view the source code</a> or <a href="https://github.com/pathoschild/SMAPI/issues" title="report issue">report a bug or suggestion</a>.
-            </div>
-        </div>
-    </div>
-</body>
-</html>
diff --git a/src/SMAPI.Web/Views/_ViewStart.cshtml b/src/SMAPI.Web/Views/_ViewStart.cshtml
deleted file mode 100644
index a5f10045..00000000
--- a/src/SMAPI.Web/Views/_ViewStart.cshtml
+++ /dev/null
@@ -1,3 +0,0 @@
-@{
-    Layout = "_Layout";
-}
diff --git a/src/SMAPI.Web/appsettings.Development.json b/src/SMAPI.Web/appsettings.Development.json
deleted file mode 100644
index db90a3de..00000000
--- a/src/SMAPI.Web/appsettings.Development.json
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-
-
-  This file is committed to source control with the default settings, but added to .gitignore to
-  avoid accidentally committing login details.
-
-
-
-*/
-{
-  "Logging": {
-    "IncludeScopes": false,
-    "LogLevel": {
-      "Default": "Debug",
-      "System": "Information",
-      "Microsoft": "Information"
-    }
-  },
-
-  "Site": {
-    "RootUrl": "http://localhost:59482/",
-    "ModListUrl": "http://localhost:59482/mods/",
-    "LogParserUrl": "http://localhost:59482/log/",
-    "BetaEnabled": false,
-    "BetaBlurb": null 
-  },
-
-  "ApiClients": {
-    "GitHubUsername": null,
-    "GitHubPassword": null,
-
-    "PastebinUserKey": null,
-    "PastebinDevKey": null
-  }
-}
diff --git a/src/SMAPI.Web/appsettings.json b/src/SMAPI.Web/appsettings.json
deleted file mode 100644
index e97b2339..00000000
--- a/src/SMAPI.Web/appsettings.json
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-
-
-  This contains the default settings for the web app. Login credentials and contextual settings are
-  configured via appsettings.Development.json locally, or environment properties in AWS.
-
-
-*/
-{
-  "Logging": {
-    "IncludeScopes": false,
-    "LogLevel": {
-      "Default": "Warning"
-    }
-  },
-
-  "Site": {
-    "RootUrl": null, // see top note
-    "ModListUrl":  null, // see top note
-    "LogParserUrl": null, // see top note
-    "BetaEnabled": null, // see top note
-    "BetaBlurb": null // see top note
-  },
-
-  "ApiClients": {
-    "UserAgent": "SMAPI/{0} (+https://smapi.io)",
-
-    "ChucklefishBaseUrl": "https://community.playstarbound.com",
-    "ChucklefishModPageUrlFormat": "resources/{0}",
-
-    "GitHubBaseUrl": "https://api.github.com",
-    "GitHubStableReleaseUrlFormat": "repos/{0}/releases/latest",
-    "GitHubAnyReleaseUrlFormat": "repos/{0}/releases?per_page=2", // allow for draft release (only visible if GitHub repo is owned by same account as the update check credentials)
-    "GitHubAcceptHeader": "application/vnd.github.v3+json",
-    "GitHubUsername": null, // see top note
-    "GitHubPassword": null, // see top note
-
-    "ModDropApiUrl": "https://www.moddrop.com/api/mods/data",
-    "ModDropModPageUrl": "https://www.moddrop.com/sdv/mod/{0}",
-
-    "NexusBaseUrl": "https://www.nexusmods.com/stardewvalley/",
-    "NexusModUrlFormat": "mods/{0}",
-    "NexusModScrapeUrlFormat": "mods/{0}?tab=files",
-
-    "PastebinBaseUrl": "https://pastebin.com/",
-    "PastebinUserKey": null, // see top note
-    "PastebinDevKey": null // see top note
-  },
-
-  "ModCompatibilityList": {
-    "WikiCacheMinutes": 10
-  },
-
-  "ModUpdateCheck": {
-    "SuccessCacheMinutes": 60,
-    "ErrorCacheMinutes": 5,
-    "SemanticVersionRegex": "^(?>(?<major>0|[1-9]\\d*))\\.(?>(?<minor>0|[1-9]\\d*))(?>(?:\\.(?<patch>0|[1-9]\\d*))?)(?:-(?<prerelease>(?>[a-z0-9]+[\\-\\.]?)+))?$",
-    "CompatibilityPageUrl": "https://mods.smapi.io"
-  }
-}
diff --git a/src/SMAPI.Web/wwwroot/Content/css/index.css b/src/SMAPI.Web/wwwroot/Content/css/index.css
deleted file mode 100644
index 979af4af..00000000
--- a/src/SMAPI.Web/wwwroot/Content/css/index.css
+++ /dev/null
@@ -1,112 +0,0 @@
-/*********
-** Intro
-*********/
-h1 {
-    text-align: center;
-    font-size: 6em;
-    color: #000;
-}
-
-#blurb {
-    margin: auto;
-    width: 30em;
-    text-align: center;
-}
-
-#call-to-action {
-    margin: 3em 0;
-    text-align: center;
-}
-
-#call-to-action a.main-cta,
-#call-to-action a.secondary-cta {
-    box-shadow: #caefab 0 1px 0 0 inset;
-    background: linear-gradient(#77d42a 5%, #5cb811 100%) #77d42a;
-    border-radius: 6px;
-    border: 1px solid #268a16;
-    display: inline-block;
-    cursor: pointer;
-    color: #306108;
-    font-weight: bold;
-    margin-bottom: 1em;
-    padding: 6px 24px;
-    text-decoration: none;
-    text-shadow: #aade7c 0 1px 0;
-}
-
-#call-to-action a.secondary-cta {
-    background: #768d87;
-    border: 1px solid #566963;
-    color: #ffffff;
-    text-shadow: #2b665e 0 1px 0;
-}
-
-.cta-dropdown {
-    position: relative;
-    display: inline-block;
-    margin-bottom: 1em;
-}
-
-.cta-dropdown a.download {
-    margin-bottom: 0 !important;
-}
-
-.cta-dropdown .dropdown-content {
-    display: none;
-    position: absolute;
-    text-align: left;
-    box-shadow: 0 8px 16px 0 rgba(0, 0, 0, 0.2);
-    border: 1px solid #566963;
-    background: #5cb811;
-    border-top: 0;
-    border-radius: 0 0 6px 6px;
-    margin-top: -6px;
-    z-index: 1;
-}
-
-.cta-dropdown .dropdown-content a:hover {
-    background-color: #ddd;
-}
-
-.cta-dropdown .dropdown-content img {
-    width: 0.85em;
-    height: 0.85em;
-}
-
-.cta-dropdown.secondary-cta-dropdown .dropdown-content a:hover {
-    background-color: #566963;
-}
-
-.cta-dropdown.secondary-cta-dropdown .dropdown-content {
-    background-color: #768d87;
-    border-color: #566963;
-}
-
-.cta-dropdown.secondary-cta-dropdown .dropdown-content a {
-    color: #fff;
-    text-shadow: #2b665e 0 1px 0;
-}
-
-.cta-dropdown .dropdown-content a {
-    padding: 0.75em 1em;
-    text-decoration: none;
-    display: block;
-}
-
-.sublinks {
-    font-size: 0.9em;
-    margin-bottom: 1em;
-}
-
-/*********
-** Subsections
-*********/
-.github-description {
-    border-left: 0.25em solid #dfe2e5;
-    padding-left: 1em;
-}
-
-#support-links li small {
-    display: block;
-    width: 50em;
-}
diff --git a/src/SMAPI.Web/wwwroot/Content/css/log-parser.css b/src/SMAPI.Web/wwwroot/Content/css/log-parser.css
deleted file mode 100644
index d5013207..00000000
--- a/src/SMAPI.Web/wwwroot/Content/css/log-parser.css
+++ /dev/null
@@ -1,318 +0,0 @@
-/*********
-** Main layout
-*********/
-#content {
-    max-width: 100%;
-}
-
-caption {
-    text-align: left;
-    padding-top: 2px;
-}
-
-#output {
-    padding: 10px;
-    overflow: auto;
-}
-
-#output h2 {
-    margin: -10px 0 10px -10px;
-}
-
-#output table {
-    font-family: monospace;
-}
-
-table caption {
-    font-weight: bold;
-}
-
-/*********
-** Result banner
-*********/
-.banner {
-    border: 2px solid gray;
-    border-radius: 5px;
-    margin-top: 1em;
-    padding: 1em;
-}
-
-.banner.success {
-    border-color: green;
-    background: #CFC;
-}
-
-.banner.error {
-    border-color: red;
-    background: #FCC;
-}
-
-/*********
-** Log metadata & filters
-*********/
-.table, #filters {
-    border-bottom: 1px dashed #888888;
-    margin-bottom: 5px;
-}
-
-#metadata th {
-    text-align: right;
-    padding-right: 0.7em;
-}
-
-.table {
-    border: 1px solid #000000;
-    background: #ffffff;
-    border-radius: 5px;
-    border-spacing: 1px;
-    overflow: hidden;
-    cursor: default;
-    box-shadow: 1px 1px 1px 1px #dddddd;
-}
-
-.mod-entry {
-    height: 1.8em;
-}
-
-.table > caption {
-    min-height: 1.3em;
-}
-
-#fix-list {
-    margin-bottom: 2em;
-}
-
-#updates {
-    min-width: 10em;
-}
-
-#mods {
-    min-width: 400px;
-}
-
-#mods .color-red {
-    color: red;
-}
-
-#mods .color-green {
-    color: green;
-}
-
-#mods tr {
-    cursor: pointer;
-}
-
-#mods.filters-disabled tr {
-    cursor: default;
-}
-
-.table tr {
-    background: #eee
-}
-
-#mods span.notice {
-    font-weight: normal;
-    font-size: 11px;
-    position: relative;
-    top: -1px;
-    display: none;
-}
-
-#mods span.notice.btn {
-    cursor: pointer;
-    border: 1px solid #000;
-    border-radius: 5px;
-    position: relative;
-    top: -1px;
-    padding: 0 2px;
-    background: #eee;
-}
-
-#mods span.notice.txt {
-    display: inline-block;
-}
-
-.table .hidden {
-    opacity: 0.5;
-}
-
-.table .content-packs {
-    margin-left: 1em;
-    font-size: 0.9em;
-    font-style: italic;
-}
-
-#metadata td:first-child {
-    padding-right: 5px;
-}
-
-.table tr:nth-child(even) {
-    background: #fff
-}
-
-#filters {
-    margin: 1em 0 0 0;
-    padding: 0;
-    font-weight: bold;
-}
-
-#filters span {
-    padding: 3px 1em;
-    display: inline-block;
-    border: 1px solid #000000;
-    border-radius: 3px;
-    font-family: monospace;
-    cursor: pointer;
-    font-weight: bold;
-    color: #000;
-    border-color: #880000;
-    background-color: #fcc;
-}
-
-#filters span:hover {
-    background-color: #fee;
-}
-
-#filters span.active {
-    background: #cfc;
-    border-color: #008800;
-}
-
-#filters span.active:hover {
-    background: #efe;
-}
-
-/*********
-** Log
-*********/
-#log .mod-repeat {
-    font-size: 0.85em;
-}
-
-#log .trace {
-    color: #999;
-}
-
-#log .debug {
-    color: #595959;
-}
-
-#log .info {
-    color: #000;
-}
-
-#log .alert {
-    color: #b0b;
-}
-
-#log .warn {
-    color: #f80;
-}
-
-#log .error {
-    color: #f00;
-}
-
-#log .critical {
-    background-color: #c00;
-    color: #fff;
-    font-weight: bold;
-}
-
-#log .section-start {
-    cursor: pointer;
-}
-
-#log .section-toggle-message {
-    color: blue;
-}
-
-#log .log-message-text {
-    white-space: pre-wrap;
-}
-
-#log {
-    border-spacing: 0;
-}
-
-#log tr {
-    background: #fff;
-}
-
-#log td {
-    padding: 0 1px;
-    background: inherit;
-    border-bottom: 1px dotted #ccc;
-    border-top: 2px solid #fff;
-    vertical-align: top;
-}
-
-#log td:not(:last-child) {
-    max-width: 175px;
-    padding: 0 4px;
-    overflow: hidden;
-    white-space: nowrap;
-}
-
-#log td[data-title]:hover {
-    overflow: inherit;
-    position: relative;
-}
-
-#log td:nth-child(3):hover:after {
-    content: attr(data-title);
-    display: block;
-    position: absolute;
-    border-radius: 4px;
-    box-shadow: 1px 1px 2px #ccc;
-    background: inherit;
-    border: 1px solid #ccc;
-    background: #efefef;
-    padding: 1px 1px 0 1px;
-    font-size: 10pt;
-    top: -2px;
-    left: 2px;
-    color: #000;
-}
-
-#log td:last-child {
-    width: 100%;
-}
-
-#error {
-    color: #f00;
-}
-
-
-/*********
-** Upload form
-*********/
-#os-list {
-    list-style: none;
-}
-
-div[data-os] {
-    display: none;
-}
-
-#input {
-    width: 100%;
-    height: 20em;
-    max-height: 70%;
-    margin: auto;
-    box-sizing: border-box;
-    border-radius: 5px;
-    border: 1px solid #000088;
-    outline: none;
-    box-shadow: inset 0px 0px 1px 1px rgba(0, 0, 192, .2);
-}
-
-#submit {
-    font-size: 1.5em;
-    border-radius: 5px;
-    outline: none;
-    box-shadow: inset 0 0 1px 1px rgba(0, 0, 0, .2);
-    cursor: pointer;
-    border: 1px solid #008800;
-    background-color: #cfc;
-}
diff --git a/src/SMAPI.Web/wwwroot/Content/css/main.css b/src/SMAPI.Web/wwwroot/Content/css/main.css
deleted file mode 100644
index 57eeee88..00000000
--- a/src/SMAPI.Web/wwwroot/Content/css/main.css
+++ /dev/null
@@ -1,141 +0,0 @@
-/* tags */
-html {
-    height: 100%;
-}
-
-body {
-    height: 100%;
-    font-family: sans-serif;
-}
-
-h1, h2, h3 {
-    font-weight: bold;
-    margin: 0.2em 0 0.1em 0;
-    padding-top: .5em;
-}
-
-h1 {
-    font-size: 1.5em;
-    color: #888;
-    margin-bottom: 0;
-}
-
-h2 {
-    font-size: 1.5em;
-    border-bottom: 1px solid #AAA;
-}
-
-h3 {
-    font-size: 1.2em;
-    border-bottom: 1px solid #AAA;
-    width: 55em;
-    max-width: 100%;
-}
-
-a {
-    color: #006;
-}
-
-/* content */
-#content-column {
-    position: absolute;
-    top: 1em;
-    left: 10em;
-}
-
-#content {
-    min-height: 140px;
-    width: calc(100% - 2em);
-    max-width: 60em;
-    padding: 0 1em 1em 1em;
-    border-left: 1px solid #CCC;
-    background: #FFF;
-    font-size: 0.9em;
-}
-
-#content p {
-    max-width: 100%;
-}
-
-.section {
-    border: 1px solid #CCC;
-    padding: 0.5em;
-    margin-bottom: 1em;
-}
-
-/* sidebar */
-#sidebar {
-    margin-top: 3em;
-    min-height: 75%;
-    width: 12em;
-    background: url("../images/sidebar-bg.gif") no-repeat top right;
-    color: #666;
-}
-
-#sidebar h4 {
-    margin: 0 0 0.2em 0;
-    width: 10em;
-    border-bottom: 1px solid #CCC;
-    font-size: 0.8em;
-    font-weight: normal;
-}
-
-#sidebar a {
-    color: #77B;
-    border: 0;
-}
-
-#sidebar ul, #sidebar li {
-    margin: 0;
-    padding: 0;
-    list-style: none none;
-    font-size: 0.9em;
-    color: #888;
-}
-
-#sidebar li {
-    margin-left: 1em;
-}
-
-/* footer */
-#footer {
-    margin: 1em;
-    padding: 1em;
-    font-size: 0.6em;
-    color: gray;
-}
-
-#footer a {
-    color: #669;
-}
-
-/* mobile fixes */
-@media (min-width: 1020px) and (max-width: 1199px) {
-    #sidebar {
-        width: 7em;
-        background: none;
-    }
-
-    #content-column {
-        left: 7em;
-    }
-}
-
-@media (max-width: 1019px) {
-    h1 {
-        margin-top: 0;
-    }
-
-    #sidebar {
-        margin-top: 0;
-        width: auto;
-        min-height: 0;
-        background: none;
-    }
-
-    #content-column {
-        position: inherit;
-        top: inherit;
-        left: inherit;
-    }
-}
diff --git a/src/SMAPI.Web/wwwroot/Content/css/mods.css b/src/SMAPI.Web/wwwroot/Content/css/mods.css
deleted file mode 100644
index fc5fff47..00000000
--- a/src/SMAPI.Web/wwwroot/Content/css/mods.css
+++ /dev/null
@@ -1,141 +0,0 @@
-/*********
-** Intro
-*********/
-#content {
-    max-width: calc(100% - 2em); /* allow for wider table if room available */
-}
-
-#intro {
-    max-width: 60em;
-}
-
-#beta-blurb {
-    margin-bottom: 2em;
-    padding: 1em;
-    border: 3px solid darkgreen;
-}
-
-table.wikitable {
-    background-color:#f8f9fa;
-    color:#222;
-    border:1px solid #a2a9b1;
-    border-collapse:collapse
-}
-
-table.wikitable > tr > th,
-table.wikitable > tr > td,
-table.wikitable > * > tr > th,
-table.wikitable > * > tr > td {
-    border:1px solid #a2a9b1;
-    padding:0.2em 0.4em
-}
-
-table.wikitable > tr > th,
-table.wikitable > * > tr > th {
-    background-color:#eaecf0;
-}
-
-table.wikitable > caption {
-    font-weight:bold
-}
-
-#options {
-    margin-bottom: 1em;
-}
-
-#options #filter-area {
-    opacity: 0.7;
-}
-
-#options #filters {
-    margin-left: 2em;
-    padding-left: 0.5em;
-    border-left: 2px solid gray;
-}
-
-#options #filters span {
-    padding: 2px;
-    margin: 2px;
-    display: inline-block;
-    border-radius: 3px;
-    color: #000;
-    border-color: #880000;
-    background-color: #fcc;
-    font-size: 0.9em;
-}
-
-#options #filters span.active {
-    background: #cfc;
-}
-
-#mod-count {
-    font-size: 0.8em;
-    opacity: 0.5;
-}
-
-#mod-list {
-    font-size: 0.9em;
-}
-
-#mod-list th.header {
-    background-repeat: no-repeat;
-    background-position: center right;
-    cursor: pointer;
-    background-image: url(data:image/gif;base64,R0lGODlhFQAJAIABAAAAAAAAACH/C1hNUCBEYXRhWE1QPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS4wLWMwNjAgNjEuMTM0Nzc3LCAyMDEwLzAyLzEyLTE3OjMyOjAwICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1wTU06T3JpZ2luYWxEb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTE4OEM2REYyN0ExMDhBNDJFIiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOjdCNTAyODcwMEY4NjExRTBBMzkyQzAyM0E1RDk3RDc3IiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOjdCNTAyODZGMEY4NjExRTBBMzkyQzAyM0E1RDk3RDc3IiB4bXA6Q3JlYXRvclRvb2w9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIj4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6MDE4MDExNzQwNzIwNjgxMTg4QzZERjI3QTEwOEE0MkUiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMTg4QzZERjI3QTEwOEE0MkUiLz4gPC9yZGY6RGVzY3JpcHRpb24+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz4B//79/Pv6+fj39vX08/Lx8O/u7ezr6uno5+bl5OPi4eDf3t3c29rZ2NfW1dTT0tHQz87NzMvKycjHxsXEw8LBwL++vby7urm4t7a1tLOysbCvrq2sq6qpqKempaSjoqGgn56dnJuamZiXlpWUk5KRkI+OjYyLiomIh4aFhIOCgYB/fn18e3p5eHd2dXRzcnFwb25tbGtqaWhnZmVkY2JhYF9eXVxbWllYV1ZVVFNSUVBPTk1MS0pJSEdGRURDQkFAPz49PDs6OTg3NjU0MzIxMC8uLSwrKikoJyYlJCMiISAfHh0cGxoZGBcWFRQTEhEQDw4NDAsKCQgHBgUEAwIBAAAh+QQBAAABACwAAAAAFQAJAAACF4yPgMsJ2mJ4VDKKrd4GVz5lYPeMiVUAADs=);
-    padding-right: 1.5em;
-}
-
-#mod-list th.headerSortUp {
-    background-image: url(data:image/gif;base64,R0lGODlhFQAEAIABAAAAAAAAACH/C1hNUCBEYXRhWE1QPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS4wLWMwNjAgNjEuMTM0Nzc3LCAyMDEwLzAyLzEyLTE3OjMyOjAwICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1wTU06T3JpZ2luYWxEb2N1bWVudElEPSJ4bXAuZGlkOjAzODAxMTc0MDcyMDY4MTE4OEM2REYyN0ExMDhBNDJFIiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOjdCNTAyODc0MEY4NjExRTBBMzkyQzAyM0E1RDk3RDc3IiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOjdCNTAyODczMEY4NjExRTBBMzkyQzAyM0E1RDk3RDc3IiB4bXA6Q3JlYXRvclRvb2w9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIj4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6MDM4MDExNzQwNzIwNjgxMTg4QzZERjI3QTEwOEE0MkUiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6MDM4MDExNzQwNzIwNjgxMTg4QzZERjI3QTEwOEE0MkUiLz4gPC9yZGY6RGVzY3JpcHRpb24+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz4B//79/Pv6+fj39vX08/Lx8O/u7ezr6uno5+bl5OPi4eDf3t3c29rZ2NfW1dTT0tHQz87NzMvKycjHxsXEw8LBwL++vby7urm4t7a1tLOysbCvrq2sq6qpqKempaSjoqGgn56dnJuamZiXlpWUk5KRkI+OjYyLiomIh4aFhIOCgYB/fn18e3p5eHd2dXRzcnFwb25tbGtqaWhnZmVkY2JhYF9eXVxbWllYV1ZVVFNSUVBPTk1MS0pJSEdGRURDQkFAPz49PDs6OTg3NjU0MzIxMC8uLSwrKikoJyYlJCMiISAfHh0cGxoZGBcWFRQTEhEQDw4NDAsKCQgHBgUEAwIBAAAh+QQBAAABACwAAAAAFQAEAAACDYwfoAvoz9qbZ9FrJC0AOw==);
-}
-
-#mod-list th.headerSortDown {
-    background-image: url(data:image/gif;base64,R0lGODlhFQAEAIABAAAAAAAAACH/C1hNUCBEYXRhWE1QPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS4wLWMwNjAgNjEuMTM0Nzc3LCAyMDEwLzAyLzEyLTE3OjMyOjAwICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1wTU06T3JpZ2luYWxEb2N1bWVudElEPSJ4bXAuZGlkOjAyODAxMTc0MDcyMDY4MTE4OEM2REYyN0ExMDhBNDJFIiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOjhFNzNGQjI3MEY4NjExRTBBMzkyQzAyM0E1RDk3RDc3IiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOjhFNzNGQjI2MEY4NjExRTBBMzkyQzAyM0E1RDk3RDc3IiB4bXA6Q3JlYXRvclRvb2w9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIj4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6MDI4MDExNzQwNzIwNjgxMTg4QzZERjI3QTEwOEE0MkUiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6MDI4MDExNzQwNzIwNjgxMTg4QzZERjI3QTEwOEE0MkUiLz4gPC9yZGY6RGVzY3JpcHRpb24+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz4B//79/Pv6+fj39vX08/Lx8O/u7ezr6uno5+bl5OPi4eDf3t3c29rZ2NfW1dTT0tHQz87NzMvKycjHxsXEw8LBwL++vby7urm4t7a1tLOysbCvrq2sq6qpqKempaSjoqGgn56dnJuamZiXlpWUk5KRkI+OjYyLiomIh4aFhIOCgYB/fn18e3p5eHd2dXRzcnFwb25tbGtqaWhnZmVkY2JhYF9eXVxbWllYV1ZVVFNSUVBPTk1MS0pJSEdGRURDQkFAPz49PDs6OTg3NjU0MzIxMC8uLSwrKikoJyYlJCMiISAfHh0cGxoZGBcWFRQTEhEQDw4NDAsKCQgHBgUEAwIBAAAh+QQBAAABACwAAAAAFQAEAAACDYyPAcmtsJyDVDKKWQEAOw==);
-}
-
-#mod-list .mod-page-links,
-#mod-list .mod-broke-in {
-    font-size: 0.9em;
-}
-
-#mod-list .mod-alt-authors,
-#mod-list .mod-alt-names {
-    font-size: 0.8em;
-}
-
-#mod-list .mod-alt-authors,
-#mod-list .mod-alt-names {
-    display: block;
-}
-
-#mod-list tr[data-status="ok"],
-#mod-list tr[data-status="optional"] {
-    background: #BFB;
-}
-
-#mod-list tr[data-status="workaround"],
-#mod-list tr[data-status="unofficial"] {
-    background: #FFFEC6;
-}
-
-#mod-list tr[data-status="broken"] {
-    background: #FBB;
-}
-
-#mod-list tr[data-status="obsolete"],
-#mod-list tr[data-status="abandoned"] {
-    background: #BBB;
-    opacity: 0.7;
-}
-
-#mod-list tr[data-status="abandoned"] .mod-page-links,
-#mod-list tr[data-status="broken"] .mod-page-links,
-#mod-list tr[data-status="obsolete"] .mod-page-links,
-#mod-list tr[data-status="unofficial"] .mod-page-links,
-#mod-list tr[data-status="workaround"] .mod-page-links {
-    text-decoration: line-through;
-}
-
-#mod-list td.smapi-3-col span {
-    border-bottom: 1px dashed gray;
-}
diff --git a/src/SMAPI.Web/wwwroot/Content/css/privacy.css b/src/SMAPI.Web/wwwroot/Content/css/privacy.css
deleted file mode 100644
index 94bc68a9..00000000
--- a/src/SMAPI.Web/wwwroot/Content/css/privacy.css
+++ /dev/null
@@ -1,3 +0,0 @@
-h3 {
-    border: 0;
-}
diff --git a/src/SMAPI.Web/wwwroot/Content/images/direct-download-icon.png b/src/SMAPI.Web/wwwroot/Content/images/direct-download-icon.png
deleted file mode 100644
index 6c30ca36..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/direct-download-icon.png and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-help.png b/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-help.png
deleted file mode 100644
index c5546c07..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-help.png and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-upcoming.png b/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-upcoming.png
deleted file mode 100644
index 065d64a9..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-upcoming.png and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-what-i-do.png b/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-what-i-do.png
deleted file mode 100644
index 1060d3d0..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/external/patreon-header-what-i-do.png and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/images/nexus-icon.png b/src/SMAPI.Web/wwwroot/Content/images/nexus-icon.png
deleted file mode 100644
index 10c66712..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/nexus-icon.png and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/images/pufferchick-cool.png b/src/SMAPI.Web/wwwroot/Content/images/pufferchick-cool.png
deleted file mode 100644
index f359146c..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/pufferchick-cool.png and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/images/pufferchick.png b/src/SMAPI.Web/wwwroot/Content/images/pufferchick.png
deleted file mode 100644
index 1de9cf47..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/pufferchick.png and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/images/sidebar-bg.gif b/src/SMAPI.Web/wwwroot/Content/images/sidebar-bg.gif
deleted file mode 100644
index 48e9af5a..00000000
Binary files a/src/SMAPI.Web/wwwroot/Content/images/sidebar-bg.gif and /dev/null differ
diff --git a/src/SMAPI.Web/wwwroot/Content/js/index.js b/src/SMAPI.Web/wwwroot/Content/js/index.js
deleted file mode 100644
index d0734b02..00000000
--- a/src/SMAPI.Web/wwwroot/Content/js/index.js
+++ /dev/null
@@ -1,34 +0,0 @@
-$(document).ready(function () {
-    /* enable pufferchick */
-    var pufferchick = $("#pufferchick");
-    $(".cta-dropdown").hover(
-        function () {
-            pufferchick.attr("src", "Content/images/pufferchick-cool.png");
-        },
-        function () {
-            pufferchick.attr("src", "Content/images/pufferchick.png");
-        }
-    );
-
-    /* enable download dropdowns */
-    $(".cta-dropdown a.download").each(function(i, button) {
-        button = $(button);
-        var wrapper = button.parent(".cta-dropdown");
-        var button = wrapper.find(".download");
-        var dropdownContent = wrapper.find(".dropdown-content");
-
-        $(window).on("click", function(e) {
-            var target = $(e.target);
-
-            // toggle dropdown on button click
-            if (target.is(button) || $.contains(button.get(0), target.get(0))) {
-                e.preventDefault();
-                dropdownContent.toggle();
-            }
-
-            // else hide dropdown
-            else
-                dropdownContent.hide();
-        });
-    });
-});
diff --git a/src/SMAPI.Web/wwwroot/Content/js/log-parser.js b/src/SMAPI.Web/wwwroot/Content/js/log-parser.js
deleted file mode 100644
index e87a1a5c..00000000
--- a/src/SMAPI.Web/wwwroot/Content/js/log-parser.js
+++ /dev/null
@@ -1,162 +0,0 @@
-/* globals $ */
-
-var smapi = smapi || {};
-var app;
-smapi.logParser = function (data, sectionUrl) {
-    // internal filter counts
-    var stats = data.stats = {
-        modsShown: 0,
-        modsHidden: 0
-    };
-    function updateModFilters() {
-        // counts
-        stats.modsShown = 0;
-        stats.modsHidden = 0;
-        for (var key in data.showMods) {
-            if (data.showMods.hasOwnProperty(key)) {
-                if (data.showMods[key])
-                    stats.modsShown++;
-                else
-                    stats.modsHidden++;
-            }
-        }
-    }
-
-    // set local time started
-    if(data)
-        data.localTimeStarted = ("0" + data.logStarted.getHours()).slice(-2) + ":" + ("0" + data.logStarted.getMinutes()).slice(-2);
-
-    // init app
-    app = new Vue({
-        el: '#output',
-        data: data,
-        computed: {
-            anyModsHidden: function () {
-                return stats.modsHidden > 0;
-            },
-            anyModsShown: function () {
-                return stats.modsShown > 0;
-            }
-        },
-        methods: {
-            toggleLevel: function (id) {
-                if (!data.enableFilters)
-                    return;
-
-                this.showLevels[id] = !this.showLevels[id];
-            },
-
-            toggleMod: function (id) {
-                if (!data.enableFilters)
-                    return;
-
-                var curShown = this.showMods[id];
-
-                // first filter: only show this by default
-                if (stats.modsHidden === 0) {
-                    this.hideAllMods();
-                    this.showMods[id] = true;
-                }
-
-                // unchecked last filter: reset
-                else if (stats.modsShown === 1 && curShown)
-                    this.showAllMods();
-
-                // else toggle
-                else
-                    this.showMods[id] = !this.showMods[id];
-
-                updateModFilters();
-            },
-
-            toggleSection: function (name) {
-                if (!data.enableFilters)
-                    return;
-
-                this.showSections[name] = !this.showSections[name];
-            },
-
-            showAllMods: function () {
-                if (!data.enableFilters)
-                    return;
-
-                for (var key in this.showMods) {
-                    if (this.showMods.hasOwnProperty(key)) {
-                        this.showMods[key] = true;
-                    }
-                }
-                updateModFilters();
-            },
-
-            hideAllMods: function () {
-                if (!data.enableFilters)
-                    return;
-
-                for (var key in this.showMods) {
-                    if (this.showMods.hasOwnProperty(key)) {
-                        this.showMods[key] = false;
-                    }
-                }
-                updateModFilters();
-            },
-
-            filtersAllow: function(modId, level) {
-                return this.showMods[modId] !== false && this.showLevels[level] !== false;
-            },
-
-            sectionsAllow: function (section) {
-                return this.showSections[section] !== false;
-            }
-        }
-    });
-
-    /**********
-    ** Upload form
-    *********/
-    var input = $("#input");
-    if (input.length) {
-        // get elements
-        var systemOptions = $("input[name='os']");
-        var systemInstructions = $("div[data-os]");
-        var submit = $("#submit");
-
-        // instruction OS chooser
-        var chooseSystem = function() {
-            systemInstructions.hide();
-            systemInstructions.filter("[data-os='" + $("input[name='os']:checked").val() + "']").show();
-        }
-        systemOptions.on("click", chooseSystem);
-        chooseSystem();
-
-        // disable submit if it's empty
-        var toggleSubmit = function()
-        {
-            var hasText = !!input.val().trim();
-            submit.prop("disabled", !hasText);
-        }
-        input.on("input", toggleSubmit);
-        toggleSubmit();
-
-        // drag & drop file
-        input.on({
-            'dragover dragenter': function(e) {
-                e.preventDefault();
-                e.stopPropagation();
-            },
-            'drop': function(e) {
-                var dataTransfer = e.originalEvent.dataTransfer;
-                if (dataTransfer && dataTransfer.files.length) {
-                    e.preventDefault();
-                    e.stopPropagation();
-                    var file = dataTransfer.files[0];
-                    var reader = new FileReader();
-                    reader.onload = $.proxy(function(file, $input, event) {
-                        $input.val(event.target.result);
-                        toggleSubmit();
-                    }, this, file, $("#input"));
-                    reader.readAsText(file);
-                }
-            }
-        });
-    }
-};
diff --git a/src/SMAPI.Web/wwwroot/Content/js/mods.js b/src/SMAPI.Web/wwwroot/Content/js/mods.js
deleted file mode 100644
index 874fbf25..00000000
--- a/src/SMAPI.Web/wwwroot/Content/js/mods.js
+++ /dev/null
@@ -1,284 +0,0 @@
-/* globals $ */
-
-var smapi = smapi || {};
-var app;
-smapi.modList = function (mods, enableBeta) {
-    // init data
-    var defaultStats = {
-        total: 0,
-        compatible: 0,
-        workaround: 0,
-        soon: 0,
-        broken: 0,
-        abandoned: 0,
-        invalid: 0,
-        smapi3_unknown: 0,
-        smapi3_ok: 0,
-        smapi3_broken: 0,
-        smapi3_soon: 0
-    };
-    var data = {
-        mods: mods,
-        showAdvanced: false,
-        visibleStats: $.extend({}, defaultStats),
-        filters: {
-            source: {
-                value: {
-                    open: { value: true },
-                    closed: { value: true }
-                }
-            },
-            status: {
-                label: enableBeta ? "main status" : "status",
-                value: {
-                    // note: keys must match status returned by the API
-                    ok: { value: true },
-                    optional: { value: true },
-                    unofficial: { value: true },
-                    workaround: { value: true },
-                    broken: { value: true },
-                    abandoned: { value: true },
-                    obsolete: { value: true }
-                }
-            },
-            betaStatus: {
-                label: "beta status",
-                value: {} // cloned from status field if needed
-            },
-            download: {
-                value: {
-                    chucklefish: { value: true, label: "Chucklefish" },
-                    moddrop: { value: true, label: "ModDrop" },
-                    nexus: { value: true, label: "Nexus" },
-                    custom: { value: true }
-                }
-            },
-            smapi3: {
-                label: "SMAPI 3.0",
-                value: {
-                    // note: keys must match status returned by the API
-                    ok: { value: true, label: "ready" },
-                    soon: { value: true },
-                    broken: { value: true },
-                    unknown: { value: true }
-                }
-            }
-        },
-        search: ""
-    };
-
-    // init filters
-    Object.entries(data.filters).forEach(([groupKey, filterGroup]) => {
-        filterGroup.label = filterGroup.label || groupKey;
-        Object.entries(filterGroup.value).forEach(([filterKey, filter]) => {
-            filter.id = ("filter_" + groupKey + "_" + filterKey).replace(/[^a-zA-Z0-9]/g, "_");
-            filter.label = filter.label || filterKey;
-        });
-    });
-
-    // init beta filters
-    if (enableBeta) {
-        var filterGroup = data.filters.betaStatus;
-        $.extend(true, filterGroup.value, data.filters.status.value);
-        Object.entries(filterGroup.value).forEach(([filterKey, filter]) => {
-            filter.id = "beta_" + filter.id;
-        });
-    }
-    else
-        delete data.filters.betaStatus;
-
-    window.boop = data.filters;
-
-    // init mods
-    for (var i = 0; i < data.mods.length; i++) {
-        var mod = mods[i];
-
-        // set initial visibility
-        mod.Visible = true;
-
-        // set overall compatibility
-        mod.LatestCompatibility = mod.BetaCompatibility || mod.Compatibility;
-
-        // set SMAPI 3.0 display text
-        switch (mod.Smapi3Status) {
-            case "ok":
-                mod.Smapi3DisplayText = "✓ yes";
-                mod.Smapi3Tooltip = "The latest version of this mod is compatible with SMAPI 3.0.";
-                break;
-
-            case "broken":
-                mod.Smapi3DisplayText = "✖ no";
-                mod.Smapi3Tooltip = "This mod will break in SMAPI 3.0; consider notifying the author.";
-                break;
-
-            default:
-                mod.Smapi3DisplayText = "↻ " + mod.Smapi3Status;
-                mod.Smapi3Tooltip = "This mod has a pending update for SMAPI 3.0 which hasn't been released yet.";
-                break;
-        }
-
-        // concatenate searchable text
-        mod.SearchableText = [mod.Name, mod.AlternateNames, mod.Author, mod.AlternateAuthors, mod.Compatibility.Summary, mod.BrokeIn];
-        if (mod.Compatibility.UnofficialVersion)
-            mod.SearchableText.push(mod.Compatibility.UnofficialVersion);
-        if (mod.BetaCompatibility) {
-            mod.SearchableText.push(mod.BetaCompatibility.Summary);
-            if (mod.BetaCompatibility.UnofficialVersion)
-                mod.SearchableText.push(mod.BetaCompatibility.UnofficialVersion);
-        }
-        for (var p = 0; p < mod.ModPages; p++)
-            mod.SearchableField.push(mod.ModPages[p].Text);
-        mod.SearchableText = mod.SearchableText.join(" ").toLowerCase();
-    }
-
-    // init app
-    app = new Vue({
-        el: "#app",
-        data: data,
-        mounted: function() {
-            // enable table sorting
-            $("#mod-list").tablesorter({
-                cssHeader: "header",
-                cssAsc: "headerSortUp",
-                cssDesc: "headerSortDown"
-            });
-
-            // put focus in textbox for quick search
-            if (!location.hash)
-                $("#search-box").focus();
-
-            // jump to anchor (since table is added after page load)
-            if (location.hash) {
-                var row = $(location.hash).get(0);
-                if (row)
-                    row.scrollIntoView();
-            }
-        },
-        methods: {
-            /**
-             * Update the visibility of all mods based on the current search text and filters.
-             */
-            applyFilters: function () {
-                // get search terms
-                var words = data.search.toLowerCase().split(" ");
-
-                // apply criteria
-                var stats = data.visibleStats = $.extend({}, defaultStats);
-                for (var i = 0; i < data.mods.length; i++) {
-                    var mod = data.mods[i];
-                    mod.Visible = true;
-
-                    // check filters
-                    mod.Visible = this.matchesFilters(mod, words);
-                    if (mod.Visible) {
-                        stats.total++;
-                        stats[this.getCompatibilityGroup(mod)]++;
-                        stats["smapi3_" + mod.Smapi3Status]++;
-                    }
-                }
-            },
-
-
-            /**
-             * Get whether a mod matches the current filters.
-             * @param {object} mod The mod to check.
-             * @param {string[]} searchWords The search words to match.
-             * @returns {bool} Whether the mod matches the filters.
-             */
-            matchesFilters: function(mod, searchWords) {
-                var filters = data.filters;
-
-                // check source
-                if (!filters.source.value.open.value && mod.SourceUrl)
-                    return false;
-                if (!filters.source.value.closed.value && !mod.SourceUrl)
-                    return false;
-
-                // check status
-                var mainStatus = mod.Compatibility.Status;
-                if (filters.status.value[mainStatus] && !filters.status.value[mainStatus].value)
-                    return false;
-
-                // check beta status
-                if (enableBeta) {
-                    var betaStatus = mod.LatestCompatibility.Status;
-                    if (filters.betaStatus.value[betaStatus] && !filters.betaStatus.value[betaStatus].value)
-                        return false;
-                }
-
-                // check SMAPI 3.0 compatibility
-                if (filters.smapi3.value[mod.Smapi3Status] && !filters.smapi3.value[mod.Smapi3Status].value)
-                    return false;
-
-                // check download sites
-                var ignoreSites = [];
-
-                if (!filters.download.value.chucklefish.value)
-                    ignoreSites.push("Chucklefish");
-                if (!filters.download.value.moddrop.value)
-                    ignoreSites.push("ModDrop");
-                if (!filters.download.value.nexus.value)
-                    ignoreSites.push("Nexus");
-                if (!filters.download.value.custom.value)
-                    ignoreSites.push("custom");
-
-                if (ignoreSites.length) {
-                    var anyLeft = false;
-                    for (var i = 0; i < mod.ModPageSites.length; i++) {
-                        if (ignoreSites.indexOf(mod.ModPageSites[i]) === -1) {
-                            anyLeft = true;
-                            break;
-                        }
-                    }
-
-                    if (!anyLeft)
-                        return false;
-                }
-
-                // check search terms
-                for (var w = 0; w < searchWords.length; w++) {
-                    if (mod.SearchableText.indexOf(searchWords[w]) === -1)
-                        return false;
-                }
-
-                return true;
-            },
-
-            /**
-             * Get a mod's compatibility group for mod metrics.
-             * @param {object} mod The mod to check.
-             * @returns {string} The compatibility group (one of 'compatible', 'workaround', 'soon', 'broken', 'abandoned', or 'invalid').
-             */
-            getCompatibilityGroup: function (mod) {
-                var status = mod.LatestCompatibility.Status;
-                switch (status) {
-                    // obsolete
-                    case "abandoned":
-                    case "obsolete":
-                        return "abandoned";
-
-                    // compatible
-                    case "ok":
-                    case "optional":
-                        return "compatible";
-
-                    // workaround
-                    case "workaround":
-                    case "unofficial":
-                        return "workaround";
-
-                    // soon/broken
-                    case "broken":
-                        if (mod.SourceUrl)
-                            return "soon";
-                        else
-                            return "broken";
-
-                    default:
-                        return "invalid";
-                }
-            }
-        }
-    });
-    app.applyFilters();
-};
diff --git a/src/SMAPI.Web/wwwroot/StardewModdingAPI.metadata.json b/src/SMAPI.Web/wwwroot/StardewModdingAPI.metadata.json
deleted file mode 100644
index 08e34114..00000000
--- a/src/SMAPI.Web/wwwroot/StardewModdingAPI.metadata.json
+++ /dev/null
@@ -1,569 +0,0 @@
-{
-  /**
-   * Metadata about some SMAPI mods used in compatibility, update, and dependency checks. This
-   * field shouldn't be edited by players in most cases.
-   *
-   * Standard fields
-   * ===============
-   * The predefined fields are documented below (only 'ID' is required). Each entry's key is the
-   * default display name for the mod if one isn't available (e.g. in dependency checks).
-   *
-   *   - ID: the mod's latest unique ID (if any).
-   *
-   *   - FormerIDs: uniquely identifies the mod across multiple versions, and supports matching
-   *     other fields if no ID was specified. This doesn't include the latest ID, if any. Multiple
-   *     variants can be separated with '|'.
-   *
-   *   - MapLocalVersions and MapRemoteVersions correct local manifest versions and remote versions
-   *     during update checks. For example, if the API returns version '1.1-1078' where '1078' is
-   *     intended to be a build number, MapRemoteVersions can map it to '1.1' when comparing to the
-   *     mod's current version. This is only meant to support legacy mods with injected update keys.
-   *
-   * Versioned metadata
-   * ==================
-   * Each record can also specify extra metadata using the field keys below.
-   *
-   * Each key consists of a field name prefixed with any combination of version range and 'Default',
-   * separated by pipes (whitespace trimmed). For example, 'UpdateKey' will always override,
-   * 'Default | UpdateKey' will only override if the mod has no update keys, and
-   * '~1.1 | Default | Name' will do the same up to version 1.1.
-   *
-   * The version format is 'min~max' (where either side can be blank for unbounded), or a single
-   * version number.
-   *
-   * These are the valid field names:
-   *
-   *   - UpdateKey: the update key to set in the mod's manifest. This is used to enable update
-   *     checks for older mods that haven't been updated to use it yet.
-   *
-   *   - Status: overrides compatibility checks. The possible values are Obsolete (SMAPI won't load
-   *     it because the mod should no longer be used), AssumeBroken (SMAPI won't load it because
-   *     the specified version isn't compatible), or AssumeCompatible (SMAPI will try to load it
-   *     even if it detects incompatible code).
-   *
-   *     Note that this shouldn't be set to 'AssumeBroken' if SMAPI can detect the incompatibility
-   *     automatically, since that hides the details from trace logs.
-   *
-   *   - StatusReasonPhrase: a message to show to the player explaining why the mod can't be loaded
-   *     (if applicable). If blank, will default to a generic not-compatible message.
-   *
-   *   - AlternativeUrl: a URL where the player can find an unofficial update or alternative if the
-   *     mod is no longer compatible.
-   */
-  "ModData": {
-    /*********
-    ** Common dependencies for friendly errors
-    *********/
-    "Advanced Location Loader": {
-      "ID": "Entoarox.AdvancedLocationLoader",
-      "Default | UpdateKey": "Nexus:2270"
-    },
-
-    //"Content Patcher": {
-    //  "ID": "Pathoschild.ContentPatcher",
-    //  "Default | UpdateKey": "Nexus:1915"
-    //},
-
-    //"Custom Farming Redux": {
-    //  "ID": "Platonymous.CustomFarming",
-    //  "Default | UpdateKey": "Nexus:991"
-    //},
-
-    "Custom Shirts": {
-      "ID": "Platonymous.CustomShirts",
-      "Default | UpdateKey": "Nexus:2416"
-    },
-
-    "Entoarox Framework": {
-      "ID": "Entoarox.EntoaroxFramework",
-      "Default | UpdateKey": "Nexus:2269"
-    },
-
-    "JSON Assets": {
-      "ID": "spacechase0.JsonAssets",
-      "Default | UpdateKey": "Nexus:1720",
-      "1.3.1 | Status": "AssumeBroken" // causes runtime crashes
-    },
-
-    "Mail Framework": {
-      "ID": "DIGUS.MailFrameworkMod",
-      "Default | UpdateKey": "Nexus:1536"
-    },
-
-    "MTN": {
-      "ID": "SgtPickles.MTN",
-      "Default | UpdateKey": "Nexus:2256",
-      "~1.2.6 | Status": "AssumeBroken" // replaces Game1.multiplayer, which breaks SMAPI's multiplayer API.
-    },
-
-    "PyTK": {
-      "ID": "Platonymous.Toolkit",
-      "Default | UpdateKey": "Nexus:1726"
-    },
-
-    "Rubydew": {
-      "ID": "bwdy.rubydew",
-      "SuppressWarnings": "UsesDynamic", // mod explicitly loads DLLs for Linux/Mac compatibility
-      "Default | UpdateKey": "Nexus:3656"
-    },
-
-    "SpaceCore": {
-      "ID": "spacechase0.SpaceCore",
-      "Default | UpdateKey": "Nexus:1348"
-    },
-
-    "Stardust Core": {
-      "ID": "Omegasis.StardustCore",
-      "Default | UpdateKey": "Nexus:2341"
-    },
-
-    "TMX Loader": {
-      "ID": "Platonymous.TMXLoader",
-      "Default | UpdateKey": "Nexus:1820"
-    },
-
-
-    /*********
-    ** Map versions
-    *********/
-    "Adjust Artisan Prices": {
-      "ID": "ThatNorthernMonkey.AdjustArtisanPrices",
-      "FormerIDs": "1e36d4ca-c7ef-4dfb-9927-d27a6c3c8bdc", // changed in 0.0.2-pathoschild-update
-      "MapRemoteVersions": { "0.01": "0.0.1" }
-    },
-
-    "Almighty Farming Tool": {
-      "ID": "439",
-      "MapRemoteVersions": {
-        "1.21": "1.2.1",
-        "1.22-unofficial.3.mizzion": "1.2.2-unofficial.3.mizzion"
-      }
-    },
-
-    "Basic Sprinkler Improved": {
-      "ID": "lrsk_sdvm_bsi.0117171308",
-      "MapRemoteVersions": { "1.0.2": "1.0.1-release" } // manifest not updated
-    },
-
-    "Better Shipping Box": {
-      "ID": "Kithio:BetterShippingBox",
-      "MapLocalVersions": { "1.0.1": "1.0.2" }
-    },
-
-    "Chefs Closet": {
-      "ID": "Duder.ChefsCloset",
-      "MapLocalVersions": { "1.3-1": "1.3" }
-    },
-
-    "Configurable Machines": {
-      "ID": "21da6619-dc03-4660-9794-8e5b498f5b97",
-      "MapLocalVersions": { "1.2-beta": "1.2" }
-    },
-
-    "Crafting Counter": {
-      "ID": "lolpcgaming.CraftingCounter",
-      "MapRemoteVersions": { "1.1": "1.0" } // not updated in manifest
-    },
-
-    "Custom Linens": {
-      "ID": "Mevima.CustomLinens",
-      "MapRemoteVersions": { "1.1": "1.0" } // manifest not updated
-    },
-
-    "Dynamic Horses": {
-      "ID": "Bpendragon-DynamicHorses",
-      "MapRemoteVersions": { "1.2": "1.1-release" } // manifest not updated
-    },
-
-    "Dynamic Machines": {
-      "ID": "DynamicMachines",
-      "MapLocalVersions": { "1.1": "1.1.1" }
-    },
-
-    "Multiple Sprites and Portraits On Rotation (File Loading)": {
-      "ID": "FileLoading",
-      "MapLocalVersions": { "1.1": "1.12" }
-    },
-
-    "Relationship Status": {
-      "ID": "relationshipstatus",
-      "MapRemoteVersions": { "1.0.5": "1.0.4" } // not updated in manifest
-    },
-
-    "ReRegeneration": {
-      "ID": "lrsk_sdvm_rerg.0925160827",
-      "MapLocalVersions": { "1.1.2-release": "1.1.2" }
-    },
-
-    "Showcase Mod": {
-      "ID": "Igorious.Showcase",
-      "MapLocalVersions": { "0.9-500": "0.9" }
-    },
-
-    "Siv's Marriage Mod": {
-      "ID": "6266959802", // official version
-      "FormerIDs": "Siv.MarriageMod | medoli900.Siv's Marriage Mod", // 1.2.3-unofficial versions
-      "MapLocalVersions": { "0.0": "1.4" }
-    },
-
-
-    /*********
-    ** Obsolete
-    *********/
-    "Animal Mood Fix": {
-      "ID": "GPeters-AnimalMoodFix",
-      "~ | Status": "Obsolete",
-      "~ | StatusReasonPhrase": "the animal mood bugs were fixed in Stardew Valley 1.2."
-    },
-
-    "Colored Chests": {
-      "ID": "4befde5c-731c-4853-8e4b-c5cdf946805f",
-      "~ | Status": "Obsolete",
-      "~ | StatusReasonPhrase": "colored chests were added in Stardew Valley 1.1."
-    },
-
-    "Modder Serialization Utility": {
-      "ID": "SerializerUtils-0-1",
-      "~ | Status": "Obsolete",
-      "~ | StatusReasonPhrase": "it's no longer maintained or used."
-    },
-
-    "No Debug Mode": {
-      "ID": "NoDebugMode",
-      "~ | Status": "Obsolete",
-      "~ | StatusReasonPhrase": "debug mode was removed in SMAPI 1.0."
-    },
-
-    /*********
-    ** Broke in SMAPI 3.0 (runtime errors due to lifecycle changes)
-    *********/
-    "Advancing Sprinklers": {
-      "ID": "warix3.advancingsprinklers",
-      "~1.0.0 | Status": "AssumeBroken"
-    },
-
-    "Arcade 2048": {
-      "ID": "Platonymous.2048",
-      "~1.0.6 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Arcade Snake": {
-      "ID": "Platonymous.Snake",
-      "~1.1.0 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Better Sprinklers": {
-      "ID": "Speeder.BetterSprinklers",
-      "~2.3.1-unofficial.7-pathoschild | Status": "AssumeBroken"
-    },
-
-    "Companion NPCs": {
-      "ID": "Redwood.CompanionNPCs",
-      "~0.0.9 | Status": "AssumeBroken"
-    },
-
-    "Content Patcher": {
-      "ID": "Pathoschild.ContentPatcher",
-      "Default | UpdateKey": "Nexus:1915",
-      "~1.6.4 | Status": "AssumeBroken"
-    },
-
-    "Crop Transplant Mod": {
-      "ID": "DIGUS.CropTransplantMod",
-      "~1.1.3 | Status": "AssumeBroken"
-    },
-
-    "Custom Adventure Guild Challenges": {
-      "ID": "DefenTheNation.CustomGuildChallenges",
-      "~1.8 | Status": "AssumeBroken"
-    },
-
-    "Custom Farming Redux": {
-      "ID": "Platonymous.CustomFarming",
-      "Default | UpdateKey": "Nexus:991",
-      "~2.10.10 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Deep Woods": {
-      "ID": "maxvollmer.deepwoodsmod",
-      "~1.5-beta.1 | Status": "AssumeBroken"
-    },
-
-    "Everlasting Baits and Unbreaking Tackles": {
-      "ID": "DIGUS.EverlastingBaitsAndUnbreakableTacklesMod",
-      "~1.2.4 | Status": "AssumeBroken"
-    },
-
-    "Farmhouse Redone": {
-      "ID": "mabelsyrup.farmhouse",
-      "~0.2 | Status": "AssumeBroken"
-    },
-
-    "Geode Info Menu": {
-      "ID": "cat.geodeinfomenu",
-      "~1.5 | Status": "AssumeBroken"
-    },
-
-    "Harp of Yoba Redux": {
-      "ID": "Platonymous.HarpOfYobaRedux",
-      "~2.6.3 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Infested Levels": {
-      "ID": "Eireon.InfestedLevels",
-      "~1.0.5 | Status": "AssumeBroken"
-    },
-
-    "JoJaBan - Arcade Sokoban": {
-      "ID": "Platonymous.JoJaBan",
-      "~0.4.3 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Level Extender": {
-      "ID": "DevinLematty.LevelExtender",
-      "~3.1 | Status": "AssumeBroken"
-    },
-
-    "Mod Update Menu": {
-      "ID": "cat.modupdatemenu",
-      "~1.4 | Status": "AssumeBroken"
-    },
-
-    "Mushroom Levels": {
-      "ID": "Eireon.MushroomLevels",
-      "~1.0.4 | Status": "AssumeBroken"
-    },
-
-    "Notes": {
-      "ID": "Platonymous.Notes",
-      "~1.0.5 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Quick Start": {
-      "ID": "WuestMan.QuickStart",
-      "~1.5 | Status": "AssumeBroken"
-    },
-
-    "Seed Bag": {
-      "ID": "Platonymous.SeedBag",
-      "~1.2.7 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Separate Money": {
-      "ID": "funnysnek.SeparateMoney",
-      "~1.4.2 | Status": "AssumeBroken"
-    },
-
-    "Split Money": {
-      "ID": "Platonymous.SplitMoney",
-      "~1.2.4 | Status": "AssumeBroken" // possibly due to PyTK
-    },
-
-    "Stack to Nearby Chests": {
-      "ID": "Ilyaki.StackToNearbyChests",
-      "~1.4.4 | Status": "AssumeBroken"
-    },
-
-    "Tree Transplant": {
-      "ID": "TreeTransplant",
-      "~1.0.5 | Status": "AssumeBroken"
-    },
-
-    /*********
-    ** Broke in SDV 1.3.36
-    *********/
-    "2cute FarmCave": {
-      "ID": "taintedwheat.2CuteFarmCave",
-      "Default | UpdateKey": "Nexus:843",
-      "~2.0 | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    "Ace's Expanded Caves - Default Cave": {
-      "ID": "Acerbicon.AECdefault",
-      "Default | UpdateKey": "Nexus:2131",
-      "~1.2.2  | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    "Ace's Expanded Caves - Desert Cave": {
-      "ID": "Acerbicon.AECdesert",
-      "Default | UpdateKey": "Nexus:2131",
-      "~1.2.2  | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    "Ace's Expanded Caves - Ice Cave": {
-      "ID": "Acerbicon.AECice",
-      "Default | UpdateKey": "Nexus:2131",
-      "~1.2.2  | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    "Ace's Expanded Caves - Lava Cave": {
-      "ID": "Acerbicon.AEClava",
-      "Default | UpdateKey": "Nexus:2131",
-      "~1.2.2  | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    "Ace's Expanded Caves - Slime Cave": {
-      "ID": "Acerbicon.AECslime",
-      "Default | UpdateKey": "Nexus:2131",
-      "~1.2.2  | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    "Green Pastures Farm": {
-      "ID": "bugbuddy.GreenPasturesFarm",
-      "Default | UpdateKey": "Nexus:2326",
-      "~1.0    | Status": "AssumeBroken" // references deleted Content/weapons.xnb
-    },
-
-    "Immersive Farm 2": {
-      "ID": "zander.immersivefarm2",
-      "~2.0.1 | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    "Karmylla's Immersive Map Edits": {
-      "ID": "Karmylla.ImmersiveMapEdits",
-      "Default | UpdateKey": "Nexus:1149",
-      "~2.4    | Status": "AssumeBroken" // references deleted Content/weapons.xnb
-    },
-
-    "Secret Gardens Greenhouse": {
-      "ID": "jessebot.secretgardens",
-      "Default | UpdateKey": "Nexus:3067",
-      "~2.0.1 | Status": "AssumeBroken" // references deleted Content/Mine.xnb
-    },
-
-    /*********
-    ** Broke circa SDV 1.3
-    *********/
-    "Canon-Friendly Dialogue Expansion": {
-      "ID": "gizzymo.canonfriendlyexpansion",
-      "~1.1.1 | Status": "AssumeBroken" // causes a save crash on certain dates
-    },
-
-    "Everytime Submarine": {
-      "ID": "MustafaDemirel.EverytimeSubmarine",
-      "~1.0.0 | Status": "AssumeBroken" // breaks player saves if their beach bridge is fixed
-    },
-
-    "Always Scroll Map": {
-      "ID": "bcmpinc.AlwaysScrollMap",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "Arcade Pong": {
-      "ID": "Platonymous.ArcadePong",
-      "~1.0.2 | Status": "AssumeBroken" // broke in SMAPI 2.6-beta.16 due to reflection into SMAPI internals
-    },
-
-    "BJS Night Sounds": {
-      "ID": "BunnyJumps.BJSNightSounds",
-      "~1.0.0 | Status": "AssumeBroken" // runtime errors with Harmony 1.2.0.1 in SMAPI 2.8+
-    },
-
-    "Craft Counter": {
-      "ID": "bcmpinc.CraftCounter",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "Fishing Adjust": {
-      "ID": "shuaiz.FishingAdjustMod",
-      "~2.0.1 | Status": "AssumeBroken" // Method not found: 'Void Harmony.HarmonyInstance.Patch(System.Reflection.MethodBase, Harmony.HarmonyMethod, Harmony.HarmonyMethod, Harmony.HarmonyMethod)'
-    },
-
-    "Fishing Automaton": {
-      "ID": "Drynwynn.FishingAutomaton",
-      "~1.1 | Status": "AssumeBroken" // runtime errors with Harmony 1.2.0.1 in SMAPI 2.8+
-    },
-
-    "Fix Animal Tools": {
-      "ID": "bcmpinc.FixAnimalTools",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "Fix Scythe Exp": {
-      "ID": "bcmpinc.FixScytheExp",
-      "~0.3 | Status": "AssumeBroken" // broke in 1.3: Exception from HarmonyInstance "bcmpinc.FixScytheExp" [...] Bad label content in ILGenerator.
-    },
-
-    "Grass Growth": {
-      "ID": "bcmpinc.GrassGrowth",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "More Silo Storage": {
-      "ID": "OrneryWalrus.MoreSiloStorage",
-      "~1.0.1 | Status": "AssumeBroken" // broke in SDV 1.3
-    },
-
-    "Movement Speed": {
-      "ID": "bcmpinc.MovementSpeed",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "No Added Flying Mine Monsters": {
-      "ID": "Drynwynn.NoAddedFlyingMineMonsters",
-      "~1.1 | Status": "AssumeBroken" // runtime errors with Harmony 1.2.0.1 in SMAPI 2.8+
-    },
-
-    "Server Bookmarker": {
-      "ID": "Ilyaki.ServerBookmarker",
-      "~1.0.0 | Status": "AssumeBroken" // broke in Stardew Valley 1.3.29 (runtime errors)
-    },
-
-    "Skill Prestige: Cooking Adapter": {
-      "ID": "Alphablackwolf.CookingSkillPrestigeAdapter",
-      "FormerIDs": "20d6b8a3-b6e7-460b-a6e4-07c2b0cb6c63", // changed circa 1.1
-      "MapRemoteVersions": { "1.2.3": "1.1" } // manifest not updated
-    },
-
-    "Skull Cave Saver": {
-      "ID": "cantorsdust.SkullCaveSaver",
-      "FormerIDs": "8ac06349-26f7-4394-806c-95d48fd35774 | community.SkullCaveSaver", // changed in 1.1 and 1.2.2
-      "1.3-beta | Status": "AssumeBroken" // doesn't work in multiplayer, no longer maintained
-    },
-
-    "Split Screen": {
-      "ID": "Ilyaki.SplitScreen",
-      "~3.0.1 | Status": "AssumeBroken" // broke in SMAPI 2.6-beta.16 due to reflection into SMAPI internals
-    },
-
-    "Stardew Hack": {
-      "ID": "bcmpinc.StardewHack",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "Stephan's Lots of Crops": {
-      "ID": "stephansstardewcrops",
-      "MapRemoteVersions": { "1.41": "1.1" }, // manifest not updated
-      "~1.1    | Status": "AssumeBroken" // broke in SDV 1.3 (overwrites vanilla items)
-    },
-
-    "Summit Reborn": {
-      "ID": "KoihimeNakamura.summitreborn",
-      "FormerIDs": "emissaryofinfinity.summitreborn", // changed in 1.0.2
-      "~1.0.2 | Status": "AssumeBroken" // broke in SDV 1.3 (runtime errors)
-    },
-
-    "Tilled Soil Decay": {
-      "ID": "bcmpinc.TilledSoilDecay",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "Tree Spread": {
-      "ID": "bcmpinc.TreeSpread",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    "Yet Another Harvest With Scythe Mod": {
-      "ID": "bcmpinc.HarvestWithScythe",
-      "~0.6 | Status": "AssumeBroken" // breaks newer versions of bcmpinc mods (per bcmpinc's request)
-    },
-
-    /*********
-    ** Broke circa SDV 1.2
-    *********/
-    "Move Faster": {
-      "ID": "shuaiz.MoveFasterMod",
-      "~1.0.1   | Status": "AssumeBroken" // doesn't do anything as of SDV 1.2.33 (bad Harmony patch?)
-    }
-  }
-}
diff --git a/src/SMAPI.Web/wwwroot/favicon.ico b/src/SMAPI.Web/wwwroot/favicon.ico
deleted file mode 100644
index 587a6e74..00000000
Binary files a/src/SMAPI.Web/wwwroot/favicon.ico and /dev/null differ
diff --git a/src/SMAPI.sln b/src/SMAPI.sln
deleted file mode 100644
index e01a69ba..00000000
--- a/src/SMAPI.sln
+++ /dev/null
@@ -1,151 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2036
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StardewModdingAPI.Mods.ConsoleCommands", "SMAPI.Mods.ConsoleCommands\StardewModdingAPI.Mods.ConsoleCommands.csproj", "{28480467-1A48-46A7-99F8-236D95225359}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StardewModdingAPI", "SMAPI\StardewModdingAPI.csproj", "{F1A573B0-F436-472C-AE29-0B91EA6B9F8F}"
-	ProjectSection(ProjectDependencies) = postProject
-		{80AD8528-AA49-4731-B4A6-C691845815A1} = {80AD8528-AA49-4731-B4A6-C691845815A1}
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".root", ".root", "{86C452BE-D2D8-45B4-B63F-E329EB06CEDA}"
-	ProjectSection(SolutionItems) = preProject
-		..\.editorconfig = ..\.editorconfig
-		..\.gitattributes = ..\.gitattributes
-		..\.gitignore = ..\.gitignore
-		..\LICENSE.txt = ..\LICENSE.txt
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StardewModdingAPI.Installer", "SMAPI.Installer\StardewModdingAPI.Installer.csproj", "{443DDF81-6AAF-420A-A610-3459F37E5575}"
-	ProjectSection(ProjectDependencies) = postProject
-		{E272EB5D-8C57-417E-8E60-C1079D3F53C4} = {E272EB5D-8C57-417E-8E60-C1079D3F53C4}
-		{28480467-1A48-46A7-99F8-236D95225359} = {28480467-1A48-46A7-99F8-236D95225359}
-		{F1A573B0-F436-472C-AE29-0B91EA6B9F8F} = {F1A573B0-F436-472C-AE29-0B91EA6B9F8F}
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StardewModdingAPI.Tests", "SMAPI.Tests\StardewModdingAPI.Tests.csproj", "{36CCB19E-92EB-48C7-9615-98EEFD45109B}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StardewModdingAPI.Web", "SMAPI.Web\StardewModdingAPI.Web.csproj", "{A308F679-51A3-4006-92D5-BAEC7EBD01A1}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Internal", "Internal", "{82D22ED7-A0A7-4D64-8E92-4B6A5E74ED11}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{EB35A917-67B9-4EFA-8DFC-4FB49B3949BB}"
-	ProjectSection(SolutionItems) = preProject
-		..\docs\mod-build-config.md = ..\docs\mod-build-config.md
-		..\docs\README.md = ..\docs\README.md
-		..\docs\release-notes.md = ..\docs\release-notes.md
-		..\docs\technical-docs.md = ..\docs\technical-docs.md
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "build", "build", "{09CF91E5-5BAB-4650-A200-E5EA9A633046}"
-	ProjectSection(SolutionItems) = preProject
-		..\build\common.targets = ..\build\common.targets
-		..\build\GlobalAssemblyInfo.cs = ..\build\GlobalAssemblyInfo.cs
-		..\build\prepare-install-package.targets = ..\build\prepare-install-package.targets
-		..\build\prepare-nuget-package.targets = ..\build\prepare-nuget-package.targets
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StardewModdingAPI.ModBuildConfig", "SMAPI.ModBuildConfig\StardewModdingAPI.ModBuildConfig.csproj", "{EA4F1E80-743F-4A1D-9757-AE66904A196A}"
-	ProjectSection(ProjectDependencies) = postProject
-		{80AD8528-AA49-4731-B4A6-C691845815A1} = {80AD8528-AA49-4731-B4A6-C691845815A1}
-	EndProjectSection
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StardewModdingAPI.ModBuildConfig.Analyzer", "SMAPI.ModBuildConfig.Analyzer\StardewModdingAPI.ModBuildConfig.Analyzer.csproj", "{80AD8528-AA49-4731-B4A6-C691845815A1}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SMAPI.ModBuildConfig.Analyzer.Tests", "SMAPI.ModBuildConfig.Analyzer.Tests\SMAPI.ModBuildConfig.Analyzer.Tests.csproj", "{0CF97929-B0D0-4D73-B7BF-4FF7191035F9}"
-EndProject
-Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "StardewModdingAPI.Internal", "SMAPI.Internal\StardewModdingAPI.Internal.shproj", "{85208F8D-6FD1-4531-BE05-7142490F59FE}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StardewModdingAPI.Mods.SaveBackup", "SMAPI.Mods.SaveBackup\StardewModdingAPI.Mods.SaveBackup.csproj", "{E272EB5D-8C57-417E-8E60-C1079D3F53C4}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StardewModdingAPI.Toolkit", "StardewModdingAPI.Toolkit\StardewModdingAPI.Toolkit.csproj", "{EA5CFD2E-9453-4D29-B80F-8E0EA23F4AC6}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StardewModdingAPI.Toolkit.CoreInterfaces", "StardewModdingAPI.Toolkit.CoreInterfaces\StardewModdingAPI.Toolkit.CoreInterfaces.csproj", "{D5CFD923-37F1-4BC3-9BE8-E506E202AC28}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{4B1CEB70-F756-4A57-AAE8-8CD78C475F25}"
-	ProjectSection(SolutionItems) = preProject
-		..\.github\CONTRIBUTING.md = ..\.github\CONTRIBUTING.md
-		..\.github\SUPPORT.md = ..\.github\SUPPORT.md
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ISSUE_TEMPLATE", "ISSUE_TEMPLATE", "{F4453AB6-D7D6-447F-A973-956CC777968F}"
-	ProjectSection(SolutionItems) = preProject
-		..\.github\ISSUE_TEMPLATE\bug_report.md = ..\.github\ISSUE_TEMPLATE\bug_report.md
-		..\.github\ISSUE_TEMPLATE\feature_request.md = ..\.github\ISSUE_TEMPLATE\feature_request.md
-		..\.github\ISSUE_TEMPLATE\general.md = ..\.github\ISSUE_TEMPLATE\general.md
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SharedMSBuildProjectFiles) = preSolution
-		SMAPI.Internal\SMAPI.Internal.projitems*{443ddf81-6aaf-420a-a610-3459f37e5575}*SharedItemsImports = 4
-		SMAPI.Internal\SMAPI.Internal.projitems*{85208f8d-6fd1-4531-be05-7142490f59fe}*SharedItemsImports = 13
-		SMAPI.Internal\SMAPI.Internal.projitems*{ea4f1e80-743f-4a1d-9757-ae66904a196a}*SharedItemsImports = 4
-		SMAPI.Internal\SMAPI.Internal.projitems*{f1a573b0-f436-472c-ae29-0b91ea6b9f8f}*SharedItemsImports = 4
-	EndGlobalSection
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{28480467-1A48-46A7-99F8-236D95225359}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{28480467-1A48-46A7-99F8-236D95225359}.Debug|Any CPU.Build.0 = Debug|x86
-		{28480467-1A48-46A7-99F8-236D95225359}.Release|Any CPU.ActiveCfg = Release|x86
-		{28480467-1A48-46A7-99F8-236D95225359}.Release|Any CPU.Build.0 = Release|x86
-		{F1A573B0-F436-472C-AE29-0B91EA6B9F8F}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{F1A573B0-F436-472C-AE29-0B91EA6B9F8F}.Debug|Any CPU.Build.0 = Debug|x86
-		{F1A573B0-F436-472C-AE29-0B91EA6B9F8F}.Release|Any CPU.ActiveCfg = Release|x86
-		{F1A573B0-F436-472C-AE29-0B91EA6B9F8F}.Release|Any CPU.Build.0 = Release|x86
-		{443DDF81-6AAF-420A-A610-3459F37E5575}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{443DDF81-6AAF-420A-A610-3459F37E5575}.Debug|Any CPU.Build.0 = Debug|x86
-		{443DDF81-6AAF-420A-A610-3459F37E5575}.Release|Any CPU.ActiveCfg = Release|x86
-		{443DDF81-6AAF-420A-A610-3459F37E5575}.Release|Any CPU.Build.0 = Release|x86
-		{36CCB19E-92EB-48C7-9615-98EEFD45109B}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{36CCB19E-92EB-48C7-9615-98EEFD45109B}.Debug|Any CPU.Build.0 = Debug|x86
-		{36CCB19E-92EB-48C7-9615-98EEFD45109B}.Release|Any CPU.ActiveCfg = Release|x86
-		{36CCB19E-92EB-48C7-9615-98EEFD45109B}.Release|Any CPU.Build.0 = Release|x86
-		{A308F679-51A3-4006-92D5-BAEC7EBD01A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A308F679-51A3-4006-92D5-BAEC7EBD01A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A308F679-51A3-4006-92D5-BAEC7EBD01A1}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A308F679-51A3-4006-92D5-BAEC7EBD01A1}.Release|Any CPU.Build.0 = Release|Any CPU
-		{EA4F1E80-743F-4A1D-9757-AE66904A196A}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{EA4F1E80-743F-4A1D-9757-AE66904A196A}.Debug|Any CPU.Build.0 = Debug|x86
-		{EA4F1E80-743F-4A1D-9757-AE66904A196A}.Release|Any CPU.ActiveCfg = Release|x86
-		{EA4F1E80-743F-4A1D-9757-AE66904A196A}.Release|Any CPU.Build.0 = Release|x86
-		{80AD8528-AA49-4731-B4A6-C691845815A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{80AD8528-AA49-4731-B4A6-C691845815A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{80AD8528-AA49-4731-B4A6-C691845815A1}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{80AD8528-AA49-4731-B4A6-C691845815A1}.Release|Any CPU.Build.0 = Release|Any CPU
-		{0CF97929-B0D0-4D73-B7BF-4FF7191035F9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{0CF97929-B0D0-4D73-B7BF-4FF7191035F9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{0CF97929-B0D0-4D73-B7BF-4FF7191035F9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{0CF97929-B0D0-4D73-B7BF-4FF7191035F9}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E272EB5D-8C57-417E-8E60-C1079D3F53C4}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{E272EB5D-8C57-417E-8E60-C1079D3F53C4}.Debug|Any CPU.Build.0 = Debug|x86
-		{E272EB5D-8C57-417E-8E60-C1079D3F53C4}.Release|Any CPU.ActiveCfg = Release|x86
-		{E272EB5D-8C57-417E-8E60-C1079D3F53C4}.Release|Any CPU.Build.0 = Release|x86
-		{EA5CFD2E-9453-4D29-B80F-8E0EA23F4AC6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{EA5CFD2E-9453-4D29-B80F-8E0EA23F4AC6}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{EA5CFD2E-9453-4D29-B80F-8E0EA23F4AC6}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{EA5CFD2E-9453-4D29-B80F-8E0EA23F4AC6}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D5CFD923-37F1-4BC3-9BE8-E506E202AC28}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D5CFD923-37F1-4BC3-9BE8-E506E202AC28}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D5CFD923-37F1-4BC3-9BE8-E506E202AC28}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D5CFD923-37F1-4BC3-9BE8-E506E202AC28}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{36CCB19E-92EB-48C7-9615-98EEFD45109B} = {82D22ED7-A0A7-4D64-8E92-4B6A5E74ED11}
-		{EB35A917-67B9-4EFA-8DFC-4FB49B3949BB} = {86C452BE-D2D8-45B4-B63F-E329EB06CEDA}
-		{09CF91E5-5BAB-4650-A200-E5EA9A633046} = {86C452BE-D2D8-45B4-B63F-E329EB06CEDA}
-		{0CF97929-B0D0-4D73-B7BF-4FF7191035F9} = {82D22ED7-A0A7-4D64-8E92-4B6A5E74ED11}
-		{4B1CEB70-F756-4A57-AAE8-8CD78C475F25} = {86C452BE-D2D8-45B4-B63F-E329EB06CEDA}
-		{F4453AB6-D7D6-447F-A973-956CC777968F} = {4B1CEB70-F756-4A57-AAE8-8CD78C475F25}
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {70143042-A862-47A8-A677-7C819DDC90DC}
-	EndGlobalSection
-EndGlobal
diff --git a/src/SMAPI.sln.DotSettings b/src/SMAPI.sln.DotSettings
deleted file mode 100644
index 5f67fd9e..00000000
--- a/src/SMAPI.sln.DotSettings
+++ /dev/null
@@ -1,26 +0,0 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=InheritdocConsiderUsage/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=MemberCanBeMadeStatic_002ELocal/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantNameQualifier/@EntryIndexedValue">HINT</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantTypeArgumentsOfMethod/@EntryIndexedValue">HINT</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/StaticQualifier/STATIC_MEMBERS_QUALIFY_MEMBERS/@EntryValue">Field, Property, Event, Method</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ThisQualifier/INSTANCE_MEMBERS_QUALIFY_MEMBERS/@EntryValue">Field, Property, Event, Method</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/LINE_FEED_AT_FILE_END/@EntryValue">True</s:Boolean>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSORHOLDER_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_LINES/@EntryValue">False</s:Boolean>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVarWhenEvident</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseExplicitType</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=ID/@EntryIndexedValue">ID</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpRenamePlacementToArrangementMigration/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpUseContinuousIndentInsideBracesMigration/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
-</wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/src/SMAPI/Constants.cs b/src/SMAPI/Constants.cs
index bacfa845..aa2440c2 100644
--- a/src/SMAPI/Constants.cs
+++ b/src/SMAPI/Constants.cs
@@ -32,16 +32,16 @@ namespace StardewModdingAPI
         public static GamePlatform TargetPlatform => (GamePlatform)Constants.Platform;
 
         /// <summary>The path to the game folder.</summary>
-        public static string ExecutionPath { get; } = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        public static string ExecutionPath { get; } = "/sdcard/SMDroid";
 
         /// <summary>The directory path containing Stardew Valley's app data.</summary>
-        public static string DataPath { get; } = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "StardewValley");
+        public static string DataPath { get; } = Path.Combine("/sdcard", "SMDroid");
 
         /// <summary>The directory path in which error logs should be stored.</summary>
         public static string LogDir { get; } = Path.Combine(Constants.DataPath, "ErrorLogs");
 
         /// <summary>The directory path where all saves are stored.</summary>
-        public static string SavesPath { get; } = Path.Combine(Constants.DataPath, "Saves");
+        public static string SavesPath { get; } = Path.Combine("/sdcard", "StardewValley");
 
         /// <summary>The name of the current save folder (if save info is available, regardless of whether the save file exists yet).</summary>
         public static string SaveFolderName => Constants.GetSaveFolderName();
@@ -56,7 +56,7 @@ namespace StardewModdingAPI
         internal const string HomePageUrl = "https://smapi.io";
 
         /// <summary>The absolute path to the folder containing SMAPI's internal files.</summary>
-        internal static readonly string InternalFilesPath = Program.DllSearchPath;
+        internal static readonly string InternalFilesPath = "/sdcard/SMDroid/smapi-internal";
 
         /// <summary>The file path for the SMAPI configuration file.</summary>
         internal static string ApiConfigPath => Path.Combine(Constants.InternalFilesPath, "StardewModdingAPI.config.json");
@@ -89,13 +89,13 @@ namespace StardewModdingAPI
         internal static string ModsPath { get; set; }
 
         /// <summary>The game's current semantic version.</summary>
-        internal static ISemanticVersion GameVersion { get; } = new GameVersion(Game1.version);
+        internal static ISemanticVersion GameVersion { get; } = new GameVersion("1.3.36");
 
         /// <summary>The target game platform.</summary>
-        internal static Platform Platform { get; } = EnvironmentUtility.DetectPlatform();
+        internal static Platform Platform { get; } = Platform.Android;
 
         /// <summary>The game's assembly name.</summary>
-        internal static string GameAssemblyName => Constants.Platform == Platform.Windows ? "Stardew Valley" : "StardewValley";
+        internal static string GameAssemblyName = "StardewValley";
 
 
         /*********
@@ -163,7 +163,18 @@ namespace StardewModdingAPI
                         typeof(Microsoft.Xna.Framework.Graphics.SpriteBatch).Assembly
                     };
                     break;
-
+                case Platform.Android:
+                    removeAssemblyReferences = new[]
+                    {
+                        "StardewValley",
+                        "MonoGame.Framework"
+                    };
+                    targetAssemblies = new[]
+                    {
+                        typeof(StardewValley.Game1).Assembly,
+                        typeof(Microsoft.Xna.Framework.Vector2).Assembly
+                    };
+                    break;
                 default:
                     throw new InvalidOperationException($"Unknown target platform '{targetPlatform}'.");
             }
diff --git a/src/SMAPI/Framework/Content/ContentCache.cs b/src/SMAPI/Framework/Content/ContentCache.cs
index 55a96ed2..3d2f679c 100644
--- a/src/SMAPI/Framework/Content/ContentCache.cs
+++ b/src/SMAPI/Framework/Content/ContentCache.cs
@@ -53,13 +53,13 @@ namespace StardewModdingAPI.Framework.Content
             this.Cache = reflection.GetField<Dictionary<string, object>>(contentManager, "loadedAssets").GetValue();
 
             // get key normalisation logic
-            if (Constants.Platform == Platform.Windows)
-            {
-                IReflectedMethod method = reflection.GetMethod(typeof(TitleContainer), "GetCleanPath");
-                this.NormaliseAssetNameForPlatform = path => method.Invoke<string>(path);
-            }
-            else
-                this.NormaliseAssetNameForPlatform = key => key.Replace('\\', '/'); // based on MonoGame's ContentManager.Load<T> logic
+            //if (Constants.Platform == Platform.Windows)
+            //{
+            //    IReflectedMethod method = reflection.GetMethod(typeof(TitleContainer), "GetCleanPath");
+            //    this.NormaliseAssetNameForPlatform = path => method.Invoke<string>(path);
+            //}
+            //else
+            this.NormaliseAssetNameForPlatform = key => key.Replace('\\', '/'); // based on MonoGame's ContentManager.Load<T> logic
         }
 
         /****
diff --git a/src/SMAPI/Framework/ContentCoordinator.cs b/src/SMAPI/Framework/ContentCoordinator.cs
index caeb7ee9..ec8a42df 100644
--- a/src/SMAPI/Framework/ContentCoordinator.cs
+++ b/src/SMAPI/Framework/ContentCoordinator.cs
@@ -82,7 +82,7 @@ namespace StardewModdingAPI.Framework
             this.Reflection = reflection;
             this.JsonHelper = jsonHelper;
             this.OnLoadingFirstAsset = onLoadingFirstAsset;
-            this.FullRootDirectory = Path.Combine(Constants.ExecutionPath, rootDirectory);
+            this.FullRootDirectory = rootDirectory;
             this.ContentManagers.Add(
                 this.MainContentManager = new GameContentManager("Game1.content", serviceProvider, rootDirectory, currentCulture, this, monitor, reflection, this.OnDisposing, onLoadingFirstAsset)
             );
diff --git a/src/SMAPI/Framework/IModMetadata.cs b/src/SMAPI/Framework/IModMetadata.cs
index 32870c2a..ac34404b 100644
--- a/src/SMAPI/Framework/IModMetadata.cs
+++ b/src/SMAPI/Framework/IModMetadata.cs
@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using StardewModdingAPI.Framework.ModHelpers;
 using StardewModdingAPI.Framework.ModLoading;
-using StardewModdingAPI.Toolkit.Framework.Clients.WebApi;
+//using StardewModdingAPI.Toolkit.Framework.Clients.WebApi;
 using StardewModdingAPI.Toolkit.Framework.ModData;
 using StardewModdingAPI.Toolkit.Framework.UpdateData;
 
@@ -52,8 +52,8 @@ namespace StardewModdingAPI.Framework
         /// <summary>The mod-provided API (if any).</summary>
         object Api { get; }
 
-        /// <summary>The update-check metadata for this mod (if any).</summary>
-        ModEntryModel UpdateCheckData { get; }
+        ///// <summary>The update-check metadata for this mod (if any).</summary>
+        //ModEntryModel UpdateCheckData { get; }
 
 
         /*********
@@ -84,9 +84,9 @@ namespace StardewModdingAPI.Framework
         /// <param name="api">The mod-provided API.</param>
         IModMetadata SetApi(object api);
 
-        /// <summary>Set the update-check metadata for this mod.</summary>
-        /// <param name="data">The update-check metadata.</param>
-        IModMetadata SetUpdateData(ModEntryModel data);
+        ///// <summary>Set the update-check metadata for this mod.</summary>
+        ///// <param name="data">The update-check metadata.</param>
+        //IModMetadata SetUpdateData(ModEntryModel data);
 
         /// <summary>Whether the mod manifest was loaded (regardless of whether the mod itself was loaded).</summary>
         bool HasManifest();
diff --git a/src/SMAPI/Framework/ModHelpers/ModHelper.cs b/src/SMAPI/Framework/ModHelpers/ModHelper.cs
index 86e8eb28..ec2912c0 100644
--- a/src/SMAPI/Framework/ModHelpers/ModHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/ModHelper.cs
@@ -40,7 +40,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         public ICommandHelper ConsoleCommands { get; }
 
         /// <summary>Provides multiplayer utilities.</summary>
-        public IMultiplayerHelper Multiplayer { get; }
+        //public IMultiplayerHelper Multiplayer { get; }
 
         /// <summary>An API for reading translations stored in the mod's <c>i18n</c> folder, with one file per locale (like <c>en.json</c>) containing a flat key => value structure. Translations are fetched with locale fallback, so missing translations are filled in from broader locales (like <c>pt-BR.json</c> &lt; <c>pt.json</c> &lt; <c>default.json</c>).</summary>
         public ITranslationHelper Translation { get; }
@@ -64,7 +64,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <param name="translationHelper">An API for reading translations stored in the mod's <c>i18n</c> folder.</param>
         /// <exception cref="ArgumentNullException">An argument is null or empty.</exception>
         /// <exception cref="InvalidOperationException">The <paramref name="modDirectory"/> path does not exist on disk.</exception>
-        public ModHelper(string modID, string modDirectory, SInputState inputState, IModEvents events, IContentHelper contentHelper, IContentPackHelper contentPackHelper, ICommandHelper commandHelper, IDataHelper dataHelper, IModRegistry modRegistry, IReflectionHelper reflectionHelper, IMultiplayerHelper multiplayer, ITranslationHelper translationHelper)
+        public ModHelper(string modID, string modDirectory, SInputState inputState, IModEvents events, IContentHelper contentHelper, IContentPackHelper contentPackHelper, ICommandHelper commandHelper, IDataHelper dataHelper, IModRegistry modRegistry, IReflectionHelper reflectionHelper, ITranslationHelper translationHelper)
             : base(modID)
         {
             // validate directory
@@ -82,7 +82,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
             this.ModRegistry = modRegistry ?? throw new ArgumentNullException(nameof(modRegistry));
             this.ConsoleCommands = commandHelper ?? throw new ArgumentNullException(nameof(commandHelper));
             this.Reflection = reflectionHelper ?? throw new ArgumentNullException(nameof(reflectionHelper));
-            this.Multiplayer = multiplayer ?? throw new ArgumentNullException(nameof(multiplayer));
+            //this.Multiplayer = multiplayer ?? throw new ArgumentNullException(nameof(multiplayer));
             this.Translation = translationHelper ?? throw new ArgumentNullException(nameof(translationHelper));
             this.Events = events;
         }
diff --git a/src/SMAPI/Framework/ModHelpers/MultiplayerHelper.cs b/src/SMAPI/Framework/ModHelpers/MultiplayerHelper.cs
deleted file mode 100644
index c62dd121..00000000
--- a/src/SMAPI/Framework/ModHelpers/MultiplayerHelper.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-using System;
-using System.Collections.Generic;
-using StardewModdingAPI.Framework.Networking;
-using StardewValley;
-
-namespace StardewModdingAPI.Framework.ModHelpers
-{
-    /// <summary>Provides multiplayer utilities.</summary>
-    internal class MultiplayerHelper : BaseHelper, IMultiplayerHelper
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>SMAPI's core multiplayer utility.</summary>
-        private readonly SMultiplayer Multiplayer;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="modID">The unique ID of the relevant mod.</param>
-        /// <param name="multiplayer">SMAPI's core multiplayer utility.</param>
-        public MultiplayerHelper(string modID, SMultiplayer multiplayer)
-            : base(modID)
-        {
-            this.Multiplayer = multiplayer;
-        }
-
-        /// <summary>Get a new multiplayer ID.</summary>
-        public long GetNewID()
-        {
-            return this.Multiplayer.getNewID();
-        }
-
-        /// <summary>Get the locations which are being actively synced from the host.</summary>
-        public IEnumerable<GameLocation> GetActiveLocations()
-        {
-            return this.Multiplayer.activeLocations();
-        }
-
-        /// <summary>Get a connected player.</summary>
-        /// <param name="id">The player's unique ID.</param>
-        /// <returns>Returns the connected player, or <c>null</c> if no such player is connected.</returns>
-        public IMultiplayerPeer GetConnectedPlayer(long id)
-        {
-            return this.Multiplayer.Peers.TryGetValue(id, out MultiplayerPeer peer)
-                ? peer
-                : null;
-        }
-
-        /// <summary>Get all connected players.</summary>
-        public IEnumerable<IMultiplayerPeer> GetConnectedPlayers()
-        {
-            return this.Multiplayer.Peers.Values;
-        }
-
-        /// <summary>Send a message to mods installed by connected players.</summary>
-        /// <typeparam name="TMessage">The data type. This can be a class with a default constructor, or a value type.</typeparam>
-        /// <param name="message">The data to send over the network.</param>
-        /// <param name="messageType">A message type which receiving mods can use to decide whether it's the one they want to handle, like <c>SetPlayerLocation</c>. This doesn't need to be globally unique, since mods should check the originating mod ID.</param>
-        /// <param name="modIDs">The mod IDs which should receive the message on the destination computers, or <c>null</c> for all mods. Specifying mod IDs is recommended to improve performance, unless it's a general-purpose broadcast.</param>
-        /// <param name="playerIDs">The <see cref="Farmer.UniqueMultiplayerID" /> values for the players who should receive the message, or <c>null</c> for all players. If you don't need to broadcast to all players, specifying player IDs is recommended to reduce latency.</param>
-        /// <exception cref="ArgumentNullException">The <paramref name="message"/> or <paramref name="messageType" /> is null.</exception>
-        public void SendMessage<TMessage>(TMessage message, string messageType, string[] modIDs = null, long[] playerIDs = null)
-        {
-            this.Multiplayer.BroadcastModMessage(
-                message: message,
-                messageType: messageType,
-                fromModID: this.ModID,
-                toModIDs: modIDs,
-                toPlayerIDs: playerIDs
-            );
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs b/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
index ca171ae1..8d8b581d 100644
--- a/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
+++ b/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
@@ -110,7 +110,7 @@ namespace StardewModdingAPI.Framework.ModLoading
                 // detect broken assembly reference
                 foreach (AssemblyNameReference reference in assembly.Definition.MainModule.AssemblyReferences)
                 {
-                    if (!reference.Name.StartsWith("System.") && !this.IsAssemblyLoaded(reference))
+                    if (!reference.Name.Equals("System") && !reference.Name.StartsWith("System.") && !this.IsAssemblyLoaded(reference))
                     {
                         this.Monitor.LogOnce(loggedMessages, $"      Broken code in {assembly.File.Name}: reference to missing assembly '{reference.FullName}'.");
                         if (!assumeCompatible)
diff --git a/src/SMAPI/Framework/ModLoading/ModMetadata.cs b/src/SMAPI/Framework/ModLoading/ModMetadata.cs
index 39f2f482..e9d88822 100644
--- a/src/SMAPI/Framework/ModLoading/ModMetadata.cs
+++ b/src/SMAPI/Framework/ModLoading/ModMetadata.cs
@@ -2,7 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using StardewModdingAPI.Framework.ModHelpers;
-using StardewModdingAPI.Toolkit.Framework.Clients.WebApi;
+//using StardewModdingAPI.Toolkit.Framework.Clients.WebApi;
 using StardewModdingAPI.Toolkit.Framework.ModData;
 using StardewModdingAPI.Toolkit.Framework.UpdateData;
 
@@ -56,8 +56,8 @@ namespace StardewModdingAPI.Framework.ModLoading
         /// <summary>The mod-provided API (if any).</summary>
         public object Api { get; private set; }
 
-        /// <summary>The update-check metadata for this mod (if any).</summary>
-        public ModEntryModel UpdateCheckData { get; private set; }
+        ///// <summary>The update-check metadata for this mod (if any).</summary>
+        //public ModEntryModel UpdateCheckData { get; private set; }
 
         /// <summary>Whether the mod is a content pack.</summary>
         public bool IsContentPack => this.Manifest?.ContentPackFor != null;
@@ -139,13 +139,13 @@ namespace StardewModdingAPI.Framework.ModLoading
             return this;
         }
 
-        /// <summary>Set the update-check metadata for this mod.</summary>
-        /// <param name="data">The update-check metadata.</param>
-        public IModMetadata SetUpdateData(ModEntryModel data)
-        {
-            this.UpdateCheckData = data;
-            return this;
-        }
+        ///// <summary>Set the update-check metadata for this mod.</summary>
+        ///// <param name="data">The update-check metadata.</param>
+        //public IModMetadata SetUpdateData(ModEntryModel data)
+        //{
+        //    this.UpdateCheckData = data;
+        //    return this;
+        //}
 
         /// <summary>Whether the mod manifest was loaded (regardless of whether the mod itself was loaded).</summary>
         public bool HasManifest()
diff --git a/src/SMAPI/Framework/ModLoading/PlatformAssemblyMap.cs b/src/SMAPI/Framework/ModLoading/PlatformAssemblyMap.cs
index 01460dce..2db0b4b6 100644
--- a/src/SMAPI/Framework/ModLoading/PlatformAssemblyMap.cs
+++ b/src/SMAPI/Framework/ModLoading/PlatformAssemblyMap.cs
@@ -51,7 +51,7 @@ namespace StardewModdingAPI.Framework.ModLoading
             // cache assembly metadata
             this.Targets = targetAssemblies;
             this.TargetReferences = this.Targets.ToDictionary(assembly => assembly, assembly => AssemblyNameReference.Parse(assembly.FullName));
-            this.TargetModules = this.Targets.ToDictionary(assembly => assembly, assembly => ModuleDefinition.ReadModule(assembly.Modules.Single().FullyQualifiedName, new ReaderParameters { InMemory = true }));
+            this.TargetModules = this.Targets.ToDictionary(assembly => assembly, assembly => ModuleDefinition.ReadModule(System.IO.Path.Combine(Constants.ExecutionPath, assembly.Modules.Single().FullyQualifiedName), new ReaderParameters { InMemory = true }));
         }
 
         /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
diff --git a/src/SMAPI/Framework/Networking/SGalaxyNetClient.cs b/src/SMAPI/Framework/Networking/SGalaxyNetClient.cs
deleted file mode 100644
index 01095c66..00000000
--- a/src/SMAPI/Framework/Networking/SGalaxyNetClient.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using System;
-using Galaxy.Api;
-using StardewValley.Network;
-using StardewValley.SDKs;
-
-namespace StardewModdingAPI.Framework.Networking
-{
-    /// <summary>A multiplayer client used to connect to a hosted server. This is an implementation of <see cref="GalaxyNetClient"/> with callbacks for SMAPI functionality.</summary>
-    internal class SGalaxyNetClient : GalaxyNetClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>A callback to raise when receiving a message. This receives the incoming message, a method to send an arbitrary message, and a callback to run the default logic.</summary>
-        private readonly Action<IncomingMessage, Action<OutgoingMessage>, Action> OnProcessingMessage;
-
-        /// <summary>A callback to raise when sending a message. This receives the outgoing message, a method to send an arbitrary message, and a callback to resume the default logic.</summary>
-        private readonly Action<OutgoingMessage, Action<OutgoingMessage>, Action> OnSendingMessage;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="address">The remote address being connected.</param>
-        /// <param name="onProcessingMessage">A callback to raise when receiving a message. This receives the incoming message, a method to send an arbitrary message, and a callback to run the default logic.</param>
-        /// <param name="onSendingMessage">A callback to raise when sending a message. This receives the outgoing message, a method to send an arbitrary message, and a callback to resume the default logic.</param>
-        public SGalaxyNetClient(GalaxyID address, Action<IncomingMessage, Action<OutgoingMessage>, Action> onProcessingMessage, Action<OutgoingMessage, Action<OutgoingMessage>, Action> onSendingMessage)
-            : base(address)
-        {
-            this.OnProcessingMessage = onProcessingMessage;
-            this.OnSendingMessage = onSendingMessage;
-        }
-
-        /// <summary>Send a message to the connected peer.</summary>
-        public override void sendMessage(OutgoingMessage message)
-        {
-            this.OnSendingMessage(message, base.sendMessage, () => base.sendMessage(message));
-        }
-
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Process an incoming network message.</summary>
-        /// <param name="message">The message to process.</param>
-        protected override void processIncomingMessage(IncomingMessage message)
-        {
-            this.OnProcessingMessage(message, base.sendMessage, () => base.processIncomingMessage(message));
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/Networking/SGalaxyNetServer.cs b/src/SMAPI/Framework/Networking/SGalaxyNetServer.cs
deleted file mode 100644
index bb67f70e..00000000
--- a/src/SMAPI/Framework/Networking/SGalaxyNetServer.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using Galaxy.Api;
-using StardewValley.Network;
-using StardewValley.SDKs;
-
-namespace StardewModdingAPI.Framework.Networking
-{
-    /// <summary>A multiplayer server used to connect to an incoming player. This is an implementation of <see cref="LidgrenServer"/> that adds support for SMAPI's metadata context exchange.</summary>
-    internal class SGalaxyNetServer : GalaxyNetServer
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>A callback to raise when receiving a message. This receives the incoming message, a method to send a message, and a callback to run the default logic.</summary>
-        private readonly Action<IncomingMessage, Action<OutgoingMessage>, Action> OnProcessingMessage;
-
-        /// <summary>SMAPI's implementation of the game's core multiplayer logic.</summary>
-        private readonly SMultiplayer Multiplayer;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="gameServer">The underlying game server.</param>
-        /// <param name="multiplayer">SMAPI's implementation of the game's core multiplayer logic.</param>
-        /// <param name="onProcessingMessage">A callback to raise when receiving a message. This receives the incoming message, a method to send a message, and a callback to run the default logic.</param>
-        public SGalaxyNetServer(IGameServer gameServer, SMultiplayer multiplayer, Action<IncomingMessage, Action<OutgoingMessage>, Action> onProcessingMessage)
-            : base(gameServer)
-        {
-            this.Multiplayer = multiplayer;
-            this.OnProcessingMessage = onProcessingMessage;
-        }
-
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Read and process a message from the client.</summary>
-        /// <param name="peer">The Galaxy peer ID.</param>
-        /// <param name="messageStream">The data to process.</param>
-        /// <remarks>This reimplements <see cref="GalaxyNetServer.onReceiveMessage"/>, but adds a callback to <see cref="OnProcessingMessage"/>.</remarks>
-        [SuppressMessage("ReSharper", "AccessToDisposedClosure", Justification = "The callback is invoked synchronously.")]
-        protected override void onReceiveMessage(GalaxyID peer, Stream messageStream)
-        {
-            using (IncomingMessage message = new IncomingMessage())
-            using (BinaryReader reader = new BinaryReader(messageStream))
-            {
-                message.Read(reader);
-                ulong peerID = peer.ToUint64(); // note: GalaxyID instances get reused, so need to store the underlying ID instead
-                this.OnProcessingMessage(message, outgoing => this.SendMessageToPeerID(peerID, outgoing), () =>
-                {
-                    if (this.peers.ContainsLeft(message.FarmerID) && (long)this.peers[message.FarmerID] == (long)peerID)
-                        this.gameServer.processIncomingMessage(message);
-                    else if (message.MessageType == StardewValley.Multiplayer.playerIntroduction)
-                    {
-                        NetFarmerRoot farmer = this.Multiplayer.readFarmer(message.Reader);
-                        GalaxyID capturedPeer = new GalaxyID(peerID);
-                        this.gameServer.checkFarmhandRequest(Convert.ToString(peerID), farmer, msg => this.sendMessage(capturedPeer, msg), () => this.peers[farmer.Value.UniqueMultiplayerID] = capturedPeer.ToUint64());
-                    }
-                });
-            }
-        }
-
-        /// <summary>Send a message to a remote peer.</summary>
-        /// <param name="peerID">The unique Galaxy ID, derived from <see cref="GalaxyID.ToUint64"/>.</param>
-        /// <param name="message">The message to send.</param>
-        private void SendMessageToPeerID(ulong peerID, OutgoingMessage message)
-        {
-            this.sendMessage(new GalaxyID(peerID), message);
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/Networking/SLidgrenClient.cs b/src/SMAPI/Framework/Networking/SLidgrenClient.cs
deleted file mode 100644
index 39876744..00000000
--- a/src/SMAPI/Framework/Networking/SLidgrenClient.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-using System;
-using StardewValley.Network;
-
-namespace StardewModdingAPI.Framework.Networking
-{
-    /// <summary>A multiplayer client used to connect to a hosted server. This is an implementation of <see cref="LidgrenClient"/> with callbacks for SMAPI functionality.</summary>
-    internal class SLidgrenClient : LidgrenClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>A callback to raise when receiving a message. This receives the incoming message, a method to send an arbitrary message, and a callback to run the default logic.</summary>
-        private readonly Action<IncomingMessage, Action<OutgoingMessage>, Action> OnProcessingMessage;
-
-        /// <summary>A callback to raise when sending a message. This receives the outgoing message, a method to send an arbitrary message, and a callback to resume the default logic.</summary>
-        private readonly Action<OutgoingMessage, Action<OutgoingMessage>, Action> OnSendingMessage;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="address">The remote address being connected.</param>
-        /// <param name="onProcessingMessage">A callback to raise when receiving a message. This receives the incoming message, a method to send an arbitrary message, and a callback to run the default logic.</param>
-        /// <param name="onSendingMessage">A callback to raise when sending a message. This receives the outgoing message, a method to send an arbitrary message, and a callback to resume the default logic.</param>
-        public SLidgrenClient(string address, Action<IncomingMessage, Action<OutgoingMessage>, Action> onProcessingMessage, Action<OutgoingMessage, Action<OutgoingMessage>, Action> onSendingMessage)
-            : base(address)
-        {
-            this.OnProcessingMessage = onProcessingMessage;
-            this.OnSendingMessage = onSendingMessage;
-        }
-
-        /// <summary>Send a message to the connected peer.</summary>
-        public override void sendMessage(OutgoingMessage message)
-        {
-            this.OnSendingMessage(message, base.sendMessage, () => base.sendMessage(message));
-        }
-
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Process an incoming network message.</summary>
-        /// <param name="message">The message to process.</param>
-        protected override void processIncomingMessage(IncomingMessage message)
-        {
-            this.OnProcessingMessage(message, base.sendMessage, () => base.processIncomingMessage(message));
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/Networking/SLidgrenServer.cs b/src/SMAPI/Framework/Networking/SLidgrenServer.cs
deleted file mode 100644
index 1bce47fe..00000000
--- a/src/SMAPI/Framework/Networking/SLidgrenServer.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using Lidgren.Network;
-using StardewValley.Network;
-
-namespace StardewModdingAPI.Framework.Networking
-{
-    /// <summary>A multiplayer server used to connect to an incoming player. This is an implementation of <see cref="LidgrenServer"/> that adds support for SMAPI's metadata context exchange.</summary>
-    internal class SLidgrenServer : LidgrenServer
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>SMAPI's implementation of the game's core multiplayer logic.</summary>
-        private readonly SMultiplayer Multiplayer;
-
-        /// <summary>A callback to raise when receiving a message. This receives the incoming message, a method to send a message, and a callback to run the default logic.</summary>
-        private readonly Action<IncomingMessage, Action<OutgoingMessage>, Action> OnProcessingMessage;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="multiplayer">SMAPI's implementation of the game's core multiplayer logic.</param>
-        /// <param name="gameServer">The underlying game server.</param>
-        /// <param name="onProcessingMessage">A callback to raise when receiving a message. This receives the incoming message, a method to send a message, and a callback to run the default logic.</param>
-        public SLidgrenServer(IGameServer gameServer, SMultiplayer multiplayer, Action<IncomingMessage, Action<OutgoingMessage>, Action> onProcessingMessage)
-            : base(gameServer)
-        {
-            this.Multiplayer = multiplayer;
-            this.OnProcessingMessage = onProcessingMessage;
-        }
-
-        /// <summary>Parse a data message from a client.</summary>
-        /// <param name="rawMessage">The raw network message to parse.</param>
-        [SuppressMessage("ReSharper", "AccessToDisposedClosure", Justification = "The callback is invoked synchronously.")]
-        protected override void parseDataMessageFromClient(NetIncomingMessage rawMessage)
-        {
-            // add hook to call multiplayer core
-            NetConnection peer = rawMessage.SenderConnection;
-            using (IncomingMessage message = new IncomingMessage())
-            using (Stream readStream = new NetBufferReadStream(rawMessage))
-            using (BinaryReader reader = new BinaryReader(readStream))
-            {
-                while (rawMessage.LengthBits - rawMessage.Position >= 8)
-                {
-                    message.Read(reader);
-                    NetConnection connection = rawMessage.SenderConnection; // don't pass rawMessage into context because it gets reused
-                    this.OnProcessingMessage(message, outgoing => this.sendMessage(connection, outgoing), () =>
-                    {
-                        if (this.peers.ContainsLeft(message.FarmerID) && this.peers[message.FarmerID] == peer)
-                            this.gameServer.processIncomingMessage(message);
-                        else if (message.MessageType == StardewValley.Multiplayer.playerIntroduction)
-                        {
-                            NetFarmerRoot farmer = this.Multiplayer.readFarmer(message.Reader);
-                            this.gameServer.checkFarmhandRequest("", farmer, msg => this.sendMessage(peer, msg), () => this.peers[farmer.Value.UniqueMultiplayerID] = peer);
-                        }
-                    });
-                }
-            }
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/Reflection/Reflector.cs b/src/SMAPI/Framework/Reflection/Reflector.cs
index ed1a4381..6747543d 100644
--- a/src/SMAPI/Framework/Reflection/Reflector.cs
+++ b/src/SMAPI/Framework/Reflection/Reflector.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Linq;
 using System.Reflection;
-using System.Runtime.Caching;
+using System.Collections.Generic;
 
 namespace StardewModdingAPI.Framework.Reflection
 {
@@ -13,7 +13,7 @@ namespace StardewModdingAPI.Framework.Reflection
         ** Fields
         *********/
         /// <summary>The cached fields and methods found via reflection.</summary>
-        private readonly MemoryCache Cache = new MemoryCache(typeof(Reflector).FullName);
+        private readonly Dictionary<string, CacheEntry> Cache = new Dictionary<string, CacheEntry>();
 
         /// <summary>The sliding cache expiration time.</summary>
         private readonly TimeSpan SlidingCacheExpiry = TimeSpan.FromMinutes(5);
@@ -258,7 +258,7 @@ namespace StardewModdingAPI.Framework.Reflection
         private TMemberInfo GetCached<TMemberInfo>(string key, Func<TMemberInfo> fetch) where TMemberInfo : MemberInfo
         {
             // get from cache
-            if (this.Cache.Contains(key))
+            if (this.Cache.ContainsKey(key))
             {
                 CacheEntry entry = (CacheEntry)this.Cache[key];
                 return entry.IsValid
@@ -269,7 +269,7 @@ namespace StardewModdingAPI.Framework.Reflection
             // fetch & cache new value
             TMemberInfo result = fetch();
             CacheEntry cacheEntry = new CacheEntry(result != null, result);
-            this.Cache.Add(key, cacheEntry, new CacheItemPolicy { SlidingExpiration = this.SlidingCacheExpiry });
+            this.Cache.Add(key, cacheEntry);
             return result;
         }
     }
diff --git a/src/SMAPI/Framework/SCore.cs b/src/SMAPI/Framework/SCore.cs
index 6a5edbd1..8e6d5f2d 100644
--- a/src/SMAPI/Framework/SCore.cs
+++ b/src/SMAPI/Framework/SCore.cs
@@ -28,7 +28,6 @@ using StardewModdingAPI.Framework.Serialisation;
 using StardewModdingAPI.Internal;
 using StardewModdingAPI.Patches;
 using StardewModdingAPI.Toolkit;
-using StardewModdingAPI.Toolkit.Framework.Clients.WebApi;
 using StardewModdingAPI.Toolkit.Framework.ModData;
 using StardewModdingAPI.Toolkit.Serialisation;
 using StardewModdingAPI.Toolkit.Utilities;
@@ -66,7 +65,7 @@ namespace StardewModdingAPI.Framework
         private readonly SConfig Settings;
 
         /// <summary>The underlying game instance.</summary>
-        private SGame GameInstance;
+        public SGame GameInstance = SGame.instance;
 
         /// <summary>The underlying content manager.</summary>
         private ContentCoordinator ContentCore => this.GameInstance.ContentCore;
@@ -164,53 +163,53 @@ namespace StardewModdingAPI.Framework
             if (modsPath != Constants.DefaultModsPath)
                 this.Monitor.Log("(Using custom --mods-path argument.)", LogLevel.Trace);
             this.Monitor.Log($"Log started at {DateTime.UtcNow:s} UTC", LogLevel.Trace);
-
-            // validate platform
-#if SMAPI_FOR_WINDOWS
-            if (Constants.Platform != Platform.Windows)
-            {
-                this.Monitor.Log("Oops! You're running Windows, but this version of SMAPI is for Linux or Mac. Please reinstall SMAPI to fix this.", LogLevel.Error);
-                this.PressAnyKeyToExit();
-                return;
-            }
-#else
-            if (Constants.Platform == Platform.Windows)
-            {
-                this.Monitor.Log("Oops! You're running {Constants.Platform}, but this version of SMAPI is for Windows. Please reinstall SMAPI to fix this.", LogLevel.Error);
-                this.PressAnyKeyToExit();
-                return;
-            }
-#endif
-        }
-
-        /// <summary>Launch SMAPI.</summary>
-        [HandleProcessCorruptedStateExceptions, SecurityCritical] // let try..catch handle corrupted state exceptions
-        public void RunInteractively()
-        {
-            // initialise SMAPI
-            try
-            {
-                JsonConverter[] converters = {
+            JsonConverter[] converters = {
                     new ColorConverter(),
                     new PointConverter(),
                     new RectangleConverter()
                 };
-                foreach (JsonConverter converter in converters)
-                    this.Toolkit.JsonHelper.JsonSettings.Converters.Add(converter);
+            foreach (JsonConverter converter in converters)
+                this.Toolkit.JsonHelper.JsonSettings.Converters.Add(converter);
 
-                // add error handlers
+            // add error handlers
 #if SMAPI_FOR_WINDOWS
                 Application.ThreadException += (sender, e) => this.Monitor.Log($"Critical thread exception: {e.Exception.GetLogSummary()}", LogLevel.Error);
                 Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
 #endif
-                AppDomain.CurrentDomain.UnhandledException += (sender, e) => this.Monitor.Log($"Critical app domain exception: {e.ExceptionObject}", LogLevel.Error);
+            AppDomain.CurrentDomain.UnhandledException += (sender, e) => this.Monitor.Log($"Critical app domain exception: {e.ExceptionObject}", LogLevel.Error);
 
-                // add more leniant assembly resolvers
-                AppDomain.CurrentDomain.AssemblyResolve += (sender, e) => AssemblyLoader.ResolveAssembly(e.Name);
+            // add more leniant assembly resolvers
+            AppDomain.CurrentDomain.AssemblyResolve += (sender, e) => AssemblyLoader.ResolveAssembly(e.Name);
+            SGame.ConstructorHack = new SGameConstructorHack(this.Monitor, this.Reflection, this.Toolkit.JsonHelper, this.InitialiseBeforeFirstAssetLoaded);
 
+            // validate platform
+            //#if SMAPI_FOR_WINDOWS
+            //            if (Constants.Platform != Platform.Windows)
+            //            {
+            //                this.Monitor.Log("Oops! You're running Windows, but this version of SMAPI is for Linux or Mac. Please reinstall SMAPI to fix this.", LogLevel.Error);
+            //                this.PressAnyKeyToExit();
+            //                return;
+            //            }
+            //#else
+            //            if (Constants.Platform == Platform.Windows)
+            //            {
+            //                this.Monitor.Log("Oops! You're running {Constants.Platform}, but this version of SMAPI is for Windows. Please reinstall SMAPI to fix this.", LogLevel.Error);
+            //                this.PressAnyKeyToExit();
+            //                return;
+            //            }
+            //#endif
+        }
+
+        /// <summary>Launch SMAPI.</summary>
+        [HandleProcessCorruptedStateExceptions, SecurityCritical] // let try..catch handle corrupted state exceptions
+        public void RunInteractively(ContentCoordinator contentCore)
+        {
+            // initialise SMAPI
+            try
+            {
                 // override game
-                SGame.ConstructorHack = new SGameConstructorHack(this.Monitor, this.Reflection, this.Toolkit.JsonHelper, this.InitialiseBeforeFirstAssetLoaded);
                 this.GameInstance = new SGame(
+                    contentCore,
                     monitor: this.Monitor,
                     monitorForGame: this.MonitorForGame,
                     reflection: this.Reflection,
@@ -222,38 +221,37 @@ namespace StardewModdingAPI.Framework
                     onGameInitialised: this.InitialiseAfterGameStart,
                     onGameExiting: this.Dispose
                 );
-                StardewValley.Program.gamePtr = this.GameInstance;
-
+                StardewValley.Program.gamePtr = Game1.game1;
                 // apply game patches
-                new GamePatcher(this.Monitor).Apply(
-                    new DialogueErrorPatch(this.MonitorForGame, this.Reflection),
-                    new ObjectErrorPatch(),
-                    new LoadForNewGamePatch(this.Reflection, this.GameInstance.OnLoadStageChanged)
-                );
+                //new GamePatcher(this.Monitor).Apply(
+                //    new DialogueErrorPatch(this.MonitorForGame, this.Reflection),
+                //    new ObjectErrorPatch(),
+                //    new LoadForNewGamePatch(this.Reflection, this.GameInstance.OnLoadStageChanged)
+                //);
 
-                // add exit handler
-                new Thread(() =>
-                {
-                    this.CancellationTokenSource.Token.WaitHandle.WaitOne();
-                    if (this.IsGameRunning)
-                    {
-                        try
-                        {
-                            File.WriteAllText(Constants.FatalCrashMarker, string.Empty);
-                            File.Copy(this.LogFile.Path, Constants.FatalCrashLog, overwrite: true);
-                        }
-                        catch (Exception ex)
-                        {
-                            this.Monitor.Log($"SMAPI failed trying to track the crash details: {ex.GetLogSummary()}", LogLevel.Error);
-                        }
+                //// add exit handler
+                //new Thread(() =>
+                //{
+                //    this.CancellationTokenSource.Token.WaitHandle.WaitOne();
+                //    if (this.IsGameRunning)
+                //    {
+                //        try
+                //        {
+                //            File.WriteAllText(Constants.FatalCrashMarker, string.Empty);
+                //            File.Copy(this.LogFile.Path, Constants.FatalCrashLog, overwrite: true);
+                //        }
+                //        catch (Exception ex)
+                //        {
+                //            this.Monitor.Log($"SMAPI failed trying to track the crash details: {ex.GetLogSummary()}", LogLevel.Error);
+                //        }
 
-                        this.GameInstance.Exit();
-                    }
-                }).Start();
+                //        Game1.game1.Exit();
+                //    }
+                //}).Start();
 
                 // set window titles
-                this.GameInstance.Window.Title = $"Stardew Valley {Constants.GameVersion} - running SMAPI {Constants.ApiVersion}";
-                Console.Title = $"SMAPI {Constants.ApiVersion} - running Stardew Valley {Constants.GameVersion}";
+                //Game1.game1.Window.Title = $"Stardew Valley {Constants.GameVersion} - running SMAPI {Constants.ApiVersion}";
+                //Console.Title = $"SMAPI {Constants.ApiVersion} - running Stardew Valley {Constants.GameVersion}";
             }
             catch (Exception ex)
             {
@@ -300,38 +298,8 @@ namespace StardewModdingAPI.Framework
             this.Monitor.VerboseLog("Verbose logging enabled.");
 
             // update window titles
-            this.GameInstance.Window.Title = $"Stardew Valley {Constants.GameVersion} - running SMAPI {Constants.ApiVersion}";
-            Console.Title = $"SMAPI {Constants.ApiVersion} - running Stardew Valley {Constants.GameVersion}";
-
-            // start game
-            this.Monitor.Log("Starting game...", LogLevel.Debug);
-            try
-            {
-                this.IsGameRunning = true;
-                StardewValley.Program.releaseBuild = true; // game's debug logic interferes with SMAPI opening the game window
-                this.GameInstance.Run();
-            }
-            catch (InvalidOperationException ex) when (ex.Source == "Microsoft.Xna.Framework.Xact" && ex.StackTrace.Contains("Microsoft.Xna.Framework.Audio.AudioEngine..ctor"))
-            {
-                this.Monitor.Log("The game couldn't load audio. Do you have speakers or headphones plugged in?", LogLevel.Error);
-                this.Monitor.Log($"Technical details: {ex.GetLogSummary()}", LogLevel.Trace);
-                this.PressAnyKeyToExit();
-            }
-            catch (FileNotFoundException ex) when (ex.Message == "Could not find file 'C:\\Program Files (x86)\\Steam\\SteamApps\\common\\Stardew Valley\\Content\\XACT\\FarmerSounds.xgs'.") // path in error is hardcoded regardless of install path
-            {
-                this.Monitor.Log("The game can't find its Content\\XACT\\FarmerSounds.xgs file. You can usually fix this by resetting your content files (see https://smapi.io/troubleshoot#reset-content ), or by uninstalling and reinstalling the game.", LogLevel.Error);
-                this.Monitor.Log($"Technical details: {ex.GetLogSummary()}", LogLevel.Trace);
-                this.PressAnyKeyToExit();
-            }
-            catch (Exception ex)
-            {
-                this.MonitorForGame.Log($"The game failed to launch: {ex.GetLogSummary()}", LogLevel.Error);
-                this.PressAnyKeyToExit();
-            }
-            finally
-            {
-                this.Dispose();
-            }
+            //Game1.game1.Window.Title = $"Stardew Valley {Constants.GameVersion} - running SMAPI {Constants.ApiVersion}";
+            //Console.Title = $"SMAPI {Constants.ApiVersion} - running Stardew Valley {Constants.GameVersion}";
         }
 
         /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
@@ -361,7 +329,7 @@ namespace StardewModdingAPI.Framework
             this.ConsoleManager?.Dispose();
             this.ContentCore?.Dispose();
             this.CancellationTokenSource?.Dispose();
-            this.GameInstance?.Dispose();
+            //this.GameInstance?.Dispose();
             this.LogFile?.Dispose();
 
             // end game (moved from Game1.OnExiting to let us clean up first)
@@ -418,13 +386,13 @@ namespace StardewModdingAPI.Framework
                 }
 
                 // check for updates
-                this.CheckForUpdatesAsync(mods);
+                //this.CheckForUpdatesAsync(mods);
             }
 
             // update window titles
-            int modsLoaded = this.ModRegistry.GetAll().Count();
-            this.GameInstance.Window.Title = $"Stardew Valley {Constants.GameVersion} - running SMAPI {Constants.ApiVersion} with {modsLoaded} mods";
-            Console.Title = $"SMAPI {Constants.ApiVersion} - running Stardew Valley {Constants.GameVersion} with {modsLoaded} mods";
+            //int modsLoaded = this.ModRegistry.GetAll().Count();
+            //Game1.game1.Window.Title = $"Stardew Valley {Constants.GameVersion} - running SMAPI {Constants.ApiVersion} with {modsLoaded} mods";
+            //Console.Title = $"SMAPI {Constants.ApiVersion} - running Stardew Valley {Constants.GameVersion} with {modsLoaded} mods";
         }
 
         /// <summary>Initialise SMAPI and mods after the game starts.</summary>
@@ -435,7 +403,7 @@ namespace StardewModdingAPI.Framework
                 this.Monitor.Log("SMAPI found problems in your game's content files which are likely to cause errors or crashes. Consider uninstalling XNB mods or reinstalling the game.", LogLevel.Error);
 
             // start SMAPI console
-            new Thread(this.RunConsoleLoop).Start();
+            //new Thread(this.RunConsoleLoop).Start();
         }
 
         /// <summary>Handle the game changing locale.</summary>
@@ -538,153 +506,153 @@ namespace StardewModdingAPI.Framework
             return !issuesFound;
         }
 
-        /// <summary>Asynchronously check for a new version of SMAPI and any installed mods, and print alerts to the console if an update is available.</summary>
-        /// <param name="mods">The mods to include in the update check (if eligible).</param>
-        private void CheckForUpdatesAsync(IModMetadata[] mods)
-        {
-            if (!this.Settings.CheckForUpdates)
-                return;
+//        /// <summary>Asynchronously check for a new version of SMAPI and any installed mods, and print alerts to the console if an update is available.</summary>
+//        /// <param name="mods">The mods to include in the update check (if eligible).</param>
+//        private void CheckForUpdatesAsync(IModMetadata[] mods)
+//        {
+//            if (!this.Settings.CheckForUpdates)
+//                return;
 
-            new Thread(() =>
-            {
-                // create client
-                string url = this.Settings.WebApiBaseUrl;
-#if !SMAPI_FOR_WINDOWS
-                url = url.Replace("https://", "http://"); // workaround for OpenSSL issues with the game's bundled Mono on Linux/Mac
-#endif
-                WebApiClient client = new WebApiClient(url, Constants.ApiVersion);
-                this.Monitor.Log("Checking for updates...", LogLevel.Trace);
+//            new Thread(() =>
+//            {
+//                // create client
+//                string url = this.Settings.WebApiBaseUrl;
+//#if !SMAPI_FOR_WINDOWS
+//                url = url.Replace("https://", "http://"); // workaround for OpenSSL issues with the game's bundled Mono on Linux/Mac
+//#endif
+//                WebApiClient client = new WebApiClient(url, Constants.ApiVersion);
+//                this.Monitor.Log("Checking for updates...", LogLevel.Trace);
 
-                // check SMAPI version
-                ISemanticVersion updateFound = null;
-                try
-                {
-                    ModEntryModel response = client.GetModInfo(new[] { new ModSearchEntryModel("Pathoschild.SMAPI", new[] { $"GitHub:{this.Settings.GitHubProjectName}" }) }).Single().Value;
-                    ISemanticVersion latestStable = response.Main?.Version;
-                    ISemanticVersion latestBeta = response.Optional?.Version;
+//                // check SMAPI version
+//                ISemanticVersion updateFound = null;
+//                try
+//                {
+//                    ModEntryModel response = client.GetModInfo(new[] { new ModSearchEntryModel("Pathoschild.SMAPI", new[] { $"GitHub:{this.Settings.GitHubProjectName}" }) }).Single().Value;
+//                    ISemanticVersion latestStable = response.Main?.Version;
+//                    ISemanticVersion latestBeta = response.Optional?.Version;
 
-                    if (latestStable == null && response.Errors.Any())
-                    {
-                        this.Monitor.Log("Couldn't check for a new version of SMAPI. This won't affect your game, but you may not be notified of new versions if this keeps happening.", LogLevel.Warn);
-                        this.Monitor.Log($"Error: {string.Join("\n", response.Errors)}", LogLevel.Trace);
-                    }
-                    else if (this.IsValidUpdate(Constants.ApiVersion, latestBeta, this.Settings.UseBetaChannel))
-                    {
-                        updateFound = latestBeta;
-                        this.Monitor.Log($"You can update SMAPI to {latestBeta}: {Constants.HomePageUrl}", LogLevel.Alert);
-                    }
-                    else if (this.IsValidUpdate(Constants.ApiVersion, latestStable, this.Settings.UseBetaChannel))
-                    {
-                        updateFound = latestStable;
-                        this.Monitor.Log($"You can update SMAPI to {latestStable}: {Constants.HomePageUrl}", LogLevel.Alert);
-                    }
-                    else
-                        this.Monitor.Log("   SMAPI okay.", LogLevel.Trace);
-                }
-                catch (Exception ex)
-                {
-                    this.Monitor.Log("Couldn't check for a new version of SMAPI. This won't affect your game, but you won't be notified of new versions if this keeps happening.", LogLevel.Warn);
-                    this.Monitor.Log(ex is WebException && ex.InnerException == null
-                        ? $"Error: {ex.Message}"
-                        : $"Error: {ex.GetLogSummary()}", LogLevel.Trace
-                    );
-                }
+//                    if (latestStable == null && response.Errors.Any())
+//                    {
+//                        this.Monitor.Log("Couldn't check for a new version of SMAPI. This won't affect your game, but you may not be notified of new versions if this keeps happening.", LogLevel.Warn);
+//                        this.Monitor.Log($"Error: {string.Join("\n", response.Errors)}", LogLevel.Trace);
+//                    }
+//                    else if (this.IsValidUpdate(Constants.ApiVersion, latestBeta, this.Settings.UseBetaChannel))
+//                    {
+//                        updateFound = latestBeta;
+//                        this.Monitor.Log($"You can update SMAPI to {latestBeta}: {Constants.HomePageUrl}", LogLevel.Alert);
+//                    }
+//                    else if (this.IsValidUpdate(Constants.ApiVersion, latestStable, this.Settings.UseBetaChannel))
+//                    {
+//                        updateFound = latestStable;
+//                        this.Monitor.Log($"You can update SMAPI to {latestStable}: {Constants.HomePageUrl}", LogLevel.Alert);
+//                    }
+//                    else
+//                        this.Monitor.Log("   SMAPI okay.", LogLevel.Trace);
+//                }
+//                catch (Exception ex)
+//                {
+//                    this.Monitor.Log("Couldn't check for a new version of SMAPI. This won't affect your game, but you won't be notified of new versions if this keeps happening.", LogLevel.Warn);
+//                    this.Monitor.Log(ex is WebException && ex.InnerException == null
+//                        ? $"Error: {ex.Message}"
+//                        : $"Error: {ex.GetLogSummary()}", LogLevel.Trace
+//                    );
+//                }
 
-                // show update message on next launch
-                if (updateFound != null)
-                    File.WriteAllText(Constants.UpdateMarker, updateFound.ToString());
+//                // show update message on next launch
+//                if (updateFound != null)
+//                    File.WriteAllText(Constants.UpdateMarker, updateFound.ToString());
 
-                // check mod versions
-                if (mods.Any())
-                {
-                    try
-                    {
-                        HashSet<string> suppressUpdateChecks = new HashSet<string>(this.Settings.SuppressUpdateChecks, StringComparer.InvariantCultureIgnoreCase);
+//                // check mod versions
+//                if (mods.Any())
+//                {
+//                    try
+//                    {
+//                        HashSet<string> suppressUpdateChecks = new HashSet<string>(this.Settings.SuppressUpdateChecks, StringComparer.InvariantCultureIgnoreCase);
 
-                        // prepare search model
-                        List<ModSearchEntryModel> searchMods = new List<ModSearchEntryModel>();
-                        foreach (IModMetadata mod in mods)
-                        {
-                            if (!mod.HasID() || suppressUpdateChecks.Contains(mod.Manifest.UniqueID))
-                                continue;
+//                        // prepare search model
+//                        List<ModSearchEntryModel> searchMods = new List<ModSearchEntryModel>();
+//                        foreach (IModMetadata mod in mods)
+//                        {
+//                            if (!mod.HasID() || suppressUpdateChecks.Contains(mod.Manifest.UniqueID))
+//                                continue;
 
-                            string[] updateKeys = mod
-                                .GetUpdateKeys(validOnly: true)
-                                .Select(p => p.ToString())
-                                .ToArray();
-                            searchMods.Add(new ModSearchEntryModel(mod.Manifest.UniqueID, updateKeys.ToArray()));
-                        }
+//                            string[] updateKeys = mod
+//                                .GetUpdateKeys(validOnly: true)
+//                                .Select(p => p.ToString())
+//                                .ToArray();
+//                            searchMods.Add(new ModSearchEntryModel(mod.Manifest.UniqueID, updateKeys.ToArray()));
+//                        }
 
-                        // fetch results
-                        this.Monitor.Log($"   Checking for updates to {searchMods.Count} mods...", LogLevel.Trace);
-                        IDictionary<string, ModEntryModel> results = client.GetModInfo(searchMods.ToArray());
+//                        // fetch results
+//                        this.Monitor.Log($"   Checking for updates to {searchMods.Count} mods...", LogLevel.Trace);
+//                        IDictionary<string, ModEntryModel> results = client.GetModInfo(searchMods.ToArray());
 
-                        // extract update alerts & errors
-                        var updates = new List<Tuple<IModMetadata, ISemanticVersion, string>>();
-                        var errors = new StringBuilder();
-                        foreach (IModMetadata mod in mods.OrderBy(p => p.DisplayName))
-                        {
-                            // link to update-check data
-                            if (!mod.HasID() || !results.TryGetValue(mod.Manifest.UniqueID, out ModEntryModel result))
-                                continue;
-                            mod.SetUpdateData(result);
+//                        // extract update alerts & errors
+//                        var updates = new List<Tuple<IModMetadata, ISemanticVersion, string>>();
+//                        var errors = new StringBuilder();
+//                        foreach (IModMetadata mod in mods.OrderBy(p => p.DisplayName))
+//                        {
+//                            // link to update-check data
+//                            if (!mod.HasID() || !results.TryGetValue(mod.Manifest.UniqueID, out ModEntryModel result))
+//                                continue;
+//                            mod.SetUpdateData(result);
 
-                            // handle errors
-                            if (result.Errors != null && result.Errors.Any())
-                            {
-                                errors.AppendLine(result.Errors.Length == 1
-                                    ? $"   {mod.DisplayName}: {result.Errors[0]}"
-                                    : $"   {mod.DisplayName}:\n      - {string.Join("\n      - ", result.Errors)}"
-                                );
-                            }
+//                            // handle errors
+//                            if (result.Errors != null && result.Errors.Any())
+//                            {
+//                                errors.AppendLine(result.Errors.Length == 1
+//                                    ? $"   {mod.DisplayName}: {result.Errors[0]}"
+//                                    : $"   {mod.DisplayName}:\n      - {string.Join("\n      - ", result.Errors)}"
+//                                );
+//                            }
 
-                            // parse versions
-                            bool useBetaInfo = result.HasBetaInfo && Constants.ApiVersion.IsPrerelease();
-                            ISemanticVersion localVersion = mod.DataRecord?.GetLocalVersionForUpdateChecks(mod.Manifest.Version) ?? mod.Manifest.Version;
-                            ISemanticVersion latestVersion = mod.DataRecord?.GetRemoteVersionForUpdateChecks(result.Main?.Version) ?? result.Main?.Version;
-                            ISemanticVersion optionalVersion = mod.DataRecord?.GetRemoteVersionForUpdateChecks(result.Optional?.Version) ?? result.Optional?.Version;
-                            ISemanticVersion unofficialVersion = useBetaInfo ? result.UnofficialForBeta?.Version : result.Unofficial?.Version;
+//                            // parse versions
+//                            bool useBetaInfo = result.HasBetaInfo && Constants.ApiVersion.IsPrerelease();
+//                            ISemanticVersion localVersion = mod.DataRecord?.GetLocalVersionForUpdateChecks(mod.Manifest.Version) ?? mod.Manifest.Version;
+//                            ISemanticVersion latestVersion = mod.DataRecord?.GetRemoteVersionForUpdateChecks(result.Main?.Version) ?? result.Main?.Version;
+//                            ISemanticVersion optionalVersion = mod.DataRecord?.GetRemoteVersionForUpdateChecks(result.Optional?.Version) ?? result.Optional?.Version;
+//                            ISemanticVersion unofficialVersion = useBetaInfo ? result.UnofficialForBeta?.Version : result.Unofficial?.Version;
 
-                            // show update alerts
-                            if (this.IsValidUpdate(localVersion, latestVersion, useBetaChannel: true))
-                                updates.Add(Tuple.Create(mod, latestVersion, result.Main?.Url));
-                            else if (this.IsValidUpdate(localVersion, optionalVersion, useBetaChannel: localVersion.IsPrerelease()))
-                                updates.Add(Tuple.Create(mod, optionalVersion, result.Optional?.Url));
-                            else if (this.IsValidUpdate(localVersion, unofficialVersion, useBetaChannel: mod.Status == ModMetadataStatus.Failed))
-                                updates.Add(Tuple.Create(mod, unofficialVersion, useBetaInfo ? result.UnofficialForBeta?.Url : result.Unofficial?.Url));
-                        }
+//                            // show update alerts
+//                            if (this.IsValidUpdate(localVersion, latestVersion, useBetaChannel: true))
+//                                updates.Add(Tuple.Create(mod, latestVersion, result.Main?.Url));
+//                            else if (this.IsValidUpdate(localVersion, optionalVersion, useBetaChannel: localVersion.IsPrerelease()))
+//                                updates.Add(Tuple.Create(mod, optionalVersion, result.Optional?.Url));
+//                            else if (this.IsValidUpdate(localVersion, unofficialVersion, useBetaChannel: mod.Status == ModMetadataStatus.Failed))
+//                                updates.Add(Tuple.Create(mod, unofficialVersion, useBetaInfo ? result.UnofficialForBeta?.Url : result.Unofficial?.Url));
+//                        }
 
-                        // show update errors
-                        if (errors.Length != 0)
-                            this.Monitor.Log("Got update-check errors for some mods:\n" + errors.ToString().TrimEnd(), LogLevel.Trace);
+//                        // show update errors
+//                        if (errors.Length != 0)
+//                            this.Monitor.Log("Got update-check errors for some mods:\n" + errors.ToString().TrimEnd(), LogLevel.Trace);
 
-                        // show update alerts
-                        if (updates.Any())
-                        {
-                            this.Monitor.Newline();
-                            this.Monitor.Log($"You can update {updates.Count} mod{(updates.Count != 1 ? "s" : "")}:", LogLevel.Alert);
-                            foreach (var entry in updates)
-                            {
-                                IModMetadata mod = entry.Item1;
-                                ISemanticVersion newVersion = entry.Item2;
-                                string newUrl = entry.Item3;
-                                this.Monitor.Log($"   {mod.DisplayName} {newVersion}: {newUrl}", LogLevel.Alert);
-                            }
-                        }
-                        else
-                            this.Monitor.Log("   All mods up to date.", LogLevel.Trace);
-                    }
-                    catch (Exception ex)
-                    {
-                        this.Monitor.Log("Couldn't check for new mod versions. This won't affect your game, but you won't be notified of mod updates if this keeps happening.", LogLevel.Warn);
-                        this.Monitor.Log(ex is WebException && ex.InnerException == null
-                            ? ex.Message
-                            : ex.ToString(), LogLevel.Trace
-                        );
-                    }
-                }
-            }).Start();
-        }
+//                        // show update alerts
+//                        if (updates.Any())
+//                        {
+//                            this.Monitor.Newline();
+//                            this.Monitor.Log($"You can update {updates.Count} mod{(updates.Count != 1 ? "s" : "")}:", LogLevel.Alert);
+//                            foreach (var entry in updates)
+//                            {
+//                                IModMetadata mod = entry.Item1;
+//                                ISemanticVersion newVersion = entry.Item2;
+//                                string newUrl = entry.Item3;
+//                                this.Monitor.Log($"   {mod.DisplayName} {newVersion}: {newUrl}", LogLevel.Alert);
+//                            }
+//                        }
+//                        else
+//                            this.Monitor.Log("   All mods up to date.", LogLevel.Trace);
+//                    }
+//                    catch (Exception ex)
+//                    {
+//                        this.Monitor.Log("Couldn't check for new mod versions. This won't affect your game, but you won't be notified of mod updates if this keeps happening.", LogLevel.Warn);
+//                        this.Monitor.Log(ex is WebException && ex.InnerException == null
+//                            ? ex.Message
+//                            : ex.ToString(), LogLevel.Trace
+//                        );
+//                    }
+//                }
+//            }).Start();
+//        }
 
         /// <summary>Get whether a given version should be offered to the user as an update.</summary>
         /// <param name="currentVersion">The current semantic version.</param>
@@ -1013,7 +981,7 @@ namespace StardewModdingAPI.Framework
                         IDataHelper dataHelper = new DataHelper(manifest.UniqueID, mod.DirectoryPath, jsonHelper);
                         IReflectionHelper reflectionHelper = new ReflectionHelper(manifest.UniqueID, mod.DisplayName, this.Reflection);
                         IModRegistry modRegistryHelper = new ModRegistryHelper(manifest.UniqueID, this.ModRegistry, proxyFactory, monitor);
-                        IMultiplayerHelper multiplayerHelper = new MultiplayerHelper(manifest.UniqueID, this.GameInstance.Multiplayer);
+                        //IMultiplayerHelper multiplayerHelper = new MultiplayerHelper(manifest.UniqueID, this.GameInstance.Multiplayer);
 
                         IContentPack CreateFakeContentPack(string packDirPath, IManifest packManifest)
                         {
@@ -1023,7 +991,7 @@ namespace StardewModdingAPI.Framework
                             return new ContentPack(packDirPath, packManifest, packContentHelper, packTranslationHelper, this.Toolkit.JsonHelper);
                         }
 
-                        modHelper = new ModHelper(manifest.UniqueID, mod.DirectoryPath, this.GameInstance.Input, events, contentHelper, contentPackHelper, commandHelper, dataHelper, modRegistryHelper, reflectionHelper, multiplayerHelper, translationHelper);
+                        modHelper = new ModHelper(manifest.UniqueID, mod.DirectoryPath, this.GameInstance.Input, events, contentHelper, contentPackHelper, commandHelper, dataHelper, modRegistryHelper, reflectionHelper, translationHelper);
                     }
 
                     // init mod
diff --git a/src/SMAPI/Framework/SGame.cs b/src/SMAPI/Framework/SGame.cs
index 525f1bea..af76e15d 100644
--- a/src/SMAPI/Framework/SGame.cs
+++ b/src/SMAPI/Framework/SGame.cs
@@ -33,7 +33,7 @@ using SObject = StardewValley.Object;
 namespace StardewModdingAPI.Framework
 {
     /// <summary>SMAPI's extension of the game's core <see cref="Game1"/>, used to inject events.</summary>
-    internal class SGame : Game1
+    internal class SGame
     {
         /*********
         ** Fields
@@ -76,7 +76,7 @@ namespace StardewModdingAPI.Framework
         private readonly Action OnLocaleChanged;
 
         /// <summary>A callback to invoke the first time *any* game content manager loads an asset.</summary>
-        private readonly Action OnLoadingFirstAsset;
+        public static Action OnLoadingFirstAsset;
 
         /// <summary>A callback to invoke after the game finishes initialising.</summary>
         private readonly Action OnGameInitialised;
@@ -99,6 +99,10 @@ namespace StardewModdingAPI.Framework
         /// <summary>Whether the next content manager requested by the game will be for <see cref="Game1.content"/>.</summary>
         private bool NextContentManagerIsMain;
 
+        public static void printLog(string msg)
+        {
+            SGame.instance.Monitor.Log(msg);
+        }
 
         /*********
         ** Accessors
@@ -116,15 +120,20 @@ namespace StardewModdingAPI.Framework
         public CommandManager CommandManager { get; } = new CommandManager();
 
         /// <summary>Manages input visible to the game.</summary>
-        public SInputState Input => (SInputState)Game1.input;
+        public SInputState Input => (SInputState)this.Reflection.GetField<InputState>(typeof(Game1), "input").GetValue();
 
-        /// <summary>The game's core multiplayer utility.</summary>
-        public SMultiplayer Multiplayer => (SMultiplayer)Game1.multiplayer;
+        ///// <summary>The game's core multiplayer utility.</summary>
+        //public SMultiplayer Multiplayer => (SMultiplayer)this.Reflection.GetField<Multiplayer>(typeof(Game1), "multiplayer").GetValue();
 
         /// <summary>A list of queued commands to execute.</summary>
         /// <remarks>This property must be threadsafe, since it's accessed from a separate console input thread.</remarks>
         public ConcurrentQueue<string> CommandQueue { get; } = new ConcurrentQueue<string>();
 
+        private bool saveParsed;
+
+        public static SGame instance;
+
+        
 
         /*********
         ** Protected methods
@@ -140,14 +149,15 @@ namespace StardewModdingAPI.Framework
         /// <param name="onLocaleChanged">A callback to invoke after the content language changes.</param>
         /// <param name="onGameInitialised">A callback to invoke after the game finishes initialising.</param>
         /// <param name="onGameExiting">A callback to invoke when the game exits.</param>
-        internal SGame(IMonitor monitor, IMonitor monitorForGame, Reflector reflection, EventManager eventManager, JsonHelper jsonHelper, ModRegistry modRegistry, DeprecationManager deprecationManager, Action onLocaleChanged, Action onGameInitialised, Action onGameExiting)
+        internal SGame(ContentCoordinator contentCore, IMonitor monitor, IMonitor monitorForGame, Reflector reflection, EventManager eventManager, JsonHelper jsonHelper, ModRegistry modRegistry, DeprecationManager deprecationManager, Action onLocaleChanged, Action onGameInitialised, Action onGameExiting)
         {
-            this.OnLoadingFirstAsset = SGame.ConstructorHack.OnLoadingFirstAsset;
+            SGame.OnLoadingFirstAsset = SGame.ConstructorHack.OnLoadingFirstAsset;
             SGame.ConstructorHack = null;
 
             // check expectations
-            if (this.ContentCore == null)
+            if (contentCore == null)
                 throw new InvalidOperationException($"The game didn't initialise its first content manager before SMAPI's {nameof(SGame)} constructor. This indicates an incompatible lifecycle change.");
+            this.ContentCore = contentCore;
 
             // init XNA
             Game1.graphics.GraphicsProfile = GraphicsProfile.HiDef;
@@ -162,12 +172,14 @@ namespace StardewModdingAPI.Framework
             this.OnLocaleChanged = onLocaleChanged;
             this.OnGameInitialised = onGameInitialised;
             this.OnGameExiting = onGameExiting;
-            Game1.input = new SInputState();
-            Game1.multiplayer = new SMultiplayer(monitor, eventManager, jsonHelper, modRegistry, reflection, this.OnModMessageReceived);
-            Game1.hooks = new SModHooks(this.OnNewDayAfterFade);
+            this.Reflection.GetField<InputState>(typeof(Game1), "input").SetValue(new SInputState());
+            //this.Reflection.GetField<Multiplayer>(typeof(Game1), "multiplayer").SetValue(new SMultiplayer(monitor, eventManager, jsonHelper, modRegistry, reflection, this.OnModMessageReceived));
+            //Game1.hooks = new SModHooks(this.OnNewDayAfterFade);
 
             // init observables
-            Game1.locations = new ObservableCollection<GameLocation>();
+            //Game1.locations = new ObservableCollection<GameLocation>();
+            this.saveParsed = false;
+            SGame.instance = this;
         }
 
         /// <summary>Initialise just before the game's first update tick.</summary>
@@ -183,18 +195,18 @@ namespace StardewModdingAPI.Framework
             this.OnGameInitialised();
         }
 
-        /// <summary>Perform cleanup logic when the game exits.</summary>
-        /// <param name="sender">The event sender.</param>
-        /// <param name="args">The event args.</param>
-        /// <remarks>This overrides the logic in <see cref="Game1.exitEvent"/> to let SMAPI clean up before exit.</remarks>
-        protected override void OnExiting(object sender, EventArgs args)
-        {
-            Game1.multiplayer.Disconnect();
-            this.OnGameExiting?.Invoke();
-        }
+        ///// <summary>Perform cleanup logic when the game exits.</summary>
+        ///// <param name="sender">The event sender.</param>
+        ///// <param name="args">The event args.</param>
+        ///// <remarks>This overrides the logic in <see cref="Game1.exitEvent"/> to let SMAPI clean up before exit.</remarks>
+        //protected override void OnExiting(object sender, EventArgs args)
+        //{
+        //    Game1.multiplayer.Disconnect();
+        //    this.OnGameExiting?.Invoke();
+        //}
 
         /// <summary>A callback invoked before <see cref="Game1.newDayAfterFade"/> runs.</summary>
-        protected void OnNewDayAfterFade()
+        public void OnNewDayAfterFade()
         {
             this.Events.DayEnding.RaiseEmpty();
         }
@@ -222,7 +234,7 @@ namespace StardewModdingAPI.Framework
             if (newStage == LoadStage.None)
             {
                 this.Monitor.Log("Context: returned to title", LogLevel.Trace);
-                this.Multiplayer.CleanupOnMultiplayerExit();
+                //this.Multiplayer.CleanupOnMultiplayerExit();
             }
             this.Monitor.VerboseLog($"Context: load stage changed to {newStage}");
 
@@ -232,34 +244,34 @@ namespace StardewModdingAPI.Framework
                 this.Events.ReturnedToTitle.RaiseEmpty();
         }
 
-        /// <summary>Constructor a content manager to read XNB files.</summary>
-        /// <param name="serviceProvider">The service provider to use to locate services.</param>
-        /// <param name="rootDirectory">The root directory to search for content.</param>
-        protected override LocalizedContentManager CreateContentManager(IServiceProvider serviceProvider, string rootDirectory)
-        {
-            // Game1._temporaryContent initialising from SGame constructor
-            // NOTE: this method is called before the SGame constructor runs. Don't depend on anything being initialised at this point.
-            if (this.ContentCore == null)
-            {
-                this.ContentCore = new ContentCoordinator(serviceProvider, rootDirectory, Thread.CurrentThread.CurrentUICulture, SGame.ConstructorHack.Monitor, SGame.ConstructorHack.Reflection, SGame.ConstructorHack.JsonHelper, this.OnLoadingFirstAsset ?? SGame.ConstructorHack?.OnLoadingFirstAsset);
-                this.NextContentManagerIsMain = true;
-                return this.ContentCore.CreateGameContentManager("Game1._temporaryContent");
-            }
+        ///// <summary>Constructor a content manager to read XNB files.</summary>
+        ///// <param name="serviceProvider">The service provider to use to locate services.</param>
+        ///// <param name="rootDirectory">The root directory to search for content.</param>
+        //public LocalizedContentManager CreateContentManager(IServiceProvider serviceProvider, string rootDirectory)
+        //{
+        //    // Game1._temporaryContent initialising from SGame constructor
+        //    // NOTE: this method is called before the SGame constructor runs. Don't depend on anything being initialised at this point.
+        //    if (this.ContentCore == null)
+        //    {
+        //        this.ContentCore = new ContentCoordinator(serviceProvider, rootDirectory, Thread.CurrentThread.CurrentUICulture, SGame.ConstructorHack.Monitor, SGame.ConstructorHack.Reflection, SGame.ConstructorHack.JsonHelper, this.OnLoadingFirstAsset ?? SGame.ConstructorHack?.OnLoadingFirstAsset);
+        //        this.NextContentManagerIsMain = true;
+        //        return this.ContentCore.CreateGameContentManager("Game1._temporaryContent");
+        //    }
 
-            // Game1.content initialising from LoadContent
-            if (this.NextContentManagerIsMain)
-            {
-                this.NextContentManagerIsMain = false;
-                return this.ContentCore.MainContentManager;
-            }
+        //    // Game1.content initialising from LoadContent
+        //    if (this.NextContentManagerIsMain)
+        //    {
+        //        this.NextContentManagerIsMain = false;
+        //        return this.ContentCore.MainContentManager;
+        //    }
 
-            // any other content manager
-            return this.ContentCore.CreateGameContentManager("(generated)");
-        }
+        //    // any other content manager
+        //    return this.ContentCore.CreateGameContentManager("(generated)");
+        //}
 
         /// <summary>The method called when the game is updating its state. This happens roughly 60 times per second.</summary>
         /// <param name="gameTime">A snapshot of the game timing state.</param>
-        protected override void Update(GameTime gameTime)
+        public void Update(GameTime gameTime)
         {
             var events = this.Events;
 
@@ -286,42 +298,41 @@ namespace StardewModdingAPI.Framework
 
                 // Run async tasks synchronously to avoid issues due to mod events triggering
                 // concurrently with game code.
-                bool saveParsed = false;
                 if (Game1.currentLoader != null)
                 {
-                    this.Monitor.Log("Game loader synchronising...", LogLevel.Trace);
-                    while (Game1.currentLoader?.MoveNext() == true)
+                    int stage = Game1.currentLoader.Current;
+                    switch (stage)
                     {
-                        // raise load stage changed
-                        switch (Game1.currentLoader.Current)
-                        {
-                            case 20 when (!saveParsed && SaveGame.loaded != null):
-                                saveParsed = true;
-                                this.OnLoadStageChanged(LoadStage.SaveParsed);
-                                break;
+                        case 20 when (!this.saveParsed && SaveGame.loaded != null):
+                            this.saveParsed = true;
+                            this.OnLoadStageChanged(LoadStage.SaveParsed);
+                            break;
 
-                            case 36:
-                                this.OnLoadStageChanged(LoadStage.SaveLoadedBasicInfo);
-                                break;
+                        case 36:
+                            this.OnLoadStageChanged(LoadStage.SaveLoadedBasicInfo);
+                            break;
 
-                            case 50:
-                                this.OnLoadStageChanged(LoadStage.SaveLoadedLocations);
-                                break;
+                        case 50:
+                            this.OnLoadStageChanged(LoadStage.SaveLoadedLocations);
+                            break;
 
-                            default:
-                                if (Game1.gameMode == Game1.playingGameMode)
-                                    this.OnLoadStageChanged(LoadStage.Preloaded);
-                                break;
-                        }
+                        case 100:
+                            Game1.currentLoader = null;
+                            this.Monitor.Log("Game loader done.", LogLevel.Trace);
+                            break;
+
+                        default:
+                            if (Game1.gameMode == Game1.playingGameMode)
+                                this.OnLoadStageChanged(LoadStage.Preloaded);
+                            break;
                     }
-
-                    Game1.currentLoader = null;
-                    this.Monitor.Log("Game loader done.", LogLevel.Trace);
+                    return;
                 }
-                if (Game1._newDayTask?.Status == TaskStatus.Created)
+                Task _newDayTask = this.Reflection.GetField<Task>(typeof(Game1), "_newDayTask").GetValue();
+                if (_newDayTask?.Status == TaskStatus.Created)
                 {
                     this.Monitor.Log("New day task synchronising...", LogLevel.Trace);
-                    Game1._newDayTask.RunSynchronously();
+                    _newDayTask.RunSynchronously();
                     this.Monitor.Log("New day task done.", LogLevel.Trace);
                 }
 
@@ -334,11 +345,11 @@ namespace StardewModdingAPI.Framework
                 // a small chance that the task will finish after we defer but before the game checks,
                 // which means technically events should be raised, but the effects of missing one
                 // update tick are neglible and not worth the complications of bypassing Game1.Update.
-                if (Game1._newDayTask != null || Game1.gameMode == Game1.loadingMode)
+                if (_newDayTask != null || Game1.gameMode == Game1.loadingMode)
                 {
                     events.UnvalidatedUpdateTicking.RaiseEmpty();
                     SGame.TicksElapsed++;
-                    base.Update(gameTime);
+                    //base.Update(gameTime);
                     events.UnvalidatedUpdateTicked.RaiseEmpty();
                     return;
                 }
@@ -387,8 +398,8 @@ namespace StardewModdingAPI.Framework
                 // this too. For example, doing this after mod event suppression would prevent the
                 // user from doing anything on the overnight shipping screen.
                 SInputState inputState = this.Input;
-                if (this.IsActive)
-                    inputState.TrueUpdate();
+                //if (Game1.game1.IsActive)
+                inputState.TrueUpdate();
 
                 /*********
                 ** Save events + suppress events during save
@@ -419,7 +430,7 @@ namespace StardewModdingAPI.Framework
                     // suppress non-save events
                     events.UnvalidatedUpdateTicking.RaiseEmpty();
                     SGame.TicksElapsed++;
-                    base.Update(gameTime);
+                    //base.Update(gameTime);
                     events.UnvalidatedUpdateTicked.RaiseEmpty();
                     return;
                 }
@@ -518,7 +529,7 @@ namespace StardewModdingAPI.Framework
                 /*********
                 ** Input events (if window has focus)
                 *********/
-                if (this.IsActive)
+                //if (Game1.game1.IsActive)
                 {
                     // raise events
                     bool isChatInput = Game1.IsChatting || (Context.IsMultiplayer && Context.IsWorldReady && Game1.activeClickableMenu == null && Game1.currentMinigame == null && inputState.IsAnyDown(Game1.options.chatButton));
@@ -596,6 +607,23 @@ namespace StardewModdingAPI.Framework
 
                     // raise menu events
                     events.MenuChanged.Raise(new MenuChangedEventArgs(was, now));
+                    GameMenu gameMenu = now as GameMenu;
+                    if (gameMenu != null)
+                    {
+                        foreach (IClickableMenu menuPage in gameMenu.pages)
+                        {
+                            OptionsPage optionsPage = menuPage as OptionsPage;
+                            if (optionsPage != null)
+                            {
+                                List<OptionsElement> options = this.Reflection.GetField<List<OptionsElement>>(optionsPage, "options").GetValue();
+                                foreach(IModMetadata modMetadata in this.ModRegistry.GetAll())
+                                {
+                                    options.InsertRange(0, modMetadata.Mod.GetConfigMenuItems());
+                                }
+                                this.Reflection.GetMethod(optionsPage, "updateContentPositions").Invoke();
+                            }
+                        }
+                    }
                 }
 
                 /*********
@@ -787,7 +815,7 @@ namespace StardewModdingAPI.Framework
                 {
                     this.Input.UpdateSuppression();
                     SGame.TicksElapsed++;
-                    base.Update(gameTime);
+                    //base.Update(gameTime);
                 }
                 catch (Exception ex)
                 {
@@ -814,708 +842,708 @@ namespace StardewModdingAPI.Framework
             }
         }
 
-        /// <summary>The method called to draw everything to the screen.</summary>
-        /// <param name="gameTime">A snapshot of the game timing state.</param>
-        protected override void Draw(GameTime gameTime)
-        {
-            Context.IsInDrawLoop = true;
-            try
-            {
-                this.DrawImpl(gameTime);
-                this.DrawCrashTimer.Reset();
-            }
-            catch (Exception ex)
-            {
-                // log error
-                this.Monitor.Log($"An error occured in the overridden draw loop: {ex.GetLogSummary()}", LogLevel.Error);
+        ///// <summary>The method called to draw everything to the screen.</summary>
+        ///// <param name="gameTime">A snapshot of the game timing state.</param>
+        //protected override void Draw(GameTime gameTime)
+        //{
+        //    Context.IsInDrawLoop = true;
+        //    try
+        //    {
+        //        this.DrawImpl(gameTime);
+        //        this.DrawCrashTimer.Reset();
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        // log error
+        //        this.Monitor.Log($"An error occured in the overridden draw loop: {ex.GetLogSummary()}", LogLevel.Error);
 
-                // exit if irrecoverable
-                if (!this.DrawCrashTimer.Decrement())
-                {
-                    this.Monitor.ExitGameImmediately("the game crashed when drawing, and SMAPI was unable to recover the game.");
-                    return;
-                }
+        //        // exit if irrecoverable
+        //        if (!this.DrawCrashTimer.Decrement())
+        //        {
+        //            this.Monitor.ExitGameImmediately("the game crashed when drawing, and SMAPI was unable to recover the game.");
+        //            return;
+        //        }
 
-                // recover sprite batch
-                try
-                {
-                    if (Game1.spriteBatch.IsOpen(this.Reflection))
-                    {
-                        this.Monitor.Log("Recovering sprite batch from error...", LogLevel.Trace);
-                        Game1.spriteBatch.End();
-                    }
-                }
-                catch (Exception innerEx)
-                {
-                    this.Monitor.Log($"Could not recover sprite batch state: {innerEx.GetLogSummary()}", LogLevel.Error);
-                }
-            }
-            Context.IsInDrawLoop = false;
-        }
+        //        // recover sprite batch
+        //        try
+        //        {
+        //            if (Game1.spriteBatch.IsOpen(this.Reflection))
+        //            {
+        //                this.Monitor.Log("Recovering sprite batch from error...", LogLevel.Trace);
+        //                Game1.spriteBatch.End();
+        //            }
+        //        }
+        //        catch (Exception innerEx)
+        //        {
+        //            this.Monitor.Log($"Could not recover sprite batch state: {innerEx.GetLogSummary()}", LogLevel.Error);
+        //        }
+        //    }
+        //    Context.IsInDrawLoop = false;
+        //}
 
-        /// <summary>Replicate the game's draw logic with some changes for SMAPI.</summary>
-        /// <param name="gameTime">A snapshot of the game timing state.</param>
-        /// <remarks>This implementation is identical to <see cref="Game1.Draw"/>, except for try..catch around menu draw code, private field references replaced by wrappers, and added events.</remarks>
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator", Justification = "copied from game code as-is")]
-        [SuppressMessage("ReSharper", "LocalVariableHidesMember", Justification = "copied from game code as-is")]
-        [SuppressMessage("ReSharper", "PossibleLossOfFraction", Justification = "copied from game code as-is")]
-        [SuppressMessage("ReSharper", "RedundantArgumentDefaultValue", Justification = "copied from game code as-is")]
-        [SuppressMessage("ReSharper", "RedundantCast", Justification = "copied from game code as-is")]
-        [SuppressMessage("ReSharper", "RedundantExplicitNullableCreation", Justification = "copied from game code as-is")]
-        [SuppressMessage("ReSharper", "RedundantTypeArgumentsOfMethod", Justification = "copied from game code as-is")]
-        [SuppressMessage("SMAPI.CommonErrors", "AvoidNetField", Justification = "copied from game code as-is")]
-        [SuppressMessage("SMAPI.CommonErrors", "AvoidImplicitNetFieldCast", Justification = "copied from game code as-is")]
-        private void DrawImpl(GameTime gameTime)
-        {
-            var events = this.Events;
+        ///// <summary>Replicate the game's draw logic with some changes for SMAPI.</summary>
+        ///// <param name="gameTime">A snapshot of the game timing state.</param>
+        ///// <remarks>This implementation is identical to <see cref="Game1.Draw"/>, except for try..catch around menu draw code, private field references replaced by wrappers, and added events.</remarks>
+        //[SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator", Justification = "copied from game code as-is")]
+        //[SuppressMessage("ReSharper", "LocalVariableHidesMember", Justification = "copied from game code as-is")]
+        //[SuppressMessage("ReSharper", "PossibleLossOfFraction", Justification = "copied from game code as-is")]
+        //[SuppressMessage("ReSharper", "RedundantArgumentDefaultValue", Justification = "copied from game code as-is")]
+        //[SuppressMessage("ReSharper", "RedundantCast", Justification = "copied from game code as-is")]
+        //[SuppressMessage("ReSharper", "RedundantExplicitNullableCreation", Justification = "copied from game code as-is")]
+        //[SuppressMessage("ReSharper", "RedundantTypeArgumentsOfMethod", Justification = "copied from game code as-is")]
+        //[SuppressMessage("SMAPI.CommonErrors", "AvoidNetField", Justification = "copied from game code as-is")]
+        //[SuppressMessage("SMAPI.CommonErrors", "AvoidImplicitNetFieldCast", Justification = "copied from game code as-is")]
+        //private void DrawImpl(GameTime gameTime)
+        //{
+        //    var events = this.Events;
 
-            if (Game1._newDayTask != null)
-                this.GraphicsDevice.Clear(this.bgColor);
-            else
-            {
-                if ((double)Game1.options.zoomLevel != 1.0)
-                    this.GraphicsDevice.SetRenderTarget(this.screen);
-                if (this.IsSaving)
-                {
-                    this.GraphicsDevice.Clear(this.bgColor);
-                    IClickableMenu activeClickableMenu = Game1.activeClickableMenu;
-                    if (activeClickableMenu != null)
-                    {
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        events.Rendering.RaiseEmpty();
-                        try
-                        {
-                            events.RenderingActiveMenu.RaiseEmpty();
-                            activeClickableMenu.draw(Game1.spriteBatch);
-                            events.RenderedActiveMenu.RaiseEmpty();
-                        }
-                        catch (Exception ex)
-                        {
-                            this.Monitor.Log($"The {activeClickableMenu.GetType().FullName} menu crashed while drawing itself during save. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
-                            activeClickableMenu.exitThisMenu();
-                        }
-                        events.Rendered.RaiseEmpty();
-                        Game1.spriteBatch.End();
-                    }
-                    if (Game1.overlayMenu != null)
-                    {
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        Game1.overlayMenu.draw(Game1.spriteBatch);
-                        Game1.spriteBatch.End();
-                    }
-                    this.renderScreenBuffer();
-                }
-                else
-                {
-                    this.GraphicsDevice.Clear(this.bgColor);
-                    if (Game1.activeClickableMenu != null && Game1.options.showMenuBackground && Game1.activeClickableMenu.showWithoutTransparencyIfOptionIsSet())
-                    {
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //    if (Game1._newDayTask != null)
+        //        this.GraphicsDevice.Clear(this.bgColor);
+        //    else
+        //    {
+        //        if ((double)Game1.options.zoomLevel != 1.0)
+        //            this.GraphicsDevice.SetRenderTarget(this.screen);
+        //        if (this.IsSaving)
+        //        {
+        //            this.GraphicsDevice.Clear(this.bgColor);
+        //            IClickableMenu activeClickableMenu = Game1.activeClickableMenu;
+        //            if (activeClickableMenu != null)
+        //            {
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                events.Rendering.RaiseEmpty();
+        //                try
+        //                {
+        //                    events.RenderingActiveMenu.RaiseEmpty();
+        //                    activeClickableMenu.draw(Game1.spriteBatch);
+        //                    events.RenderedActiveMenu.RaiseEmpty();
+        //                }
+        //                catch (Exception ex)
+        //                {
+        //                    this.Monitor.Log($"The {activeClickableMenu.GetType().FullName} menu crashed while drawing itself during save. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
+        //                    activeClickableMenu.exitThisMenu();
+        //                }
+        //                events.Rendered.RaiseEmpty();
+        //                Game1.spriteBatch.End();
+        //            }
+        //            if (Game1.overlayMenu != null)
+        //            {
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                Game1.overlayMenu.draw(Game1.spriteBatch);
+        //                Game1.spriteBatch.End();
+        //            }
+        //            this.renderScreenBuffer();
+        //        }
+        //        else
+        //        {
+        //            this.GraphicsDevice.Clear(this.bgColor);
+        //            if (Game1.activeClickableMenu != null && Game1.options.showMenuBackground && Game1.activeClickableMenu.showWithoutTransparencyIfOptionIsSet())
+        //            {
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
 
-                        events.Rendering.RaiseEmpty();
-                        try
-                        {
-                            Game1.activeClickableMenu.drawBackground(Game1.spriteBatch);
-                            events.RenderingActiveMenu.RaiseEmpty();
-                            Game1.activeClickableMenu.draw(Game1.spriteBatch);
-                            events.RenderedActiveMenu.RaiseEmpty();
-                        }
-                        catch (Exception ex)
-                        {
-                            this.Monitor.Log($"The {Game1.activeClickableMenu.GetType().FullName} menu crashed while drawing itself. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
-                            Game1.activeClickableMenu.exitThisMenu();
-                        }
-                        events.Rendered.RaiseEmpty();
-                        Game1.spriteBatch.End();
-                        this.drawOverlays(Game1.spriteBatch);
-                        if ((double)Game1.options.zoomLevel != 1.0)
-                        {
-                            this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
-                            this.GraphicsDevice.Clear(this.bgColor);
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
-                            Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
-                            Game1.spriteBatch.End();
-                        }
-                        if (Game1.overlayMenu == null)
-                            return;
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        Game1.overlayMenu.draw(Game1.spriteBatch);
-                        Game1.spriteBatch.End();
-                    }
-                    else if (Game1.gameMode == (byte)11)
-                    {
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        events.Rendering.RaiseEmpty();
-                        Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3685"), new Vector2(16f, 16f), Color.HotPink);
-                        Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3686"), new Vector2(16f, 32f), new Color(0, (int)byte.MaxValue, 0));
-                        Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.parseText(Game1.errorMessage, Game1.dialogueFont, Game1.graphics.GraphicsDevice.Viewport.Width), new Vector2(16f, 48f), Color.White);
-                        events.Rendered.RaiseEmpty();
-                        Game1.spriteBatch.End();
-                    }
-                    else if (Game1.currentMinigame != null)
-                    {
-                        Game1.currentMinigame.draw(Game1.spriteBatch);
-                        if (Game1.globalFade && !Game1.menuUp && (!Game1.nameSelectUp || Game1.messagePause))
-                        {
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            Game1.spriteBatch.Draw(Game1.fadeToBlackRect, Game1.graphics.GraphicsDevice.Viewport.Bounds, Color.Black * (Game1.gameMode == (byte)0 ? 1f - Game1.fadeToBlackAlpha : Game1.fadeToBlackAlpha));
-                            Game1.spriteBatch.End();
-                        }
-                        this.drawOverlays(Game1.spriteBatch);
-                        if ((double)Game1.options.zoomLevel == 1.0)
-                            return;
-                        this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
-                        this.GraphicsDevice.Clear(this.bgColor);
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
-                        Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
-                        Game1.spriteBatch.End();
-                    }
-                    else if (Game1.showingEndOfNightStuff)
-                    {
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        events.Rendering.RaiseEmpty();
-                        if (Game1.activeClickableMenu != null)
-                        {
-                            try
-                            {
-                                events.RenderingActiveMenu.RaiseEmpty();
-                                Game1.activeClickableMenu.draw(Game1.spriteBatch);
-                                events.RenderedActiveMenu.RaiseEmpty();
-                            }
-                            catch (Exception ex)
-                            {
-                                this.Monitor.Log($"The {Game1.activeClickableMenu.GetType().FullName} menu crashed while drawing itself during end-of-night-stuff. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
-                                Game1.activeClickableMenu.exitThisMenu();
-                            }
-                        }
-                        events.Rendered.RaiseEmpty();
-                        Game1.spriteBatch.End();
-                        this.drawOverlays(Game1.spriteBatch);
-                        if ((double)Game1.options.zoomLevel == 1.0)
-                            return;
-                        this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
-                        this.GraphicsDevice.Clear(this.bgColor);
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
-                        Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
-                        Game1.spriteBatch.End();
-                    }
-                    else if (Game1.gameMode == (byte)6 || Game1.gameMode == (byte)3 && Game1.currentLocation == null)
-                    {
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        events.Rendering.RaiseEmpty();
-                        string str1 = "";
-                        for (int index = 0; (double)index < gameTime.TotalGameTime.TotalMilliseconds % 999.0 / 333.0; ++index)
-                            str1 += ".";
-                        string str2 = Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3688");
-                        string s = str2 + str1;
-                        string str3 = str2 + "... ";
-                        int widthOfString = SpriteText.getWidthOfString(str3);
-                        int height = 64;
-                        int x = 64;
-                        int y = Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea().Bottom - height;
-                        SpriteText.drawString(Game1.spriteBatch, s, x, y, 999999, widthOfString, height, 1f, 0.88f, false, 0, str3, -1);
-                        events.Rendered.RaiseEmpty();
-                        Game1.spriteBatch.End();
-                        this.drawOverlays(Game1.spriteBatch);
-                        if ((double)Game1.options.zoomLevel != 1.0)
-                        {
-                            this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
-                            this.GraphicsDevice.Clear(this.bgColor);
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
-                            Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
-                            Game1.spriteBatch.End();
-                        }
-                        if (Game1.overlayMenu != null)
-                        {
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            Game1.overlayMenu.draw(Game1.spriteBatch);
-                            Game1.spriteBatch.End();
-                        }
-                        //base.Draw(gameTime);
-                    }
-                    else
-                    {
-                        byte batchOpens = 0; // used for rendering event
+        //                events.Rendering.RaiseEmpty();
+        //                try
+        //                {
+        //                    Game1.activeClickableMenu.drawBackground(Game1.spriteBatch);
+        //                    events.RenderingActiveMenu.RaiseEmpty();
+        //                    Game1.activeClickableMenu.draw(Game1.spriteBatch);
+        //                    events.RenderedActiveMenu.RaiseEmpty();
+        //                }
+        //                catch (Exception ex)
+        //                {
+        //                    this.Monitor.Log($"The {Game1.activeClickableMenu.GetType().FullName} menu crashed while drawing itself. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
+        //                    Game1.activeClickableMenu.exitThisMenu();
+        //                }
+        //                events.Rendered.RaiseEmpty();
+        //                Game1.spriteBatch.End();
+        //                this.drawOverlays(Game1.spriteBatch);
+        //                if ((double)Game1.options.zoomLevel != 1.0)
+        //                {
+        //                    this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
+        //                    this.GraphicsDevice.Clear(this.bgColor);
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
+        //                    Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
+        //                    Game1.spriteBatch.End();
+        //                }
+        //                if (Game1.overlayMenu == null)
+        //                    return;
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                Game1.overlayMenu.draw(Game1.spriteBatch);
+        //                Game1.spriteBatch.End();
+        //            }
+        //            else if (Game1.gameMode == (byte)11)
+        //            {
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                events.Rendering.RaiseEmpty();
+        //                Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3685"), new Vector2(16f, 16f), Color.HotPink);
+        //                Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3686"), new Vector2(16f, 32f), new Color(0, (int)byte.MaxValue, 0));
+        //                Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.parseText(Game1.errorMessage, Game1.dialogueFont, Game1.graphics.GraphicsDevice.Viewport.Width), new Vector2(16f, 48f), Color.White);
+        //                events.Rendered.RaiseEmpty();
+        //                Game1.spriteBatch.End();
+        //            }
+        //            else if (Game1.currentMinigame != null)
+        //            {
+        //                Game1.currentMinigame.draw(Game1.spriteBatch);
+        //                if (Game1.globalFade && !Game1.menuUp && (!Game1.nameSelectUp || Game1.messagePause))
+        //                {
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    Game1.spriteBatch.Draw(Game1.fadeToBlackRect, Game1.graphics.GraphicsDevice.Viewport.Bounds, Color.Black * (Game1.gameMode == (byte)0 ? 1f - Game1.fadeToBlackAlpha : Game1.fadeToBlackAlpha));
+        //                    Game1.spriteBatch.End();
+        //                }
+        //                this.drawOverlays(Game1.spriteBatch);
+        //                if ((double)Game1.options.zoomLevel == 1.0)
+        //                    return;
+        //                this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
+        //                this.GraphicsDevice.Clear(this.bgColor);
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
+        //                Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
+        //                Game1.spriteBatch.End();
+        //            }
+        //            else if (Game1.showingEndOfNightStuff)
+        //            {
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                events.Rendering.RaiseEmpty();
+        //                if (Game1.activeClickableMenu != null)
+        //                {
+        //                    try
+        //                    {
+        //                        events.RenderingActiveMenu.RaiseEmpty();
+        //                        Game1.activeClickableMenu.draw(Game1.spriteBatch);
+        //                        events.RenderedActiveMenu.RaiseEmpty();
+        //                    }
+        //                    catch (Exception ex)
+        //                    {
+        //                        this.Monitor.Log($"The {Game1.activeClickableMenu.GetType().FullName} menu crashed while drawing itself during end-of-night-stuff. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
+        //                        Game1.activeClickableMenu.exitThisMenu();
+        //                    }
+        //                }
+        //                events.Rendered.RaiseEmpty();
+        //                Game1.spriteBatch.End();
+        //                this.drawOverlays(Game1.spriteBatch);
+        //                if ((double)Game1.options.zoomLevel == 1.0)
+        //                    return;
+        //                this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
+        //                this.GraphicsDevice.Clear(this.bgColor);
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
+        //                Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
+        //                Game1.spriteBatch.End();
+        //            }
+        //            else if (Game1.gameMode == (byte)6 || Game1.gameMode == (byte)3 && Game1.currentLocation == null)
+        //            {
+        //                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                events.Rendering.RaiseEmpty();
+        //                string str1 = "";
+        //                for (int index = 0; (double)index < gameTime.TotalGameTime.TotalMilliseconds % 999.0 / 333.0; ++index)
+        //                    str1 += ".";
+        //                string str2 = Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3688");
+        //                string s = str2 + str1;
+        //                string str3 = str2 + "... ";
+        //                int widthOfString = SpriteText.getWidthOfString(str3);
+        //                int height = 64;
+        //                int x = 64;
+        //                int y = Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea().Bottom - height;
+        //                SpriteText.drawString(Game1.spriteBatch, s, x, y, 999999, widthOfString, height, 1f, 0.88f, false, 0, str3, -1);
+        //                events.Rendered.RaiseEmpty();
+        //                Game1.spriteBatch.End();
+        //                this.drawOverlays(Game1.spriteBatch);
+        //                if ((double)Game1.options.zoomLevel != 1.0)
+        //                {
+        //                    this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
+        //                    this.GraphicsDevice.Clear(this.bgColor);
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone);
+        //                    Game1.spriteBatch.Draw((Texture2D)this.screen, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screen.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
+        //                    Game1.spriteBatch.End();
+        //                }
+        //                if (Game1.overlayMenu != null)
+        //                {
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    Game1.overlayMenu.draw(Game1.spriteBatch);
+        //                    Game1.spriteBatch.End();
+        //                }
+        //                //base.Draw(gameTime);
+        //            }
+        //            else
+        //            {
+        //                byte batchOpens = 0; // used for rendering event
 
-                        Microsoft.Xna.Framework.Rectangle rectangle;
-                        Viewport viewport;
-                        if (Game1.gameMode == (byte)0)
-                        {
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            if (++batchOpens == 1)
-                                events.Rendering.RaiseEmpty();
-                        }
-                        else
-                        {
-                            if (Game1.drawLighting)
-                            {
-                                this.GraphicsDevice.SetRenderTarget(Game1.lightmap);
-                                this.GraphicsDevice.Clear(Color.White * 0.0f);
-                                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                                if (++batchOpens == 1)
-                                    events.Rendering.RaiseEmpty();
-                                Game1.spriteBatch.Draw(Game1.staminaRect, Game1.lightmap.Bounds, Game1.currentLocation.Name.StartsWith("UndergroundMine") ? Game1.mine.getLightingColor(gameTime) : (Game1.ambientLight.Equals(Color.White) || Game1.isRaining && (bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.isOutdoors) ? Game1.outdoorLight : Game1.ambientLight));
-                                for (int index = 0; index < Game1.currentLightSources.Count; ++index)
-                                {
-                                    if (Utility.isOnScreen((Vector2)((NetFieldBase<Vector2, NetVector2>)Game1.currentLightSources.ElementAt<LightSource>(index).position), (int)((double)(float)((NetFieldBase<float, NetFloat>)Game1.currentLightSources.ElementAt<LightSource>(index).radius) * 64.0 * 4.0)))
-                                        Game1.spriteBatch.Draw(Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture, Game1.GlobalToLocal(Game1.viewport, (Vector2)((NetFieldBase<Vector2, NetVector2>)Game1.currentLightSources.ElementAt<LightSource>(index).position)) / (float)(Game1.options.lightingQuality / 2), new Microsoft.Xna.Framework.Rectangle?(Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture.Bounds), (Color)((NetFieldBase<Color, NetColor>)Game1.currentLightSources.ElementAt<LightSource>(index).color), 0.0f, new Vector2((float)Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture.Bounds.Center.X, (float)Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture.Bounds.Center.Y), (float)((NetFieldBase<float, NetFloat>)Game1.currentLightSources.ElementAt<LightSource>(index).radius) / (float)(Game1.options.lightingQuality / 2), SpriteEffects.None, 0.9f);
-                                }
-                                Game1.spriteBatch.End();
-                                this.GraphicsDevice.SetRenderTarget((double)Game1.options.zoomLevel == 1.0 ? (RenderTarget2D)null : this.screen);
-                            }
-                            if (Game1.bloomDay && Game1.bloom != null)
-                                Game1.bloom.BeginDraw();
-                            this.GraphicsDevice.Clear(this.bgColor);
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            if (++batchOpens == 1)
-                                events.Rendering.RaiseEmpty();
-                            events.RenderingWorld.RaiseEmpty();
-                            if (Game1.background != null)
-                                Game1.background.draw(Game1.spriteBatch);
-                            Game1.mapDisplayDevice.BeginScene(Game1.spriteBatch);
-                            Game1.currentLocation.Map.GetLayer("Back").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
-                            Game1.currentLocation.drawWater(Game1.spriteBatch);
-                            this._farmerShadows.Clear();
-                            if (Game1.currentLocation.currentEvent != null && !Game1.currentLocation.currentEvent.isFestival && Game1.currentLocation.currentEvent.farmerActors.Count > 0)
-                            {
-                                foreach (Farmer farmerActor in Game1.currentLocation.currentEvent.farmerActors)
-                                {
-                                    if (farmerActor.IsLocalPlayer && Game1.displayFarmer || !(bool)((NetFieldBase<bool, NetBool>)farmerActor.hidden))
-                                        this._farmerShadows.Add(farmerActor);
-                                }
-                            }
-                            else
-                            {
-                                foreach (Farmer farmer in Game1.currentLocation.farmers)
-                                {
-                                    if (farmer.IsLocalPlayer && Game1.displayFarmer || !(bool)((NetFieldBase<bool, NetBool>)farmer.hidden))
-                                        this._farmerShadows.Add(farmer);
-                                }
-                            }
-                            if (!Game1.currentLocation.shouldHideCharacters())
-                            {
-                                if (Game1.CurrentEvent == null)
-                                {
-                                    foreach (NPC character in Game1.currentLocation.characters)
-                                    {
-                                        if (!(bool)((NetFieldBase<bool, NetBool>)character.swimming) && !character.HideShadow && (!character.IsInvisible && !Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(character.getTileLocation())))
-                                            Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, character.Position + new Vector2((float)(character.Sprite.SpriteWidth * 4) / 2f, (float)(character.GetBoundingBox().Height + (character.IsMonster ? 0 : 12)))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)character.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)character.scale), SpriteEffects.None, Math.Max(0.0f, (float)character.getStandingY() / 10000f) - 1E-06f);
-                                    }
-                                }
-                                else
-                                {
-                                    foreach (NPC actor in Game1.CurrentEvent.actors)
-                                    {
-                                        if (!(bool)((NetFieldBase<bool, NetBool>)actor.swimming) && !actor.HideShadow && !Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(actor.getTileLocation()))
-                                            Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, actor.Position + new Vector2((float)(actor.Sprite.SpriteWidth * 4) / 2f, (float)(actor.GetBoundingBox().Height + (actor.IsMonster ? 0 : (actor.Sprite.SpriteHeight <= 16 ? -4 : 12))))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)actor.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)actor.scale), SpriteEffects.None, Math.Max(0.0f, (float)actor.getStandingY() / 10000f) - 1E-06f);
-                                    }
-                                }
-                                foreach (Farmer farmerShadow in this._farmerShadows)
-                                {
-                                    if (!(bool)((NetFieldBase<bool, NetBool>)farmerShadow.swimming) && !farmerShadow.isRidingHorse() && (Game1.currentLocation == null || !Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(farmerShadow.getTileLocation())))
-                                    {
-                                        SpriteBatch spriteBatch = Game1.spriteBatch;
-                                        Texture2D shadowTexture = Game1.shadowTexture;
-                                        Vector2 local = Game1.GlobalToLocal(farmerShadow.Position + new Vector2(32f, 24f));
-                                        Microsoft.Xna.Framework.Rectangle? sourceRectangle = new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds);
-                                        Color white = Color.White;
-                                        double num1 = 0.0;
-                                        Microsoft.Xna.Framework.Rectangle bounds = Game1.shadowTexture.Bounds;
-                                        double x = (double)bounds.Center.X;
-                                        bounds = Game1.shadowTexture.Bounds;
-                                        double y = (double)bounds.Center.Y;
-                                        Vector2 origin = new Vector2((float)x, (float)y);
-                                        double num2 = 4.0 - (!farmerShadow.running && !farmerShadow.UsingTool || farmerShadow.FarmerSprite.currentAnimationIndex <= 1 ? 0.0 : (double)Math.Abs(FarmerRenderer.featureYOffsetPerFrame[farmerShadow.FarmerSprite.CurrentFrame]) * 0.5);
-                                        int num3 = 0;
-                                        double num4 = 0.0;
-                                        spriteBatch.Draw(shadowTexture, local, sourceRectangle, white, (float)num1, origin, (float)num2, (SpriteEffects)num3, (float)num4);
-                                    }
-                                }
-                            }
-                            Game1.currentLocation.Map.GetLayer("Buildings").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
-                            Game1.mapDisplayDevice.EndScene();
-                            Game1.spriteBatch.End();
-                            Game1.spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            if (!Game1.currentLocation.shouldHideCharacters())
-                            {
-                                if (Game1.CurrentEvent == null)
-                                {
-                                    foreach (NPC character in Game1.currentLocation.characters)
-                                    {
-                                        if (!(bool)((NetFieldBase<bool, NetBool>)character.swimming) && !character.HideShadow && Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(character.getTileLocation()))
-                                            Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, character.Position + new Vector2((float)(character.Sprite.SpriteWidth * 4) / 2f, (float)(character.GetBoundingBox().Height + (character.IsMonster ? 0 : 12)))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)character.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)character.scale), SpriteEffects.None, Math.Max(0.0f, (float)character.getStandingY() / 10000f) - 1E-06f);
-                                    }
-                                }
-                                else
-                                {
-                                    foreach (NPC actor in Game1.CurrentEvent.actors)
-                                    {
-                                        if (!(bool)((NetFieldBase<bool, NetBool>)actor.swimming) && !actor.HideShadow && Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(actor.getTileLocation()))
-                                            Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, actor.Position + new Vector2((float)(actor.Sprite.SpriteWidth * 4) / 2f, (float)(actor.GetBoundingBox().Height + (actor.IsMonster ? 0 : 12)))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)actor.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)actor.scale), SpriteEffects.None, Math.Max(0.0f, (float)actor.getStandingY() / 10000f) - 1E-06f);
-                                    }
-                                }
-                                foreach (Farmer farmerShadow in this._farmerShadows)
-                                {
-                                    if (!(bool)((NetFieldBase<bool, NetBool>)farmerShadow.swimming) && !farmerShadow.isRidingHorse() && (Game1.currentLocation != null && Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(farmerShadow.getTileLocation())))
-                                    {
-                                        SpriteBatch spriteBatch = Game1.spriteBatch;
-                                        Texture2D shadowTexture = Game1.shadowTexture;
-                                        Vector2 local = Game1.GlobalToLocal(farmerShadow.Position + new Vector2(32f, 24f));
-                                        Microsoft.Xna.Framework.Rectangle? sourceRectangle = new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds);
-                                        Color white = Color.White;
-                                        double num1 = 0.0;
-                                        Microsoft.Xna.Framework.Rectangle bounds = Game1.shadowTexture.Bounds;
-                                        double x = (double)bounds.Center.X;
-                                        bounds = Game1.shadowTexture.Bounds;
-                                        double y = (double)bounds.Center.Y;
-                                        Vector2 origin = new Vector2((float)x, (float)y);
-                                        double num2 = 4.0 - (!farmerShadow.running && !farmerShadow.UsingTool || farmerShadow.FarmerSprite.currentAnimationIndex <= 1 ? 0.0 : (double)Math.Abs(FarmerRenderer.featureYOffsetPerFrame[farmerShadow.FarmerSprite.CurrentFrame]) * 0.5);
-                                        int num3 = 0;
-                                        double num4 = 0.0;
-                                        spriteBatch.Draw(shadowTexture, local, sourceRectangle, white, (float)num1, origin, (float)num2, (SpriteEffects)num3, (float)num4);
-                                    }
-                                }
-                            }
-                            if ((Game1.eventUp || Game1.killScreen) && (!Game1.killScreen && Game1.currentLocation.currentEvent != null))
-                                Game1.currentLocation.currentEvent.draw(Game1.spriteBatch);
-                            if (Game1.player.currentUpgrade != null && Game1.player.currentUpgrade.daysLeftTillUpgradeDone <= 3 && Game1.currentLocation.Name.Equals("Farm"))
-                                Game1.spriteBatch.Draw(Game1.player.currentUpgrade.workerTexture, Game1.GlobalToLocal(Game1.viewport, Game1.player.currentUpgrade.positionOfCarpenter), new Microsoft.Xna.Framework.Rectangle?(Game1.player.currentUpgrade.getSourceRectangle()), Color.White, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, (float)(((double)Game1.player.currentUpgrade.positionOfCarpenter.Y + 48.0) / 10000.0));
-                            Game1.currentLocation.draw(Game1.spriteBatch);
-                            if (Game1.eventUp && Game1.currentLocation.currentEvent != null)
-                            {
-                                string messageToScreen = Game1.currentLocation.currentEvent.messageToScreen;
-                            }
-                            if (Game1.player.ActiveObject == null && (Game1.player.UsingTool || Game1.pickingTool) && (Game1.player.CurrentTool != null && (!Game1.player.CurrentTool.Name.Equals("Seeds") || Game1.pickingTool)))
-                                Game1.drawTool(Game1.player);
-                            if (Game1.currentLocation.Name.Equals("Farm"))
-                                this.drawFarmBuildings();
-                            if (Game1.tvStation >= 0)
-                                Game1.spriteBatch.Draw(Game1.tvStationTexture, Game1.GlobalToLocal(Game1.viewport, new Vector2(400f, 160f)), new Microsoft.Xna.Framework.Rectangle?(new Microsoft.Xna.Framework.Rectangle(Game1.tvStation * 24, 0, 24, 15)), Color.White, 0.0f, Vector2.Zero, 4f, SpriteEffects.None, 1E-08f);
-                            if (Game1.panMode)
-                            {
-                                Game1.spriteBatch.Draw(Game1.fadeToBlackRect, new Microsoft.Xna.Framework.Rectangle((int)Math.Floor((double)(Game1.getOldMouseX() + Game1.viewport.X) / 64.0) * 64 - Game1.viewport.X, (int)Math.Floor((double)(Game1.getOldMouseY() + Game1.viewport.Y) / 64.0) * 64 - Game1.viewport.Y, 64, 64), Color.Lime * 0.75f);
-                                foreach (Warp warp in (NetList<Warp, NetRef<Warp>>)Game1.currentLocation.warps)
-                                    Game1.spriteBatch.Draw(Game1.fadeToBlackRect, new Microsoft.Xna.Framework.Rectangle(warp.X * 64 - Game1.viewport.X, warp.Y * 64 - Game1.viewport.Y, 64, 64), Color.Red * 0.75f);
-                            }
-                            Game1.mapDisplayDevice.BeginScene(Game1.spriteBatch);
-                            Game1.currentLocation.Map.GetLayer("Front").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
-                            Game1.mapDisplayDevice.EndScene();
-                            Game1.currentLocation.drawAboveFrontLayer(Game1.spriteBatch);
-                            Game1.spriteBatch.End();
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            if (Game1.displayFarmer && Game1.player.ActiveObject != null && ((bool)((NetFieldBase<bool, NetBool>)Game1.player.ActiveObject.bigCraftable) && this.checkBigCraftableBoundariesForFrontLayer()) && Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location(Game1.player.getStandingX(), Game1.player.getStandingY()), Game1.viewport.Size) == null)
-                                Game1.drawPlayerHeldObject(Game1.player);
-                            else if (Game1.displayFarmer && Game1.player.ActiveObject != null)
-                            {
-                                if (Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location((int)Game1.player.Position.X, (int)Game1.player.Position.Y - 38), Game1.viewport.Size) == null || Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location((int)Game1.player.Position.X, (int)Game1.player.Position.Y - 38), Game1.viewport.Size).TileIndexProperties.ContainsKey("FrontAlways"))
-                                {
-                                    Layer layer1 = Game1.currentLocation.Map.GetLayer("Front");
-                                    rectangle = Game1.player.GetBoundingBox();
-                                    Location mapDisplayLocation1 = new Location(rectangle.Right, (int)Game1.player.Position.Y - 38);
-                                    Size size1 = Game1.viewport.Size;
-                                    if (layer1.PickTile(mapDisplayLocation1, size1) != null)
-                                    {
-                                        Layer layer2 = Game1.currentLocation.Map.GetLayer("Front");
-                                        rectangle = Game1.player.GetBoundingBox();
-                                        Location mapDisplayLocation2 = new Location(rectangle.Right, (int)Game1.player.Position.Y - 38);
-                                        Size size2 = Game1.viewport.Size;
-                                        if (layer2.PickTile(mapDisplayLocation2, size2).TileIndexProperties.ContainsKey("FrontAlways"))
-                                            goto label_129;
-                                    }
-                                    else
-                                        goto label_129;
-                                }
-                                Game1.drawPlayerHeldObject(Game1.player);
-                            }
-                            label_129:
-                            if ((Game1.player.UsingTool || Game1.pickingTool) && Game1.player.CurrentTool != null && ((!Game1.player.CurrentTool.Name.Equals("Seeds") || Game1.pickingTool) && (Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location(Game1.player.getStandingX(), (int)Game1.player.Position.Y - 38), Game1.viewport.Size) != null && Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location(Game1.player.getStandingX(), Game1.player.getStandingY()), Game1.viewport.Size) == null)))
-                                Game1.drawTool(Game1.player);
-                            if (Game1.currentLocation.Map.GetLayer("AlwaysFront") != null)
-                            {
-                                Game1.mapDisplayDevice.BeginScene(Game1.spriteBatch);
-                                Game1.currentLocation.Map.GetLayer("AlwaysFront").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
-                                Game1.mapDisplayDevice.EndScene();
-                            }
-                            if ((double)Game1.toolHold > 400.0 && Game1.player.CurrentTool.UpgradeLevel >= 1 && Game1.player.canReleaseTool)
-                            {
-                                Color color = Color.White;
-                                switch ((int)((double)Game1.toolHold / 600.0) + 2)
-                                {
-                                    case 1:
-                                        color = Tool.copperColor;
-                                        break;
-                                    case 2:
-                                        color = Tool.steelColor;
-                                        break;
-                                    case 3:
-                                        color = Tool.goldColor;
-                                        break;
-                                    case 4:
-                                        color = Tool.iridiumColor;
-                                        break;
-                                }
-                                Game1.spriteBatch.Draw(Game1.littleEffect, new Microsoft.Xna.Framework.Rectangle((int)Game1.player.getLocalPosition(Game1.viewport).X - 2, (int)Game1.player.getLocalPosition(Game1.viewport).Y - (Game1.player.CurrentTool.Name.Equals("Watering Can") ? 0 : 64) - 2, (int)((double)Game1.toolHold % 600.0 * 0.0799999982118607) + 4, 12), Color.Black);
-                                Game1.spriteBatch.Draw(Game1.littleEffect, new Microsoft.Xna.Framework.Rectangle((int)Game1.player.getLocalPosition(Game1.viewport).X, (int)Game1.player.getLocalPosition(Game1.viewport).Y - (Game1.player.CurrentTool.Name.Equals("Watering Can") ? 0 : 64), (int)((double)Game1.toolHold % 600.0 * 0.0799999982118607), 8), color);
-                            }
-                            if (Game1.isDebrisWeather && Game1.currentLocation.IsOutdoors && (!(bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.ignoreDebrisWeather) && !Game1.currentLocation.Name.Equals("Desert")) && Game1.viewport.X > -10)
-                            {
-                                foreach (WeatherDebris weatherDebris in Game1.debrisWeather)
-                                    weatherDebris.draw(Game1.spriteBatch);
-                            }
-                            if (Game1.farmEvent != null)
-                                Game1.farmEvent.draw(Game1.spriteBatch);
-                            if ((double)Game1.currentLocation.LightLevel > 0.0 && Game1.timeOfDay < 2000)
-                            {
-                                SpriteBatch spriteBatch = Game1.spriteBatch;
-                                Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
-                                viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
-                                Color color = Color.Black * Game1.currentLocation.LightLevel;
-                                spriteBatch.Draw(fadeToBlackRect, bounds, color);
-                            }
-                            if (Game1.screenGlow)
-                            {
-                                SpriteBatch spriteBatch = Game1.spriteBatch;
-                                Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
-                                viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
-                                Color color = Game1.screenGlowColor * Game1.screenGlowAlpha;
-                                spriteBatch.Draw(fadeToBlackRect, bounds, color);
-                            }
-                            Game1.currentLocation.drawAboveAlwaysFrontLayer(Game1.spriteBatch);
-                            if (Game1.player.CurrentTool != null && Game1.player.CurrentTool is FishingRod && ((Game1.player.CurrentTool as FishingRod).isTimingCast || (double)(Game1.player.CurrentTool as FishingRod).castingChosenCountdown > 0.0 || ((Game1.player.CurrentTool as FishingRod).fishCaught || (Game1.player.CurrentTool as FishingRod).showingTreasure)))
-                                Game1.player.CurrentTool.draw(Game1.spriteBatch);
-                            if (Game1.isRaining && Game1.currentLocation.IsOutdoors && (!Game1.currentLocation.Name.Equals("Desert") && !(Game1.currentLocation is Summit)) && (!Game1.eventUp || Game1.currentLocation.isTileOnMap(new Vector2((float)(Game1.viewport.X / 64), (float)(Game1.viewport.Y / 64)))))
-                            {
-                                for (int index = 0; index < Game1.rainDrops.Length; ++index)
-                                    Game1.spriteBatch.Draw(Game1.rainTexture, Game1.rainDrops[index].position, new Microsoft.Xna.Framework.Rectangle?(Game1.getSourceRectForStandardTileSheet(Game1.rainTexture, Game1.rainDrops[index].frame, -1, -1)), Color.White);
-                            }
-                            Game1.spriteBatch.End();
-                            Game1.spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            if (Game1.eventUp && Game1.currentLocation.currentEvent != null)
-                            {
-                                foreach (NPC actor in Game1.currentLocation.currentEvent.actors)
-                                {
-                                    if (actor.isEmoting)
-                                    {
-                                        Vector2 localPosition = actor.getLocalPosition(Game1.viewport);
-                                        localPosition.Y -= 140f;
-                                        if (actor.Age == 2)
-                                            localPosition.Y += 32f;
-                                        else if (actor.Gender == 1)
-                                            localPosition.Y += 10f;
-                                        Game1.spriteBatch.Draw(Game1.emoteSpriteSheet, localPosition, new Microsoft.Xna.Framework.Rectangle?(new Microsoft.Xna.Framework.Rectangle(actor.CurrentEmoteIndex * 16 % Game1.emoteSpriteSheet.Width, actor.CurrentEmoteIndex * 16 / Game1.emoteSpriteSheet.Width * 16, 16, 16)), Color.White, 0.0f, Vector2.Zero, 4f, SpriteEffects.None, (float)actor.getStandingY() / 10000f);
-                                    }
-                                }
-                            }
-                            Game1.spriteBatch.End();
-                            if (Game1.drawLighting)
-                            {
-                                Game1.spriteBatch.Begin(SpriteSortMode.Deferred, this.lightingBlend, SamplerState.LinearClamp, (DepthStencilState)null, (RasterizerState)null);
-                                Game1.spriteBatch.Draw((Texture2D)Game1.lightmap, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(Game1.lightmap.Bounds), Color.White, 0.0f, Vector2.Zero, (float)(Game1.options.lightingQuality / 2), SpriteEffects.None, 1f);
-                                if (Game1.isRaining && (bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.isOutdoors) && !(Game1.currentLocation is Desert))
-                                {
-                                    SpriteBatch spriteBatch = Game1.spriteBatch;
-                                    Texture2D staminaRect = Game1.staminaRect;
-                                    viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                    Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
-                                    Color color = Color.OrangeRed * 0.45f;
-                                    spriteBatch.Draw(staminaRect, bounds, color);
-                                }
-                                Game1.spriteBatch.End();
-                            }
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                            events.RenderedWorld.RaiseEmpty();
-                            if (Game1.drawGrid)
-                            {
-                                int num1 = -Game1.viewport.X % 64;
-                                float num2 = (float)(-Game1.viewport.Y % 64);
-                                int num3 = num1;
-                                while (true)
-                                {
-                                    int num4 = num3;
-                                    viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                    int width1 = viewport.Width;
-                                    if (num4 < width1)
-                                    {
-                                        SpriteBatch spriteBatch = Game1.spriteBatch;
-                                        Texture2D staminaRect = Game1.staminaRect;
-                                        int x = num3;
-                                        int y = (int)num2;
-                                        int width2 = 1;
-                                        viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                        int height = viewport.Height;
-                                        Microsoft.Xna.Framework.Rectangle destinationRectangle = new Microsoft.Xna.Framework.Rectangle(x, y, width2, height);
-                                        Color color = Color.Red * 0.5f;
-                                        spriteBatch.Draw(staminaRect, destinationRectangle, color);
-                                        num3 += 64;
-                                    }
-                                    else
-                                        break;
-                                }
-                                float num5 = num2;
-                                while (true)
-                                {
-                                    double num4 = (double)num5;
-                                    viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                    double height1 = (double)viewport.Height;
-                                    if (num4 < height1)
-                                    {
-                                        SpriteBatch spriteBatch = Game1.spriteBatch;
-                                        Texture2D staminaRect = Game1.staminaRect;
-                                        int x = num1;
-                                        int y = (int)num5;
-                                        viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                        int width = viewport.Width;
-                                        int height2 = 1;
-                                        Microsoft.Xna.Framework.Rectangle destinationRectangle = new Microsoft.Xna.Framework.Rectangle(x, y, width, height2);
-                                        Color color = Color.Red * 0.5f;
-                                        spriteBatch.Draw(staminaRect, destinationRectangle, color);
-                                        num5 += 64f;
-                                    }
-                                    else
-                                        break;
-                                }
-                            }
-                            if (Game1.currentBillboard != 0)
-                                this.drawBillboard();
-                            if ((Game1.displayHUD || Game1.eventUp) && (Game1.currentBillboard == 0 && Game1.gameMode == (byte)3) && (!Game1.freezeControls && !Game1.panMode && !Game1.HostPaused))
-                            {
-                                events.RenderingHud.RaiseEmpty();
-                                this.drawHUD();
-                                events.RenderedHud.RaiseEmpty();
-                            }
-                            else if (Game1.activeClickableMenu == null && Game1.farmEvent == null)
-                                Game1.spriteBatch.Draw(Game1.mouseCursors, new Vector2((float)Game1.getOldMouseX(), (float)Game1.getOldMouseY()), new Microsoft.Xna.Framework.Rectangle?(Game1.getSourceRectForStandardTileSheet(Game1.mouseCursors, 0, 16, 16)), Color.White, 0.0f, Vector2.Zero, (float)(4.0 + (double)Game1.dialogueButtonScale / 150.0), SpriteEffects.None, 1f);
-                            if (Game1.hudMessages.Count > 0 && (!Game1.eventUp || Game1.isFestival()))
-                            {
-                                for (int i = Game1.hudMessages.Count - 1; i >= 0; --i)
-                                    Game1.hudMessages[i].draw(Game1.spriteBatch, i);
-                            }
-                        }
-                        if (Game1.farmEvent != null)
-                            Game1.farmEvent.draw(Game1.spriteBatch);
-                        if (Game1.dialogueUp && !Game1.nameSelectUp && !Game1.messagePause && (Game1.activeClickableMenu == null || !(Game1.activeClickableMenu is DialogueBox)))
-                            this.drawDialogueBox();
-                        if (Game1.progressBar)
-                        {
-                            SpriteBatch spriteBatch1 = Game1.spriteBatch;
-                            Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
-                            int x1 = (Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea().Width - Game1.dialogueWidth) / 2;
-                            rectangle = Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea();
-                            int y1 = rectangle.Bottom - 128;
-                            int dialogueWidth = Game1.dialogueWidth;
-                            int height1 = 32;
-                            Microsoft.Xna.Framework.Rectangle destinationRectangle1 = new Microsoft.Xna.Framework.Rectangle(x1, y1, dialogueWidth, height1);
-                            Color lightGray = Color.LightGray;
-                            spriteBatch1.Draw(fadeToBlackRect, destinationRectangle1, lightGray);
-                            SpriteBatch spriteBatch2 = Game1.spriteBatch;
-                            Texture2D staminaRect = Game1.staminaRect;
-                            int x2 = (Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea().Width - Game1.dialogueWidth) / 2;
-                            rectangle = Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea();
-                            int y2 = rectangle.Bottom - 128;
-                            int width = (int)((double)Game1.pauseAccumulator / (double)Game1.pauseTime * (double)Game1.dialogueWidth);
-                            int height2 = 32;
-                            Microsoft.Xna.Framework.Rectangle destinationRectangle2 = new Microsoft.Xna.Framework.Rectangle(x2, y2, width, height2);
-                            Color dimGray = Color.DimGray;
-                            spriteBatch2.Draw(staminaRect, destinationRectangle2, dimGray);
-                        }
-                        if (Game1.eventUp && Game1.currentLocation != null && Game1.currentLocation.currentEvent != null)
-                            Game1.currentLocation.currentEvent.drawAfterMap(Game1.spriteBatch);
-                        if (Game1.isRaining && Game1.currentLocation != null && ((bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.isOutdoors) && !(Game1.currentLocation is Desert)))
-                        {
-                            SpriteBatch spriteBatch = Game1.spriteBatch;
-                            Texture2D staminaRect = Game1.staminaRect;
-                            viewport = Game1.graphics.GraphicsDevice.Viewport;
-                            Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
-                            Color color = Color.Blue * 0.2f;
-                            spriteBatch.Draw(staminaRect, bounds, color);
-                        }
-                        if ((Game1.fadeToBlack || Game1.globalFade) && !Game1.menuUp && (!Game1.nameSelectUp || Game1.messagePause))
-                        {
-                            SpriteBatch spriteBatch = Game1.spriteBatch;
-                            Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
-                            viewport = Game1.graphics.GraphicsDevice.Viewport;
-                            Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
-                            Color color = Color.Black * (Game1.gameMode == (byte)0 ? 1f - Game1.fadeToBlackAlpha : Game1.fadeToBlackAlpha);
-                            spriteBatch.Draw(fadeToBlackRect, bounds, color);
-                        }
-                        else if ((double)Game1.flashAlpha > 0.0)
-                        {
-                            if (Game1.options.screenFlash)
-                            {
-                                SpriteBatch spriteBatch = Game1.spriteBatch;
-                                Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
-                                viewport = Game1.graphics.GraphicsDevice.Viewport;
-                                Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
-                                Color color = Color.White * Math.Min(1f, Game1.flashAlpha);
-                                spriteBatch.Draw(fadeToBlackRect, bounds, color);
-                            }
-                            Game1.flashAlpha -= 0.1f;
-                        }
-                        if ((Game1.messagePause || Game1.globalFade) && Game1.dialogueUp)
-                            this.drawDialogueBox();
-                        foreach (TemporaryAnimatedSprite overlayTempSprite in Game1.screenOverlayTempSprites)
-                            overlayTempSprite.draw(Game1.spriteBatch, true, 0, 0, 1f);
-                        if (Game1.debugMode)
-                        {
-                            StringBuilder debugStringBuilder = Game1._debugStringBuilder;
-                            debugStringBuilder.Clear();
-                            if (Game1.panMode)
-                            {
-                                debugStringBuilder.Append((Game1.getOldMouseX() + Game1.viewport.X) / 64);
-                                debugStringBuilder.Append(",");
-                                debugStringBuilder.Append((Game1.getOldMouseY() + Game1.viewport.Y) / 64);
-                            }
-                            else
-                            {
-                                debugStringBuilder.Append("player: ");
-                                debugStringBuilder.Append(Game1.player.getStandingX() / 64);
-                                debugStringBuilder.Append(", ");
-                                debugStringBuilder.Append(Game1.player.getStandingY() / 64);
-                            }
-                            debugStringBuilder.Append(" mouseTransparency: ");
-                            debugStringBuilder.Append(Game1.mouseCursorTransparency);
-                            debugStringBuilder.Append(" mousePosition: ");
-                            debugStringBuilder.Append(Game1.getMouseX());
-                            debugStringBuilder.Append(",");
-                            debugStringBuilder.Append(Game1.getMouseY());
-                            debugStringBuilder.Append(Environment.NewLine);
-                            debugStringBuilder.Append("debugOutput: ");
-                            debugStringBuilder.Append(Game1.debugOutput);
-                            Game1.spriteBatch.DrawString(Game1.smallFont, debugStringBuilder, new Vector2((float)this.GraphicsDevice.Viewport.GetTitleSafeArea().X, (float)(this.GraphicsDevice.Viewport.GetTitleSafeArea().Y + Game1.smallFont.LineSpacing * 8)), Color.Red, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.9999999f);
-                        }
-                        if (Game1.showKeyHelp)
-                            Game1.spriteBatch.DrawString(Game1.smallFont, Game1.keyHelpString, new Vector2(64f, (float)(Game1.viewport.Height - 64 - (Game1.dialogueUp ? 192 + (Game1.isQuestion ? Game1.questionChoices.Count * 64 : 0) : 0)) - Game1.smallFont.MeasureString(Game1.keyHelpString).Y), Color.LightGray, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.9999999f);
-                        if (Game1.activeClickableMenu != null)
-                        {
-                            try
-                            {
-                                events.RenderingActiveMenu.RaiseEmpty();
-                                Game1.activeClickableMenu.draw(Game1.spriteBatch);
-                                events.RenderedActiveMenu.RaiseEmpty();
-                            }
-                            catch (Exception ex)
-                            {
-                                this.Monitor.Log($"The {Game1.activeClickableMenu.GetType().FullName} menu crashed while drawing itself. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
-                                Game1.activeClickableMenu.exitThisMenu();
-                            }
-                        }
-                        else if (Game1.farmEvent != null)
-                            Game1.farmEvent.drawAboveEverything(Game1.spriteBatch);
-                        if (Game1.HostPaused)
-                        {
-                            string s = Game1.content.LoadString("Strings\\StringsFromCSFiles:DayTimeMoneyBox.cs.10378");
-                            SpriteText.drawStringWithScrollBackground(Game1.spriteBatch, s, 96, 32, "", 1f, -1);
-                        }
+        //                Microsoft.Xna.Framework.Rectangle rectangle;
+        //                Viewport viewport;
+        //                if (Game1.gameMode == (byte)0)
+        //                {
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    if (++batchOpens == 1)
+        //                        events.Rendering.RaiseEmpty();
+        //                }
+        //                else
+        //                {
+        //                    if (Game1.drawLighting)
+        //                    {
+        //                        this.GraphicsDevice.SetRenderTarget(Game1.lightmap);
+        //                        this.GraphicsDevice.Clear(Color.White * 0.0f);
+        //                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                        if (++batchOpens == 1)
+        //                            events.Rendering.RaiseEmpty();
+        //                        Game1.spriteBatch.Draw(Game1.staminaRect, Game1.lightmap.Bounds, Game1.currentLocation.Name.StartsWith("UndergroundMine") ? Game1.mine.getLightingColor(gameTime) : (Game1.ambientLight.Equals(Color.White) || Game1.isRaining && (bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.isOutdoors) ? Game1.outdoorLight : Game1.ambientLight));
+        //                        for (int index = 0; index < Game1.currentLightSources.Count; ++index)
+        //                        {
+        //                            if (Utility.isOnScreen((Vector2)((NetFieldBase<Vector2, NetVector2>)Game1.currentLightSources.ElementAt<LightSource>(index).position), (int)((double)(float)((NetFieldBase<float, NetFloat>)Game1.currentLightSources.ElementAt<LightSource>(index).radius) * 64.0 * 4.0)))
+        //                                Game1.spriteBatch.Draw(Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture, Game1.GlobalToLocal(Game1.viewport, (Vector2)((NetFieldBase<Vector2, NetVector2>)Game1.currentLightSources.ElementAt<LightSource>(index).position)) / (float)(Game1.options.lightingQuality / 2), new Microsoft.Xna.Framework.Rectangle?(Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture.Bounds), (Color)((NetFieldBase<Color, NetColor>)Game1.currentLightSources.ElementAt<LightSource>(index).color), 0.0f, new Vector2((float)Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture.Bounds.Center.X, (float)Game1.currentLightSources.ElementAt<LightSource>(index).lightTexture.Bounds.Center.Y), (float)((NetFieldBase<float, NetFloat>)Game1.currentLightSources.ElementAt<LightSource>(index).radius) / (float)(Game1.options.lightingQuality / 2), SpriteEffects.None, 0.9f);
+        //                        }
+        //                        Game1.spriteBatch.End();
+        //                        this.GraphicsDevice.SetRenderTarget((double)Game1.options.zoomLevel == 1.0 ? (RenderTarget2D)null : this.screen);
+        //                    }
+        //                    if (Game1.bloomDay && Game1.bloom != null)
+        //                        Game1.bloom.BeginDraw();
+        //                    this.GraphicsDevice.Clear(this.bgColor);
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    if (++batchOpens == 1)
+        //                        events.Rendering.RaiseEmpty();
+        //                    events.RenderingWorld.RaiseEmpty();
+        //                    if (Game1.background != null)
+        //                        Game1.background.draw(Game1.spriteBatch);
+        //                    Game1.mapDisplayDevice.BeginScene(Game1.spriteBatch);
+        //                    Game1.currentLocation.Map.GetLayer("Back").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
+        //                    Game1.currentLocation.drawWater(Game1.spriteBatch);
+        //                    this._farmerShadows.Clear();
+        //                    if (Game1.currentLocation.currentEvent != null && !Game1.currentLocation.currentEvent.isFestival && Game1.currentLocation.currentEvent.farmerActors.Count > 0)
+        //                    {
+        //                        foreach (Farmer farmerActor in Game1.currentLocation.currentEvent.farmerActors)
+        //                        {
+        //                            if (farmerActor.IsLocalPlayer && Game1.displayFarmer || !(bool)((NetFieldBase<bool, NetBool>)farmerActor.hidden))
+        //                                this._farmerShadows.Add(farmerActor);
+        //                        }
+        //                    }
+        //                    else
+        //                    {
+        //                        foreach (Farmer farmer in Game1.currentLocation.farmers)
+        //                        {
+        //                            if (farmer.IsLocalPlayer && Game1.displayFarmer || !(bool)((NetFieldBase<bool, NetBool>)farmer.hidden))
+        //                                this._farmerShadows.Add(farmer);
+        //                        }
+        //                    }
+        //                    if (!Game1.currentLocation.shouldHideCharacters())
+        //                    {
+        //                        if (Game1.CurrentEvent == null)
+        //                        {
+        //                            foreach (NPC character in Game1.currentLocation.characters)
+        //                            {
+        //                                if (!(bool)((NetFieldBase<bool, NetBool>)character.swimming) && !character.HideShadow && (!character.IsInvisible && !Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(character.getTileLocation())))
+        //                                    Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, character.Position + new Vector2((float)(character.Sprite.SpriteWidth * 4) / 2f, (float)(character.GetBoundingBox().Height + (character.IsMonster ? 0 : 12)))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)character.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)character.scale), SpriteEffects.None, Math.Max(0.0f, (float)character.getStandingY() / 10000f) - 1E-06f);
+        //                            }
+        //                        }
+        //                        else
+        //                        {
+        //                            foreach (NPC actor in Game1.CurrentEvent.actors)
+        //                            {
+        //                                if (!(bool)((NetFieldBase<bool, NetBool>)actor.swimming) && !actor.HideShadow && !Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(actor.getTileLocation()))
+        //                                    Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, actor.Position + new Vector2((float)(actor.Sprite.SpriteWidth * 4) / 2f, (float)(actor.GetBoundingBox().Height + (actor.IsMonster ? 0 : (actor.Sprite.SpriteHeight <= 16 ? -4 : 12))))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)actor.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)actor.scale), SpriteEffects.None, Math.Max(0.0f, (float)actor.getStandingY() / 10000f) - 1E-06f);
+        //                            }
+        //                        }
+        //                        foreach (Farmer farmerShadow in this._farmerShadows)
+        //                        {
+        //                            if (!(bool)((NetFieldBase<bool, NetBool>)farmerShadow.swimming) && !farmerShadow.isRidingHorse() && (Game1.currentLocation == null || !Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(farmerShadow.getTileLocation())))
+        //                            {
+        //                                SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                                Texture2D shadowTexture = Game1.shadowTexture;
+        //                                Vector2 local = Game1.GlobalToLocal(farmerShadow.Position + new Vector2(32f, 24f));
+        //                                Microsoft.Xna.Framework.Rectangle? sourceRectangle = new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds);
+        //                                Color white = Color.White;
+        //                                double num1 = 0.0;
+        //                                Microsoft.Xna.Framework.Rectangle bounds = Game1.shadowTexture.Bounds;
+        //                                double x = (double)bounds.Center.X;
+        //                                bounds = Game1.shadowTexture.Bounds;
+        //                                double y = (double)bounds.Center.Y;
+        //                                Vector2 origin = new Vector2((float)x, (float)y);
+        //                                double num2 = 4.0 - (!farmerShadow.running && !farmerShadow.UsingTool || farmerShadow.FarmerSprite.currentAnimationIndex <= 1 ? 0.0 : (double)Math.Abs(FarmerRenderer.featureYOffsetPerFrame[farmerShadow.FarmerSprite.CurrentFrame]) * 0.5);
+        //                                int num3 = 0;
+        //                                double num4 = 0.0;
+        //                                spriteBatch.Draw(shadowTexture, local, sourceRectangle, white, (float)num1, origin, (float)num2, (SpriteEffects)num3, (float)num4);
+        //                            }
+        //                        }
+        //                    }
+        //                    Game1.currentLocation.Map.GetLayer("Buildings").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
+        //                    Game1.mapDisplayDevice.EndScene();
+        //                    Game1.spriteBatch.End();
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    if (!Game1.currentLocation.shouldHideCharacters())
+        //                    {
+        //                        if (Game1.CurrentEvent == null)
+        //                        {
+        //                            foreach (NPC character in Game1.currentLocation.characters)
+        //                            {
+        //                                if (!(bool)((NetFieldBase<bool, NetBool>)character.swimming) && !character.HideShadow && Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(character.getTileLocation()))
+        //                                    Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, character.Position + new Vector2((float)(character.Sprite.SpriteWidth * 4) / 2f, (float)(character.GetBoundingBox().Height + (character.IsMonster ? 0 : 12)))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)character.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)character.scale), SpriteEffects.None, Math.Max(0.0f, (float)character.getStandingY() / 10000f) - 1E-06f);
+        //                            }
+        //                        }
+        //                        else
+        //                        {
+        //                            foreach (NPC actor in Game1.CurrentEvent.actors)
+        //                            {
+        //                                if (!(bool)((NetFieldBase<bool, NetBool>)actor.swimming) && !actor.HideShadow && Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(actor.getTileLocation()))
+        //                                    Game1.spriteBatch.Draw(Game1.shadowTexture, Game1.GlobalToLocal(Game1.viewport, actor.Position + new Vector2((float)(actor.Sprite.SpriteWidth * 4) / 2f, (float)(actor.GetBoundingBox().Height + (actor.IsMonster ? 0 : 12)))), new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds), Color.White, 0.0f, new Vector2((float)Game1.shadowTexture.Bounds.Center.X, (float)Game1.shadowTexture.Bounds.Center.Y), (float)(4.0 + (double)actor.yJumpOffset / 40.0) * (float)((NetFieldBase<float, NetFloat>)actor.scale), SpriteEffects.None, Math.Max(0.0f, (float)actor.getStandingY() / 10000f) - 1E-06f);
+        //                            }
+        //                        }
+        //                        foreach (Farmer farmerShadow in this._farmerShadows)
+        //                        {
+        //                            if (!(bool)((NetFieldBase<bool, NetBool>)farmerShadow.swimming) && !farmerShadow.isRidingHorse() && (Game1.currentLocation != null && Game1.currentLocation.shouldShadowBeDrawnAboveBuildingsLayer(farmerShadow.getTileLocation())))
+        //                            {
+        //                                SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                                Texture2D shadowTexture = Game1.shadowTexture;
+        //                                Vector2 local = Game1.GlobalToLocal(farmerShadow.Position + new Vector2(32f, 24f));
+        //                                Microsoft.Xna.Framework.Rectangle? sourceRectangle = new Microsoft.Xna.Framework.Rectangle?(Game1.shadowTexture.Bounds);
+        //                                Color white = Color.White;
+        //                                double num1 = 0.0;
+        //                                Microsoft.Xna.Framework.Rectangle bounds = Game1.shadowTexture.Bounds;
+        //                                double x = (double)bounds.Center.X;
+        //                                bounds = Game1.shadowTexture.Bounds;
+        //                                double y = (double)bounds.Center.Y;
+        //                                Vector2 origin = new Vector2((float)x, (float)y);
+        //                                double num2 = 4.0 - (!farmerShadow.running && !farmerShadow.UsingTool || farmerShadow.FarmerSprite.currentAnimationIndex <= 1 ? 0.0 : (double)Math.Abs(FarmerRenderer.featureYOffsetPerFrame[farmerShadow.FarmerSprite.CurrentFrame]) * 0.5);
+        //                                int num3 = 0;
+        //                                double num4 = 0.0;
+        //                                spriteBatch.Draw(shadowTexture, local, sourceRectangle, white, (float)num1, origin, (float)num2, (SpriteEffects)num3, (float)num4);
+        //                            }
+        //                        }
+        //                    }
+        //                    if ((Game1.eventUp || Game1.killScreen) && (!Game1.killScreen && Game1.currentLocation.currentEvent != null))
+        //                        Game1.currentLocation.currentEvent.draw(Game1.spriteBatch);
+        //                    if (Game1.player.currentUpgrade != null && Game1.player.currentUpgrade.daysLeftTillUpgradeDone <= 3 && Game1.currentLocation.Name.Equals("Farm"))
+        //                        Game1.spriteBatch.Draw(Game1.player.currentUpgrade.workerTexture, Game1.GlobalToLocal(Game1.viewport, Game1.player.currentUpgrade.positionOfCarpenter), new Microsoft.Xna.Framework.Rectangle?(Game1.player.currentUpgrade.getSourceRectangle()), Color.White, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, (float)(((double)Game1.player.currentUpgrade.positionOfCarpenter.Y + 48.0) / 10000.0));
+        //                    Game1.currentLocation.draw(Game1.spriteBatch);
+        //                    if (Game1.eventUp && Game1.currentLocation.currentEvent != null)
+        //                    {
+        //                        string messageToScreen = Game1.currentLocation.currentEvent.messageToScreen;
+        //                    }
+        //                    if (Game1.player.ActiveObject == null && (Game1.player.UsingTool || Game1.pickingTool) && (Game1.player.CurrentTool != null && (!Game1.player.CurrentTool.Name.Equals("Seeds") || Game1.pickingTool)))
+        //                        Game1.drawTool(Game1.player);
+        //                    if (Game1.currentLocation.Name.Equals("Farm"))
+        //                        this.drawFarmBuildings();
+        //                    if (Game1.tvStation >= 0)
+        //                        Game1.spriteBatch.Draw(Game1.tvStationTexture, Game1.GlobalToLocal(Game1.viewport, new Vector2(400f, 160f)), new Microsoft.Xna.Framework.Rectangle?(new Microsoft.Xna.Framework.Rectangle(Game1.tvStation * 24, 0, 24, 15)), Color.White, 0.0f, Vector2.Zero, 4f, SpriteEffects.None, 1E-08f);
+        //                    if (Game1.panMode)
+        //                    {
+        //                        Game1.spriteBatch.Draw(Game1.fadeToBlackRect, new Microsoft.Xna.Framework.Rectangle((int)Math.Floor((double)(Game1.getOldMouseX() + Game1.viewport.X) / 64.0) * 64 - Game1.viewport.X, (int)Math.Floor((double)(Game1.getOldMouseY() + Game1.viewport.Y) / 64.0) * 64 - Game1.viewport.Y, 64, 64), Color.Lime * 0.75f);
+        //                        foreach (Warp warp in (NetList<Warp, NetRef<Warp>>)Game1.currentLocation.warps)
+        //                            Game1.spriteBatch.Draw(Game1.fadeToBlackRect, new Microsoft.Xna.Framework.Rectangle(warp.X * 64 - Game1.viewport.X, warp.Y * 64 - Game1.viewport.Y, 64, 64), Color.Red * 0.75f);
+        //                    }
+        //                    Game1.mapDisplayDevice.BeginScene(Game1.spriteBatch);
+        //                    Game1.currentLocation.Map.GetLayer("Front").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
+        //                    Game1.mapDisplayDevice.EndScene();
+        //                    Game1.currentLocation.drawAboveFrontLayer(Game1.spriteBatch);
+        //                    Game1.spriteBatch.End();
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    if (Game1.displayFarmer && Game1.player.ActiveObject != null && ((bool)((NetFieldBase<bool, NetBool>)Game1.player.ActiveObject.bigCraftable) && this.checkBigCraftableBoundariesForFrontLayer()) && Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location(Game1.player.getStandingX(), Game1.player.getStandingY()), Game1.viewport.Size) == null)
+        //                        Game1.drawPlayerHeldObject(Game1.player);
+        //                    else if (Game1.displayFarmer && Game1.player.ActiveObject != null)
+        //                    {
+        //                        if (Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location((int)Game1.player.Position.X, (int)Game1.player.Position.Y - 38), Game1.viewport.Size) == null || Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location((int)Game1.player.Position.X, (int)Game1.player.Position.Y - 38), Game1.viewport.Size).TileIndexProperties.ContainsKey("FrontAlways"))
+        //                        {
+        //                            Layer layer1 = Game1.currentLocation.Map.GetLayer("Front");
+        //                            rectangle = Game1.player.GetBoundingBox();
+        //                            Location mapDisplayLocation1 = new Location(rectangle.Right, (int)Game1.player.Position.Y - 38);
+        //                            Size size1 = Game1.viewport.Size;
+        //                            if (layer1.PickTile(mapDisplayLocation1, size1) != null)
+        //                            {
+        //                                Layer layer2 = Game1.currentLocation.Map.GetLayer("Front");
+        //                                rectangle = Game1.player.GetBoundingBox();
+        //                                Location mapDisplayLocation2 = new Location(rectangle.Right, (int)Game1.player.Position.Y - 38);
+        //                                Size size2 = Game1.viewport.Size;
+        //                                if (layer2.PickTile(mapDisplayLocation2, size2).TileIndexProperties.ContainsKey("FrontAlways"))
+        //                                    goto label_129;
+        //                            }
+        //                            else
+        //                                goto label_129;
+        //                        }
+        //                        Game1.drawPlayerHeldObject(Game1.player);
+        //                    }
+        //                    label_129:
+        //                    if ((Game1.player.UsingTool || Game1.pickingTool) && Game1.player.CurrentTool != null && ((!Game1.player.CurrentTool.Name.Equals("Seeds") || Game1.pickingTool) && (Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location(Game1.player.getStandingX(), (int)Game1.player.Position.Y - 38), Game1.viewport.Size) != null && Game1.currentLocation.Map.GetLayer("Front").PickTile(new Location(Game1.player.getStandingX(), Game1.player.getStandingY()), Game1.viewport.Size) == null)))
+        //                        Game1.drawTool(Game1.player);
+        //                    if (Game1.currentLocation.Map.GetLayer("AlwaysFront") != null)
+        //                    {
+        //                        Game1.mapDisplayDevice.BeginScene(Game1.spriteBatch);
+        //                        Game1.currentLocation.Map.GetLayer("AlwaysFront").Draw(Game1.mapDisplayDevice, Game1.viewport, Location.Origin, false, 4);
+        //                        Game1.mapDisplayDevice.EndScene();
+        //                    }
+        //                    if ((double)Game1.toolHold > 400.0 && Game1.player.CurrentTool.UpgradeLevel >= 1 && Game1.player.canReleaseTool)
+        //                    {
+        //                        Color color = Color.White;
+        //                        switch ((int)((double)Game1.toolHold / 600.0) + 2)
+        //                        {
+        //                            case 1:
+        //                                color = Tool.copperColor;
+        //                                break;
+        //                            case 2:
+        //                                color = Tool.steelColor;
+        //                                break;
+        //                            case 3:
+        //                                color = Tool.goldColor;
+        //                                break;
+        //                            case 4:
+        //                                color = Tool.iridiumColor;
+        //                                break;
+        //                        }
+        //                        Game1.spriteBatch.Draw(Game1.littleEffect, new Microsoft.Xna.Framework.Rectangle((int)Game1.player.getLocalPosition(Game1.viewport).X - 2, (int)Game1.player.getLocalPosition(Game1.viewport).Y - (Game1.player.CurrentTool.Name.Equals("Watering Can") ? 0 : 64) - 2, (int)((double)Game1.toolHold % 600.0 * 0.0799999982118607) + 4, 12), Color.Black);
+        //                        Game1.spriteBatch.Draw(Game1.littleEffect, new Microsoft.Xna.Framework.Rectangle((int)Game1.player.getLocalPosition(Game1.viewport).X, (int)Game1.player.getLocalPosition(Game1.viewport).Y - (Game1.player.CurrentTool.Name.Equals("Watering Can") ? 0 : 64), (int)((double)Game1.toolHold % 600.0 * 0.0799999982118607), 8), color);
+        //                    }
+        //                    if (Game1.isDebrisWeather && Game1.currentLocation.IsOutdoors && (!(bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.ignoreDebrisWeather) && !Game1.currentLocation.Name.Equals("Desert")) && Game1.viewport.X > -10)
+        //                    {
+        //                        foreach (WeatherDebris weatherDebris in Game1.debrisWeather)
+        //                            weatherDebris.draw(Game1.spriteBatch);
+        //                    }
+        //                    if (Game1.farmEvent != null)
+        //                        Game1.farmEvent.draw(Game1.spriteBatch);
+        //                    if ((double)Game1.currentLocation.LightLevel > 0.0 && Game1.timeOfDay < 2000)
+        //                    {
+        //                        SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                        Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
+        //                        viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                        Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
+        //                        Color color = Color.Black * Game1.currentLocation.LightLevel;
+        //                        spriteBatch.Draw(fadeToBlackRect, bounds, color);
+        //                    }
+        //                    if (Game1.screenGlow)
+        //                    {
+        //                        SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                        Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
+        //                        viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                        Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
+        //                        Color color = Game1.screenGlowColor * Game1.screenGlowAlpha;
+        //                        spriteBatch.Draw(fadeToBlackRect, bounds, color);
+        //                    }
+        //                    Game1.currentLocation.drawAboveAlwaysFrontLayer(Game1.spriteBatch);
+        //                    if (Game1.player.CurrentTool != null && Game1.player.CurrentTool is FishingRod && ((Game1.player.CurrentTool as FishingRod).isTimingCast || (double)(Game1.player.CurrentTool as FishingRod).castingChosenCountdown > 0.0 || ((Game1.player.CurrentTool as FishingRod).fishCaught || (Game1.player.CurrentTool as FishingRod).showingTreasure)))
+        //                        Game1.player.CurrentTool.draw(Game1.spriteBatch);
+        //                    if (Game1.isRaining && Game1.currentLocation.IsOutdoors && (!Game1.currentLocation.Name.Equals("Desert") && !(Game1.currentLocation is Summit)) && (!Game1.eventUp || Game1.currentLocation.isTileOnMap(new Vector2((float)(Game1.viewport.X / 64), (float)(Game1.viewport.Y / 64)))))
+        //                    {
+        //                        for (int index = 0; index < Game1.rainDrops.Length; ++index)
+        //                            Game1.spriteBatch.Draw(Game1.rainTexture, Game1.rainDrops[index].position, new Microsoft.Xna.Framework.Rectangle?(Game1.getSourceRectForStandardTileSheet(Game1.rainTexture, Game1.rainDrops[index].frame, -1, -1)), Color.White);
+        //                    }
+        //                    Game1.spriteBatch.End();
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    if (Game1.eventUp && Game1.currentLocation.currentEvent != null)
+        //                    {
+        //                        foreach (NPC actor in Game1.currentLocation.currentEvent.actors)
+        //                        {
+        //                            if (actor.isEmoting)
+        //                            {
+        //                                Vector2 localPosition = actor.getLocalPosition(Game1.viewport);
+        //                                localPosition.Y -= 140f;
+        //                                if (actor.Age == 2)
+        //                                    localPosition.Y += 32f;
+        //                                else if (actor.Gender == 1)
+        //                                    localPosition.Y += 10f;
+        //                                Game1.spriteBatch.Draw(Game1.emoteSpriteSheet, localPosition, new Microsoft.Xna.Framework.Rectangle?(new Microsoft.Xna.Framework.Rectangle(actor.CurrentEmoteIndex * 16 % Game1.emoteSpriteSheet.Width, actor.CurrentEmoteIndex * 16 / Game1.emoteSpriteSheet.Width * 16, 16, 16)), Color.White, 0.0f, Vector2.Zero, 4f, SpriteEffects.None, (float)actor.getStandingY() / 10000f);
+        //                            }
+        //                        }
+        //                    }
+        //                    Game1.spriteBatch.End();
+        //                    if (Game1.drawLighting)
+        //                    {
+        //                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, this.lightingBlend, SamplerState.LinearClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                        Game1.spriteBatch.Draw((Texture2D)Game1.lightmap, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(Game1.lightmap.Bounds), Color.White, 0.0f, Vector2.Zero, (float)(Game1.options.lightingQuality / 2), SpriteEffects.None, 1f);
+        //                        if (Game1.isRaining && (bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.isOutdoors) && !(Game1.currentLocation is Desert))
+        //                        {
+        //                            SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                            Texture2D staminaRect = Game1.staminaRect;
+        //                            viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                            Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
+        //                            Color color = Color.OrangeRed * 0.45f;
+        //                            spriteBatch.Draw(staminaRect, bounds, color);
+        //                        }
+        //                        Game1.spriteBatch.End();
+        //                    }
+        //                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+        //                    events.RenderedWorld.RaiseEmpty();
+        //                    if (Game1.drawGrid)
+        //                    {
+        //                        int num1 = -Game1.viewport.X % 64;
+        //                        float num2 = (float)(-Game1.viewport.Y % 64);
+        //                        int num3 = num1;
+        //                        while (true)
+        //                        {
+        //                            int num4 = num3;
+        //                            viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                            int width1 = viewport.Width;
+        //                            if (num4 < width1)
+        //                            {
+        //                                SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                                Texture2D staminaRect = Game1.staminaRect;
+        //                                int x = num3;
+        //                                int y = (int)num2;
+        //                                int width2 = 1;
+        //                                viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                                int height = viewport.Height;
+        //                                Microsoft.Xna.Framework.Rectangle destinationRectangle = new Microsoft.Xna.Framework.Rectangle(x, y, width2, height);
+        //                                Color color = Color.Red * 0.5f;
+        //                                spriteBatch.Draw(staminaRect, destinationRectangle, color);
+        //                                num3 += 64;
+        //                            }
+        //                            else
+        //                                break;
+        //                        }
+        //                        float num5 = num2;
+        //                        while (true)
+        //                        {
+        //                            double num4 = (double)num5;
+        //                            viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                            double height1 = (double)viewport.Height;
+        //                            if (num4 < height1)
+        //                            {
+        //                                SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                                Texture2D staminaRect = Game1.staminaRect;
+        //                                int x = num1;
+        //                                int y = (int)num5;
+        //                                viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                                int width = viewport.Width;
+        //                                int height2 = 1;
+        //                                Microsoft.Xna.Framework.Rectangle destinationRectangle = new Microsoft.Xna.Framework.Rectangle(x, y, width, height2);
+        //                                Color color = Color.Red * 0.5f;
+        //                                spriteBatch.Draw(staminaRect, destinationRectangle, color);
+        //                                num5 += 64f;
+        //                            }
+        //                            else
+        //                                break;
+        //                        }
+        //                    }
+        //                    if (Game1.currentBillboard != 0)
+        //                        this.drawBillboard();
+        //                    if ((Game1.displayHUD || Game1.eventUp) && (Game1.currentBillboard == 0 && Game1.gameMode == (byte)3) && (!Game1.freezeControls && !Game1.panMode && !Game1.HostPaused))
+        //                    {
+        //                        events.RenderingHud.RaiseEmpty();
+        //                        this.drawHUD();
+        //                        events.RenderedHud.RaiseEmpty();
+        //                    }
+        //                    else if (Game1.activeClickableMenu == null && Game1.farmEvent == null)
+        //                        Game1.spriteBatch.Draw(Game1.mouseCursors, new Vector2((float)Game1.getOldMouseX(), (float)Game1.getOldMouseY()), new Microsoft.Xna.Framework.Rectangle?(Game1.getSourceRectForStandardTileSheet(Game1.mouseCursors, 0, 16, 16)), Color.White, 0.0f, Vector2.Zero, (float)(4.0 + (double)Game1.dialogueButtonScale / 150.0), SpriteEffects.None, 1f);
+        //                    if (Game1.hudMessages.Count > 0 && (!Game1.eventUp || Game1.isFestival()))
+        //                    {
+        //                        for (int i = Game1.hudMessages.Count - 1; i >= 0; --i)
+        //                            Game1.hudMessages[i].draw(Game1.spriteBatch, i);
+        //                    }
+        //                }
+        //                if (Game1.farmEvent != null)
+        //                    Game1.farmEvent.draw(Game1.spriteBatch);
+        //                if (Game1.dialogueUp && !Game1.nameSelectUp && !Game1.messagePause && (Game1.activeClickableMenu == null || !(Game1.activeClickableMenu is DialogueBox)))
+        //                    this.drawDialogueBox();
+        //                if (Game1.progressBar)
+        //                {
+        //                    SpriteBatch spriteBatch1 = Game1.spriteBatch;
+        //                    Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
+        //                    int x1 = (Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea().Width - Game1.dialogueWidth) / 2;
+        //                    rectangle = Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea();
+        //                    int y1 = rectangle.Bottom - 128;
+        //                    int dialogueWidth = Game1.dialogueWidth;
+        //                    int height1 = 32;
+        //                    Microsoft.Xna.Framework.Rectangle destinationRectangle1 = new Microsoft.Xna.Framework.Rectangle(x1, y1, dialogueWidth, height1);
+        //                    Color lightGray = Color.LightGray;
+        //                    spriteBatch1.Draw(fadeToBlackRect, destinationRectangle1, lightGray);
+        //                    SpriteBatch spriteBatch2 = Game1.spriteBatch;
+        //                    Texture2D staminaRect = Game1.staminaRect;
+        //                    int x2 = (Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea().Width - Game1.dialogueWidth) / 2;
+        //                    rectangle = Game1.graphics.GraphicsDevice.Viewport.GetTitleSafeArea();
+        //                    int y2 = rectangle.Bottom - 128;
+        //                    int width = (int)((double)Game1.pauseAccumulator / (double)Game1.pauseTime * (double)Game1.dialogueWidth);
+        //                    int height2 = 32;
+        //                    Microsoft.Xna.Framework.Rectangle destinationRectangle2 = new Microsoft.Xna.Framework.Rectangle(x2, y2, width, height2);
+        //                    Color dimGray = Color.DimGray;
+        //                    spriteBatch2.Draw(staminaRect, destinationRectangle2, dimGray);
+        //                }
+        //                if (Game1.eventUp && Game1.currentLocation != null && Game1.currentLocation.currentEvent != null)
+        //                    Game1.currentLocation.currentEvent.drawAfterMap(Game1.spriteBatch);
+        //                if (Game1.isRaining && Game1.currentLocation != null && ((bool)((NetFieldBase<bool, NetBool>)Game1.currentLocation.isOutdoors) && !(Game1.currentLocation is Desert)))
+        //                {
+        //                    SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                    Texture2D staminaRect = Game1.staminaRect;
+        //                    viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                    Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
+        //                    Color color = Color.Blue * 0.2f;
+        //                    spriteBatch.Draw(staminaRect, bounds, color);
+        //                }
+        //                if ((Game1.fadeToBlack || Game1.globalFade) && !Game1.menuUp && (!Game1.nameSelectUp || Game1.messagePause))
+        //                {
+        //                    SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                    Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
+        //                    viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                    Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
+        //                    Color color = Color.Black * (Game1.gameMode == (byte)0 ? 1f - Game1.fadeToBlackAlpha : Game1.fadeToBlackAlpha);
+        //                    spriteBatch.Draw(fadeToBlackRect, bounds, color);
+        //                }
+        //                else if ((double)Game1.flashAlpha > 0.0)
+        //                {
+        //                    if (Game1.options.screenFlash)
+        //                    {
+        //                        SpriteBatch spriteBatch = Game1.spriteBatch;
+        //                        Texture2D fadeToBlackRect = Game1.fadeToBlackRect;
+        //                        viewport = Game1.graphics.GraphicsDevice.Viewport;
+        //                        Microsoft.Xna.Framework.Rectangle bounds = viewport.Bounds;
+        //                        Color color = Color.White * Math.Min(1f, Game1.flashAlpha);
+        //                        spriteBatch.Draw(fadeToBlackRect, bounds, color);
+        //                    }
+        //                    Game1.flashAlpha -= 0.1f;
+        //                }
+        //                if ((Game1.messagePause || Game1.globalFade) && Game1.dialogueUp)
+        //                    this.drawDialogueBox();
+        //                foreach (TemporaryAnimatedSprite overlayTempSprite in Game1.screenOverlayTempSprites)
+        //                    overlayTempSprite.draw(Game1.spriteBatch, true, 0, 0, 1f);
+        //                if (Game1.debugMode)
+        //                {
+        //                    StringBuilder debugStringBuilder = Game1._debugStringBuilder;
+        //                    debugStringBuilder.Clear();
+        //                    if (Game1.panMode)
+        //                    {
+        //                        debugStringBuilder.Append((Game1.getOldMouseX() + Game1.viewport.X) / 64);
+        //                        debugStringBuilder.Append(",");
+        //                        debugStringBuilder.Append((Game1.getOldMouseY() + Game1.viewport.Y) / 64);
+        //                    }
+        //                    else
+        //                    {
+        //                        debugStringBuilder.Append("player: ");
+        //                        debugStringBuilder.Append(Game1.player.getStandingX() / 64);
+        //                        debugStringBuilder.Append(", ");
+        //                        debugStringBuilder.Append(Game1.player.getStandingY() / 64);
+        //                    }
+        //                    debugStringBuilder.Append(" mouseTransparency: ");
+        //                    debugStringBuilder.Append(Game1.mouseCursorTransparency);
+        //                    debugStringBuilder.Append(" mousePosition: ");
+        //                    debugStringBuilder.Append(Game1.getMouseX());
+        //                    debugStringBuilder.Append(",");
+        //                    debugStringBuilder.Append(Game1.getMouseY());
+        //                    debugStringBuilder.Append(Environment.NewLine);
+        //                    debugStringBuilder.Append("debugOutput: ");
+        //                    debugStringBuilder.Append(Game1.debugOutput);
+        //                    Game1.spriteBatch.DrawString(Game1.smallFont, debugStringBuilder, new Vector2((float)this.GraphicsDevice.Viewport.GetTitleSafeArea().X, (float)(this.GraphicsDevice.Viewport.GetTitleSafeArea().Y + Game1.smallFont.LineSpacing * 8)), Color.Red, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.9999999f);
+        //                }
+        //                if (Game1.showKeyHelp)
+        //                    Game1.spriteBatch.DrawString(Game1.smallFont, Game1.keyHelpString, new Vector2(64f, (float)(Game1.viewport.Height - 64 - (Game1.dialogueUp ? 192 + (Game1.isQuestion ? Game1.questionChoices.Count * 64 : 0) : 0)) - Game1.smallFont.MeasureString(Game1.keyHelpString).Y), Color.LightGray, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.9999999f);
+        //                if (Game1.activeClickableMenu != null)
+        //                {
+        //                    try
+        //                    {
+        //                        events.RenderingActiveMenu.RaiseEmpty();
+        //                        Game1.activeClickableMenu.draw(Game1.spriteBatch);
+        //                        events.RenderedActiveMenu.RaiseEmpty();
+        //                    }
+        //                    catch (Exception ex)
+        //                    {
+        //                        this.Monitor.Log($"The {Game1.activeClickableMenu.GetType().FullName} menu crashed while drawing itself. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
+        //                        Game1.activeClickableMenu.exitThisMenu();
+        //                    }
+        //                }
+        //                else if (Game1.farmEvent != null)
+        //                    Game1.farmEvent.drawAboveEverything(Game1.spriteBatch);
+        //                if (Game1.HostPaused)
+        //                {
+        //                    string s = Game1.content.LoadString("Strings\\StringsFromCSFiles:DayTimeMoneyBox.cs.10378");
+        //                    SpriteText.drawStringWithScrollBackground(Game1.spriteBatch, s, 96, 32, "", 1f, -1);
+        //                }
 
-                        events.Rendered.RaiseEmpty();
-                        Game1.spriteBatch.End();
-                        this.drawOverlays(Game1.spriteBatch);
-                        this.renderScreenBuffer();
-                    }
-                }
-            }
-        }
+        //                events.Rendered.RaiseEmpty();
+        //                Game1.spriteBatch.End();
+        //                this.drawOverlays(Game1.spriteBatch);
+        //                this.renderScreenBuffer();
+        //            }
+        //        }
+        //    }
+        //}
     }
 }
diff --git a/src/SMAPI/Framework/SMultiplayer.cs b/src/SMAPI/Framework/SMultiplayer.cs
deleted file mode 100644
index 382910a0..00000000
--- a/src/SMAPI/Framework/SMultiplayer.cs
+++ /dev/null
@@ -1,515 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using Galaxy.Api;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using StardewModdingAPI.Events;
-using StardewModdingAPI.Framework.Events;
-using StardewModdingAPI.Framework.Networking;
-using StardewModdingAPI.Framework.Reflection;
-using StardewModdingAPI.Toolkit.Serialisation;
-using StardewValley;
-using StardewValley.Network;
-using StardewValley.SDKs;
-
-namespace StardewModdingAPI.Framework
-{
-    /// <summary>SMAPI's implementation of the game's core multiplayer logic.</summary>
-    /// <remarks>
-    /// SMAPI syncs mod context to all players through the host as such:
-    ///   1. Farmhand sends ModContext + PlayerIntro.
-    ///   2. If host receives ModContext: it stores the context, replies with known contexts, and forwards it to other farmhands.
-    ///   3. If host receives PlayerIntro before ModContext: it stores a 'vanilla player' context, and forwards it to other farmhands.
-    ///   4. If farmhand receives ModContext: it stores it.
-    ///   5. If farmhand receives ServerIntro without a preceding ModContext: it stores a 'vanilla host' context.
-    ///   6. If farmhand receives PlayerIntro without a preceding ModContext AND it's not the host peer: it stores a 'vanilla player' context.
-    ///
-    /// Once a farmhand/server stored a context, messages can be sent to that player through the SMAPI APIs.
-    /// </remarks>
-    internal class SMultiplayer : Multiplayer
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>Encapsulates monitoring and logging.</summary>
-        private readonly IMonitor Monitor;
-
-        /// <summary>Tracks the installed mods.</summary>
-        private readonly ModRegistry ModRegistry;
-
-        /// <summary>Encapsulates SMAPI's JSON file parsing.</summary>
-        private readonly JsonHelper JsonHelper;
-
-        /// <summary>Simplifies access to private code.</summary>
-        private readonly Reflector Reflection;
-
-        /// <summary>Manages SMAPI events.</summary>
-        private readonly EventManager EventManager;
-
-        /// <summary>A callback to invoke when a mod message is received.</summary>
-        private readonly Action<ModMessageModel> OnModMessageReceived;
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The metadata for each connected peer.</summary>
-        public IDictionary<long, MultiplayerPeer> Peers { get; } = new Dictionary<long, MultiplayerPeer>();
-
-        /// <summary>The metadata for the host player, if the current player is a farmhand.</summary>
-        public MultiplayerPeer HostPeer;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="monitor">Encapsulates monitoring and logging.</param>
-        /// <param name="eventManager">Manages SMAPI events.</param>
-        /// <param name="jsonHelper">Encapsulates SMAPI's JSON file parsing.</param>
-        /// <param name="modRegistry">Tracks the installed mods.</param>
-        /// <param name="reflection">Simplifies access to private code.</param>
-        /// <param name="onModMessageReceived">A callback to invoke when a mod message is received.</param>
-        public SMultiplayer(IMonitor monitor, EventManager eventManager, JsonHelper jsonHelper, ModRegistry modRegistry, Reflector reflection, Action<ModMessageModel> onModMessageReceived)
-        {
-            this.Monitor = monitor;
-            this.EventManager = eventManager;
-            this.JsonHelper = jsonHelper;
-            this.ModRegistry = modRegistry;
-            this.Reflection = reflection;
-            this.OnModMessageReceived = onModMessageReceived;
-        }
-
-        /// <summary>Perform cleanup needed when a multiplayer session ends.</summary>
-        public void CleanupOnMultiplayerExit()
-        {
-            this.Peers.Clear();
-            this.HostPeer = null;
-        }
-
-        /// <summary>Initialise a client before the game connects to a remote server.</summary>
-        /// <param name="client">The client to initialise.</param>
-        public override Client InitClient(Client client)
-        {
-            switch (client)
-            {
-                case LidgrenClient _:
-                    {
-                        string address = this.Reflection.GetField<string>(client, "address").GetValue();
-                        return new SLidgrenClient(address, this.OnClientProcessingMessage, this.OnClientSendingMessage);
-                    }
-
-                case GalaxyNetClient _:
-                    {
-                        GalaxyID address = this.Reflection.GetField<GalaxyID>(client, "lobbyId").GetValue();
-                        return new SGalaxyNetClient(address, this.OnClientProcessingMessage, this.OnClientSendingMessage);
-                    }
-
-                default:
-                    this.Monitor.Log($"Unknown multiplayer client type: {client.GetType().AssemblyQualifiedName}", LogLevel.Trace);
-                    return client;
-            }
-        }
-
-        /// <summary>Initialise a server before the game connects to an incoming player.</summary>
-        /// <param name="server">The server to initialise.</param>
-        public override Server InitServer(Server server)
-        {
-            switch (server)
-            {
-                case LidgrenServer _:
-                    {
-                        IGameServer gameServer = this.Reflection.GetField<IGameServer>(server, "gameServer").GetValue();
-                        return new SLidgrenServer(gameServer, this, this.OnServerProcessingMessage);
-                    }
-
-                case GalaxyNetServer _:
-                    {
-                        IGameServer gameServer = this.Reflection.GetField<IGameServer>(server, "gameServer").GetValue();
-                        return new SGalaxyNetServer(gameServer, this, this.OnServerProcessingMessage);
-                    }
-
-                default:
-                    this.Monitor.Log($"Unknown multiplayer server type: {server.GetType().AssemblyQualifiedName}", LogLevel.Trace);
-                    return server;
-            }
-        }
-
-        /// <summary>A callback raised when sending a message as a farmhand.</summary>
-        /// <param name="message">The message being sent.</param>
-        /// <param name="sendMessage">Send an arbitrary message through the client.</param>
-        /// <param name="resume">Resume sending the underlying message.</param>
-        protected void OnClientSendingMessage(OutgoingMessage message, Action<OutgoingMessage> sendMessage, Action resume)
-        {
-            if (this.Monitor.IsVerbose)
-                this.Monitor.Log($"CLIENT SEND {(MessageType)message.MessageType} {message.FarmerID}", LogLevel.Trace);
-
-            switch (message.MessageType)
-            {
-                // sync mod context (step 1)
-                case (byte)MessageType.PlayerIntroduction:
-                    sendMessage(new OutgoingMessage((byte)MessageType.ModContext, Game1.player.UniqueMultiplayerID, this.GetContextSyncMessageFields()));
-                    resume();
-                    break;
-
-                // run default logic
-                default:
-                    resume();
-                    break;
-            }
-        }
-
-        /// <summary>Process an incoming network message as the host player.</summary>
-        /// <param name="message">The message to process.</param>
-        /// <param name="sendMessage">A method which sends the given message to the client.</param>
-        /// <param name="resume">Process the message using the game's default logic.</param>
-        public void OnServerProcessingMessage(IncomingMessage message, Action<OutgoingMessage> sendMessage, Action resume)
-        {
-            if (this.Monitor.IsVerbose)
-                this.Monitor.Log($"SERVER RECV {(MessageType)message.MessageType} {message.FarmerID}", LogLevel.Trace);
-
-            switch (message.MessageType)
-            {
-                // sync mod context (step 2)
-                case (byte)MessageType.ModContext:
-                    {
-                        // parse message
-                        RemoteContextModel model = this.ReadContext(message.Reader);
-                        this.Monitor.Log($"Received context for farmhand {message.FarmerID} running {(model != null ? $"SMAPI {model.ApiVersion} with {model.Mods.Length} mods" : "vanilla")}.", LogLevel.Trace);
-
-                        // store peer
-                        MultiplayerPeer newPeer = new MultiplayerPeer(message.FarmerID, model, sendMessage, isHost: false);
-                        if (this.Peers.ContainsKey(message.FarmerID))
-                        {
-                            this.Monitor.Log($"Received mod context from farmhand {message.FarmerID}, but the game didn't see them disconnect. This may indicate issues with the network connection.", LogLevel.Info);
-                            this.Peers.Remove(message.FarmerID);
-                            return;
-                        }
-                        this.AddPeer(newPeer, canBeHost: false, raiseEvent: false);
-
-                        // reply with own context
-                        this.Monitor.VerboseLog("   Replying with host context...");
-                        newPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModContext, Game1.player.UniqueMultiplayerID, this.GetContextSyncMessageFields()));
-
-                        // reply with other players' context
-                        foreach (MultiplayerPeer otherPeer in this.Peers.Values.Where(p => p.PlayerID != newPeer.PlayerID))
-                        {
-                            this.Monitor.VerboseLog($"   Replying with context for player {otherPeer.PlayerID}...");
-                            newPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModContext, otherPeer.PlayerID, this.GetContextSyncMessageFields(otherPeer)));
-                        }
-
-                        // forward to other peers
-                        if (this.Peers.Count > 1)
-                        {
-                            object[] fields = this.GetContextSyncMessageFields(newPeer);
-                            foreach (MultiplayerPeer otherPeer in this.Peers.Values.Where(p => p.PlayerID != newPeer.PlayerID))
-                            {
-                                this.Monitor.VerboseLog($"   Forwarding context to player {otherPeer.PlayerID}...");
-                                otherPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModContext, newPeer.PlayerID, fields));
-                            }
-                        }
-
-                        // raise event
-                        this.EventManager.PeerContextReceived.Raise(new PeerContextReceivedEventArgs(newPeer));
-                    }
-                    break;
-
-                // handle player intro
-                case (byte)MessageType.PlayerIntroduction:
-                    // store peer if new
-                    if (!this.Peers.ContainsKey(message.FarmerID))
-                    {
-                        this.Monitor.Log($"Received connection for vanilla player {message.FarmerID}.", LogLevel.Trace);
-                        MultiplayerPeer peer = new MultiplayerPeer(message.FarmerID, null, sendMessage, isHost: false);
-                        this.AddPeer(peer, canBeHost: false);
-                    }
-
-                    resume();
-                    break;
-
-                // handle mod message
-                case (byte)MessageType.ModMessage:
-                    this.ReceiveModMessage(message);
-                    break;
-
-                default:
-                    resume();
-                    break;
-            }
-        }
-
-        /// <summary>Process an incoming network message as a farmhand.</summary>
-        /// <param name="message">The message to process.</param>
-        /// <param name="sendMessage">Send an arbitrary message through the client.</param>
-        /// <param name="resume">Resume processing the message using the game's default logic.</param>
-        /// <returns>Returns whether the message was handled.</returns>
-        public void OnClientProcessingMessage(IncomingMessage message, Action<OutgoingMessage> sendMessage, Action resume)
-        {
-            if (this.Monitor.IsVerbose)
-                this.Monitor.Log($"CLIENT RECV {(MessageType)message.MessageType} {message.FarmerID}", LogLevel.Trace);
-
-            switch (message.MessageType)
-            {
-                // mod context sync (step 4)
-                case (byte)MessageType.ModContext:
-                    {
-                        // parse message
-                        RemoteContextModel model = this.ReadContext(message.Reader);
-                        this.Monitor.Log($"Received context for {(model?.IsHost == true ? "host" : "farmhand")} {message.FarmerID} running {(model != null ? $"SMAPI {model.ApiVersion} with {model.Mods.Length} mods" : "vanilla")}.", LogLevel.Trace);
-
-                        // store peer
-                        MultiplayerPeer peer = new MultiplayerPeer(message.FarmerID, model, sendMessage, isHost: model?.IsHost ?? this.HostPeer == null);
-                        if (peer.IsHost && this.HostPeer != null)
-                        {
-                            this.Monitor.Log($"Rejected mod context from host player {peer.PlayerID}: already received host data from {(peer.PlayerID == this.HostPeer.PlayerID ? "that player" : $"player {peer.PlayerID}")}.", LogLevel.Error);
-                            return;
-                        }
-                        this.AddPeer(peer, canBeHost: true);
-                    }
-                    break;
-
-                // handle server intro
-                case (byte)MessageType.ServerIntroduction:
-                    {
-                        // store peer
-                        if (!this.Peers.ContainsKey(message.FarmerID) && this.HostPeer == null)
-                        {
-                            this.Monitor.Log($"Received connection for vanilla host {message.FarmerID}.", LogLevel.Trace);
-                            this.AddPeer(new MultiplayerPeer(message.FarmerID, null, sendMessage, isHost: true), canBeHost: false);
-                        }
-                        resume();
-                        break;
-                    }
-
-                // handle player intro
-                case (byte)MessageType.PlayerIntroduction:
-                    {
-                        // store peer
-                        if (!this.Peers.TryGetValue(message.FarmerID, out MultiplayerPeer peer))
-                        {
-                            peer = new MultiplayerPeer(message.FarmerID, null, sendMessage, isHost: this.HostPeer == null);
-                            this.Monitor.Log($"Received connection for vanilla {(peer.IsHost ? "host" : "farmhand")} {message.FarmerID}.", LogLevel.Trace);
-                            this.AddPeer(peer, canBeHost: true);
-                        }
-
-                        resume();
-                        break;
-                    }
-
-                // handle mod message
-                case (byte)MessageType.ModMessage:
-                    this.ReceiveModMessage(message);
-                    break;
-
-                default:
-                    resume();
-                    break;
-            }
-        }
-
-        /// <summary>Remove players who are disconnecting.</summary>
-        protected override void removeDisconnectedFarmers()
-        {
-            foreach (long playerID in this.disconnectingFarmers)
-            {
-                if (this.Peers.TryGetValue(playerID, out MultiplayerPeer peer))
-                {
-                    this.Monitor.Log($"Player quit: {playerID}", LogLevel.Trace);
-                    this.Peers.Remove(playerID);
-                    this.EventManager.PeerDisconnected.Raise(new PeerDisconnectedEventArgs(peer));
-                }
-            }
-
-            base.removeDisconnectedFarmers();
-        }
-
-        /// <summary>Broadcast a mod message to matching players.</summary>
-        /// <param name="message">The data to send over the network.</param>
-        /// <param name="messageType">A message type which receiving mods can use to decide whether it's the one they want to handle, like <c>SetPlayerLocation</c>. This doesn't need to be globally unique, since mods should check the originating mod ID.</param>
-        /// <param name="fromModID">The unique ID of the mod sending the message.</param>
-        /// <param name="toModIDs">The mod IDs which should receive the message on the destination computers, or <c>null</c> for all mods. Specifying mod IDs is recommended to improve performance, unless it's a general-purpose broadcast.</param>
-        /// <param name="toPlayerIDs">The <see cref="Farmer.UniqueMultiplayerID" /> values for the players who should receive the message, or <c>null</c> for all players. If you don't need to broadcast to all players, specifying player IDs is recommended to reduce latency.</param>
-        public void BroadcastModMessage<TMessage>(TMessage message, string messageType, string fromModID, string[] toModIDs, long[] toPlayerIDs)
-        {
-            // validate
-            if (message == null)
-                throw new ArgumentNullException(nameof(message));
-            if (string.IsNullOrWhiteSpace(messageType))
-                throw new ArgumentNullException(nameof(messageType));
-            if (string.IsNullOrWhiteSpace(fromModID))
-                throw new ArgumentNullException(nameof(fromModID));
-            if (!this.Peers.Any())
-            {
-                this.Monitor.VerboseLog($"Ignored '{messageType}' broadcast from mod {fromModID}: not connected to any players.");
-                return;
-            }
-
-            // filter player IDs
-            HashSet<long> playerIDs = null;
-            if (toPlayerIDs != null && toPlayerIDs.Any())
-            {
-                playerIDs = new HashSet<long>(toPlayerIDs);
-                playerIDs.RemoveWhere(id => !this.Peers.ContainsKey(id));
-                if (!playerIDs.Any())
-                {
-                    this.Monitor.VerboseLog($"Ignored '{messageType}' broadcast from mod {fromModID}: none of the specified player IDs are connected.");
-                    return;
-                }
-            }
-
-            // get data to send
-            ModMessageModel model = new ModMessageModel(
-                fromPlayerID: Game1.player.UniqueMultiplayerID,
-                fromModID: fromModID,
-                toModIDs: toModIDs,
-                toPlayerIDs: playerIDs?.ToArray(),
-                type: messageType,
-                data: JToken.FromObject(message)
-            );
-            string data = JsonConvert.SerializeObject(model, Formatting.None);
-
-            // log message
-            if (this.Monitor.IsVerbose)
-                this.Monitor.Log($"Broadcasting '{messageType}' message: {data}.", LogLevel.Trace);
-
-            // send message
-            if (Context.IsMainPlayer)
-            {
-                foreach (MultiplayerPeer peer in this.Peers.Values)
-                {
-                    if (playerIDs == null || playerIDs.Contains(peer.PlayerID))
-                    {
-                        model.ToPlayerIDs = new[] { peer.PlayerID };
-                        peer.SendMessage(new OutgoingMessage((byte)MessageType.ModMessage, peer.PlayerID, data));
-                    }
-                }
-            }
-            else if (this.HostPeer != null && this.HostPeer.HasSmapi)
-                this.HostPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModMessage, this.HostPeer.PlayerID, data));
-            else
-                this.Monitor.VerboseLog("  Can't send message because no valid connections were found.");
-
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Save a received peer.</summary>
-        /// <param name="peer">The peer to add.</param>
-        /// <param name="canBeHost">Whether to track the peer as the host if applicable.</param>
-        /// <param name="raiseEvent">Whether to raise the <see cref="Events.EventManager.PeerContextReceived"/> event.</param>
-        private void AddPeer(MultiplayerPeer peer, bool canBeHost, bool raiseEvent = true)
-        {
-            // store
-            this.Peers[peer.PlayerID] = peer;
-            if (canBeHost && peer.IsHost)
-                this.HostPeer = peer;
-
-            // raise event
-            if (raiseEvent)
-                this.EventManager.PeerContextReceived.Raise(new PeerContextReceivedEventArgs(peer));
-        }
-
-        /// <summary>Read the metadata context for a player.</summary>
-        /// <param name="reader">The stream reader.</param>
-        private RemoteContextModel ReadContext(BinaryReader reader)
-        {
-            string data = reader.ReadString();
-            RemoteContextModel model = this.JsonHelper.Deserialise<RemoteContextModel>(data);
-            return model.ApiVersion != null
-                ? model
-                : null; // no data available for unmodded players
-        }
-
-        /// <summary>Receive a mod message sent from another player's mods.</summary>
-        /// <param name="message">The raw message to parse.</param>
-        private void ReceiveModMessage(IncomingMessage message)
-        {
-            // parse message
-            string json = message.Reader.ReadString();
-            ModMessageModel model = this.JsonHelper.Deserialise<ModMessageModel>(json);
-            HashSet<long> playerIDs = new HashSet<long>(model.ToPlayerIDs ?? this.GetKnownPlayerIDs());
-            if (this.Monitor.IsVerbose)
-                this.Monitor.Log($"Received message: {json}.", LogLevel.Trace);
-
-            // notify local mods
-            if (playerIDs.Contains(Game1.player.UniqueMultiplayerID))
-                this.OnModMessageReceived(model);
-
-            // forward to other players
-            if (Context.IsMainPlayer && playerIDs.Any(p => p != Game1.player.UniqueMultiplayerID))
-            {
-                ModMessageModel newModel = new ModMessageModel(model);
-                foreach (long playerID in playerIDs)
-                {
-                    if (playerID != Game1.player.UniqueMultiplayerID && playerID != model.FromPlayerID && this.Peers.TryGetValue(playerID, out MultiplayerPeer peer))
-                    {
-                        newModel.ToPlayerIDs = new[] { peer.PlayerID };
-                        this.Monitor.VerboseLog($"  Forwarding message to player {peer.PlayerID}.");
-                        peer.SendMessage(new OutgoingMessage((byte)MessageType.ModMessage, peer.PlayerID, this.JsonHelper.Serialise(newModel, Formatting.None)));
-                    }
-                }
-            }
-        }
-
-        /// <summary>Get all connected player IDs, including the current player.</summary>
-        private IEnumerable<long> GetKnownPlayerIDs()
-        {
-            yield return Game1.player.UniqueMultiplayerID;
-            foreach (long peerID in this.Peers.Keys)
-                yield return peerID;
-        }
-
-        /// <summary>Get the fields to include in a context sync message sent to other players.</summary>
-        private object[] GetContextSyncMessageFields()
-        {
-            RemoteContextModel model = new RemoteContextModel
-            {
-                IsHost = Context.IsWorldReady && Context.IsMainPlayer,
-                Platform = Constants.TargetPlatform,
-                ApiVersion = Constants.ApiVersion,
-                GameVersion = Constants.GameVersion,
-                Mods = this.ModRegistry
-                    .GetAll()
-                    .Select(mod => new RemoteContextModModel
-                    {
-                        ID = mod.Manifest.UniqueID,
-                        Name = mod.Manifest.Name,
-                        Version = mod.Manifest.Version
-                    })
-                    .ToArray()
-            };
-
-            return new object[] { this.JsonHelper.Serialise(model, Formatting.None) };
-        }
-
-        /// <summary>Get the fields to include in a context sync message sent to other players.</summary>
-        /// <param name="peer">The peer whose data to represent.</param>
-        private object[] GetContextSyncMessageFields(IMultiplayerPeer peer)
-        {
-            if (!peer.HasSmapi)
-                return new object[] { "{}" };
-
-            RemoteContextModel model = new RemoteContextModel
-            {
-                IsHost = peer.IsHost,
-                Platform = peer.Platform.Value,
-                ApiVersion = peer.ApiVersion,
-                GameVersion = peer.GameVersion,
-                Mods = peer.Mods
-                    .Select(mod => new RemoteContextModModel
-                    {
-                        ID = mod.ID,
-                        Name = mod.Name,
-                        Version = mod.Version
-                    })
-                    .ToArray()
-            };
-
-            return new object[] { this.JsonHelper.Serialise(model, Formatting.None) };
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/StateTracking/LocationTracker.cs b/src/SMAPI/Framework/StateTracking/LocationTracker.cs
index 2249e41b..8a2ac1b7 100644
--- a/src/SMAPI/Framework/StateTracking/LocationTracker.cs
+++ b/src/SMAPI/Framework/StateTracking/LocationTracker.cs
@@ -62,7 +62,7 @@ namespace StardewModdingAPI.Framework.StateTracking
             this.BuildingsWatcher = location is BuildableGameLocation buildableLocation
                 ? WatcherFactory.ForNetCollection(buildableLocation.buildings)
                 : (ICollectionWatcher<Building>)WatcherFactory.ForObservableCollection(new ObservableCollection<Building>());
-            this.DebrisWatcher = WatcherFactory.ForNetCollection(location.debris);
+            this.DebrisWatcher = WatcherFactory.ForNetCollection(location.debris.debrisNetCollection);
             this.LargeTerrainFeaturesWatcher = WatcherFactory.ForNetCollection(location.largeTerrainFeatures);
             this.NpcsWatcher = WatcherFactory.ForNetCollection(location.characters);
             this.ObjectsWatcher = WatcherFactory.ForNetDictionary(location.netObjects);
diff --git a/src/SMAPI/Framework/StateTracking/WorldLocationsTracker.cs b/src/SMAPI/Framework/StateTracking/WorldLocationsTracker.cs
index f09c69c1..c9d6a703 100644
--- a/src/SMAPI/Framework/StateTracking/WorldLocationsTracker.cs
+++ b/src/SMAPI/Framework/StateTracking/WorldLocationsTracker.cs
@@ -53,9 +53,9 @@ namespace StardewModdingAPI.Framework.StateTracking
         /// <summary>Construct an instance.</summary>
         /// <param name="locations">The game's list of locations.</param>
         /// <param name="activeMineLocations">The game's list of active mine locations.</param>
-        public WorldLocationsTracker(ObservableCollection<GameLocation> locations, IList<MineShaft> activeMineLocations)
+        public WorldLocationsTracker(List<GameLocation> locations, IList<MineShaft> activeMineLocations)
         {
-            this.LocationListWatcher = WatcherFactory.ForObservableCollection(locations);
+            this.LocationListWatcher = WatcherFactory.ForReferenceList(locations);
             this.MineLocationListWatcher = WatcherFactory.ForReferenceList(activeMineLocations);
         }
 
diff --git a/src/SMAPI/Framework/WatcherCore.cs b/src/SMAPI/Framework/WatcherCore.cs
index 32b7fdc6..b1f00a68 100644
--- a/src/SMAPI/Framework/WatcherCore.cs
+++ b/src/SMAPI/Framework/WatcherCore.cs
@@ -65,7 +65,7 @@ namespace StardewModdingAPI.Framework
             this.WindowSizeWatcher = WatcherFactory.ForEquatable(() => new Point(Game1.viewport.Width, Game1.viewport.Height));
             this.TimeWatcher = WatcherFactory.ForEquatable(() => Game1.timeOfDay);
             this.ActiveMenuWatcher = WatcherFactory.ForReference(() => Game1.activeClickableMenu);
-            this.LocationsWatcher = new WorldLocationsTracker((ObservableCollection<GameLocation>)Game1.locations, MineShaft.activeMines);
+            this.LocationsWatcher = new WorldLocationsTracker(Game1.locations, MineShaft.activeMines);
             this.LocaleWatcher = WatcherFactory.ForGenericEquality(() => LocalizedContentManager.CurrentLanguageCode);
             this.Watchers.AddRange(new IWatcher[]
             {
diff --git a/src/SMAPI/IMod.cs b/src/SMAPI/IMod.cs
index 44ef32c9..6166a295 100644
--- a/src/SMAPI/IMod.cs
+++ b/src/SMAPI/IMod.cs
@@ -1,3 +1,6 @@
+using System.Collections.Generic;
+using StardewValley.Menus;
+
 namespace StardewModdingAPI
 {
     /// <summary>The implementation for a Stardew Valley mod.</summary>
@@ -23,6 +26,8 @@ namespace StardewModdingAPI
         /// <param name="helper">Provides simplified APIs for writing mods.</param>
         void Entry(IModHelper helper);
 
+        List<OptionsElement> GetConfigMenuItems();
+
         /// <summary>Get an API that other mods can access. This is always called after <see cref="Entry"/>.</summary>
         object GetApi();
     }
diff --git a/src/SMAPI/IModHelper.cs b/src/SMAPI/IModHelper.cs
index cd746e06..589a0ced 100644
--- a/src/SMAPI/IModHelper.cs
+++ b/src/SMAPI/IModHelper.cs
@@ -35,8 +35,8 @@ namespace StardewModdingAPI
         /// <summary>Metadata about loaded mods.</summary>
         IModRegistry ModRegistry { get; }
 
-        /// <summary>Provides multiplayer utilities.</summary>
-        IMultiplayerHelper Multiplayer { get; }
+        ///// <summary>Provides multiplayer utilities.</summary>
+        //IMultiplayerHelper Multiplayer { get; }
 
         /// <summary>Provides translations stored in the mod's <c>i18n</c> folder, with one file per locale (like <c>en.json</c>) containing a flat key => value structure. Translations are fetched with locale fallback, so missing translations are filled in from broader locales (like <c>pt-BR.json</c> &lt; <c>pt.json</c> &lt; <c>default.json</c>).</summary>
         ITranslationHelper Translation { get; }
diff --git a/src/SMAPI/IMultiplayerHelper.cs b/src/SMAPI/IMultiplayerHelper.cs
deleted file mode 100644
index 4067a676..00000000
--- a/src/SMAPI/IMultiplayerHelper.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-using System.Collections.Generic;
-using StardewValley;
-
-namespace StardewModdingAPI
-{
-    /// <summary>Provides multiplayer utilities.</summary>
-    public interface IMultiplayerHelper : IModLinked
-    {
-        /// <summary>Get a new multiplayer ID.</summary>
-        long GetNewID();
-
-        /// <summary>Get the locations which are being actively synced from the host.</summary>
-        IEnumerable<GameLocation> GetActiveLocations();
-
-        /// <summary>Get a connected player.</summary>
-        /// <param name="id">The player's unique ID.</param>
-        /// <returns>Returns the connected player, or <c>null</c> if no such player is connected.</returns>
-        IMultiplayerPeer GetConnectedPlayer(long id);
-
-        /// <summary>Get all connected players.</summary>
-        IEnumerable<IMultiplayerPeer> GetConnectedPlayers();
-
-        /// <summary>Send a message to mods installed by connected players.</summary>
-        /// <typeparam name="TMessage">The data type. This can be a class with a default constructor, or a value type.</typeparam>
-        /// <param name="message">The data to send over the network.</param>
-        /// <param name="messageType">A message type which receiving mods can use to decide whether it's the one they want to handle, like <c>SetPlayerLocation</c>. This doesn't need to be globally unique, since mods should check the originating mod ID.</param>
-        /// <param name="modIDs">The mod IDs which should receive the message on the destination computers, or <c>null</c> for all mods. Specifying mod IDs is recommended to improve performance, unless it's a general-purpose broadcast.</param>
-        /// <param name="playerIDs">The <see cref="Farmer.UniqueMultiplayerID" /> values for the players who should receive the message, or <c>null</c> for all players. If you don't need to broadcast to all players, specifying player IDs is recommended to reduce latency.</param>
-        /// <exception cref="ArgumentNullException">The <paramref name="message"/> or <paramref name="messageType" /> is null.</exception>
-        void SendMessage<TMessage>(TMessage message, string messageType, string[] modIDs = null, long[] playerIDs = null);
-    }
-}
diff --git a/src/SMAPI.Internal/ConsoleWriting/ColorfulConsoleWriter.cs b/src/SMAPI/Internal/ConsoleWriting/ColorfulConsoleWriter.cs
similarity index 100%
rename from src/SMAPI.Internal/ConsoleWriting/ColorfulConsoleWriter.cs
rename to src/SMAPI/Internal/ConsoleWriting/ColorfulConsoleWriter.cs
diff --git a/src/SMAPI.Internal/ConsoleWriting/LogLevel.cs b/src/SMAPI/Internal/ConsoleWriting/LogLevel.cs
similarity index 100%
rename from src/SMAPI.Internal/ConsoleWriting/LogLevel.cs
rename to src/SMAPI/Internal/ConsoleWriting/LogLevel.cs
diff --git a/src/SMAPI.Internal/ConsoleWriting/MonitorColorScheme.cs b/src/SMAPI/Internal/ConsoleWriting/MonitorColorScheme.cs
similarity index 92%
rename from src/SMAPI.Internal/ConsoleWriting/MonitorColorScheme.cs
rename to src/SMAPI/Internal/ConsoleWriting/MonitorColorScheme.cs
index bccb56d7..6dd5199e 100644
--- a/src/SMAPI.Internal/ConsoleWriting/MonitorColorScheme.cs
+++ b/src/SMAPI/Internal/ConsoleWriting/MonitorColorScheme.cs
@@ -1,7 +1,7 @@
 namespace StardewModdingAPI.Internal.ConsoleWriting
 {
     /// <summary>A monitor color scheme to use.</summary>
-    internal enum MonitorColorScheme
+    public enum MonitorColorScheme
     {
         /// <summary>Choose a color scheme automatically.</summary>
         AutoDetect,
diff --git a/src/SMAPI.Internal/EnvironmentUtility.cs b/src/SMAPI/Internal/EnvironmentUtility.cs
similarity index 100%
rename from src/SMAPI.Internal/EnvironmentUtility.cs
rename to src/SMAPI/Internal/EnvironmentUtility.cs
diff --git a/src/SMAPI.Internal/Platform.cs b/src/SMAPI/Internal/Platform.cs
similarity index 81%
rename from src/SMAPI.Internal/Platform.cs
rename to src/SMAPI/Internal/Platform.cs
index 81ca5c1f..d2fa7ab6 100644
--- a/src/SMAPI.Internal/Platform.cs
+++ b/src/SMAPI/Internal/Platform.cs
@@ -9,6 +9,9 @@ namespace StardewModdingAPI.Internal
         /// <summary>The Mac version of the game.</summary>
         Mac,
 
+        /// <summary>The Android version of the game.</summary>
+        Android,
+
         /// <summary>The Windows version of the game.</summary>
         Windows
     }
diff --git a/src/SMAPI/Mod.cs b/src/SMAPI/Mod.cs
index 3a753afc..d47932a0 100644
--- a/src/SMAPI/Mod.cs
+++ b/src/SMAPI/Mod.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using StardewValley.Menus;
 
 namespace StardewModdingAPI
 {
@@ -25,6 +27,11 @@ namespace StardewModdingAPI
         /// <param name="helper">Provides simplified APIs for writing mods.</param>
         public abstract void Entry(IModHelper helper);
 
+        public virtual List<OptionsElement> GetConfigMenuItems()
+        {
+            return new List<OptionsElement>();
+        }
+
         /// <summary>Get an API that other mods can access. This is always called after <see cref="Entry"/>.</summary>
         public virtual object GetApi() => null;
 
diff --git a/src/SMAPI/Patches/LoadForNewGamePatch.cs b/src/SMAPI/Patches/LoadForNewGamePatch.cs
index 9e788e84..3f75b71b 100644
--- a/src/SMAPI/Patches/LoadForNewGamePatch.cs
+++ b/src/SMAPI/Patches/LoadForNewGamePatch.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.Reflection;
@@ -75,8 +76,8 @@ namespace StardewModdingAPI.Patches
             if (LoadForNewGamePatch.IsCreating)
             {
                 // raise CreatedBasicInfo after locations are cleared twice
-                ObservableCollection<GameLocation> locations = (ObservableCollection<GameLocation>)Game1.locations;
-                locations.CollectionChanged += LoadForNewGamePatch.OnLocationListChanged;
+                List<GameLocation> locations = Game1.locations;
+                //locations.CollectionChanged += LoadForNewGamePatch.OnLocationListChanged;
             }
 
             return true;
@@ -89,8 +90,8 @@ namespace StardewModdingAPI.Patches
             if (LoadForNewGamePatch.IsCreating)
             {
                 // clean up
-                ObservableCollection<GameLocation> locations = (ObservableCollection<GameLocation>) Game1.locations;
-                locations.CollectionChanged -= LoadForNewGamePatch.OnLocationListChanged;
+                List<GameLocation> locations = Game1.locations;
+                //locations.CollectionChanged -= LoadForNewGamePatch.OnLocationListChanged;
 
                 // raise stage changed
                 LoadForNewGamePatch.OnStageChanged(LoadStage.CreatedLocations);
diff --git a/src/SMAPI/Program.cs b/src/SMAPI/Program.cs
index 3a34872a..6818b7c4 100644
--- a/src/SMAPI/Program.cs
+++ b/src/SMAPI/Program.cs
@@ -131,8 +131,8 @@ namespace StardewModdingAPI
             }
 
             // load SMAPI
-            using (SCore core = new SCore(modsPath, writeToConsole))
-                core.RunInteractively();
+            //using (SCore core = new SCore(modsPath, writeToConsole))
+            //    core.RunInteractively();
         }
 
         /// <summary>Write an error directly to the console and exit.</summary>
diff --git a/src/SMAPI/Properties/AssemblyInfo.cs b/src/SMAPI/Properties/AssemblyInfo.cs
deleted file mode 100644
index 03843ea8..00000000
--- a/src/SMAPI/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-[assembly: AssemblyTitle("SMAPI")]
-[assembly: AssemblyDescription("A modding API for Stardew Valley.")]
-[assembly: InternalsVisibleTo("StardewModdingAPI.Tests")]
-[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")] // Moq for unit testing
diff --git a/src/StardewModdingAPI.Toolkit.CoreInterfaces/IManifest.cs b/src/SMAPI/Toolkit/CoreInterfaces/IManifest.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit.CoreInterfaces/IManifest.cs
rename to src/SMAPI/Toolkit/CoreInterfaces/IManifest.cs
diff --git a/src/StardewModdingAPI.Toolkit.CoreInterfaces/IManifestContentPackFor.cs b/src/SMAPI/Toolkit/CoreInterfaces/IManifestContentPackFor.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit.CoreInterfaces/IManifestContentPackFor.cs
rename to src/SMAPI/Toolkit/CoreInterfaces/IManifestContentPackFor.cs
diff --git a/src/StardewModdingAPI.Toolkit.CoreInterfaces/IManifestDependency.cs b/src/SMAPI/Toolkit/CoreInterfaces/IManifestDependency.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit.CoreInterfaces/IManifestDependency.cs
rename to src/SMAPI/Toolkit/CoreInterfaces/IManifestDependency.cs
diff --git a/src/StardewModdingAPI.Toolkit.CoreInterfaces/ISemanticVersion.cs b/src/SMAPI/Toolkit/CoreInterfaces/ISemanticVersion.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit.CoreInterfaces/ISemanticVersion.cs
rename to src/SMAPI/Toolkit/CoreInterfaces/ISemanticVersion.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/MetadataModel.cs b/src/SMAPI/Toolkit/Framework/ModData/MetadataModel.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/MetadataModel.cs
rename to src/SMAPI/Toolkit/Framework/ModData/MetadataModel.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataField.cs b/src/SMAPI/Toolkit/Framework/ModData/ModDataField.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataField.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModDataField.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataFieldKey.cs b/src/SMAPI/Toolkit/Framework/ModData/ModDataFieldKey.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataFieldKey.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModDataFieldKey.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataModel.cs b/src/SMAPI/Toolkit/Framework/ModData/ModDataModel.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataModel.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModDataModel.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataRecord.cs b/src/SMAPI/Toolkit/Framework/ModData/ModDataRecord.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataRecord.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModDataRecord.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataRecordVersionedFields.cs b/src/SMAPI/Toolkit/Framework/ModData/ModDataRecordVersionedFields.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModDataRecordVersionedFields.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModDataRecordVersionedFields.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModDatabase.cs b/src/SMAPI/Toolkit/Framework/ModData/ModDatabase.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModDatabase.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModDatabase.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModStatus.cs b/src/SMAPI/Toolkit/Framework/ModData/ModStatus.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModStatus.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModStatus.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModData/ModWarning.cs b/src/SMAPI/Toolkit/Framework/ModData/ModWarning.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModData/ModWarning.cs
rename to src/SMAPI/Toolkit/Framework/ModData/ModWarning.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModScanning/ModFolder.cs b/src/SMAPI/Toolkit/Framework/ModScanning/ModFolder.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModScanning/ModFolder.cs
rename to src/SMAPI/Toolkit/Framework/ModScanning/ModFolder.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/ModScanning/ModScanner.cs b/src/SMAPI/Toolkit/Framework/ModScanning/ModScanner.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/ModScanning/ModScanner.cs
rename to src/SMAPI/Toolkit/Framework/ModScanning/ModScanner.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/UpdateData/ModRepositoryKey.cs b/src/SMAPI/Toolkit/Framework/UpdateData/ModRepositoryKey.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/UpdateData/ModRepositoryKey.cs
rename to src/SMAPI/Toolkit/Framework/UpdateData/ModRepositoryKey.cs
diff --git a/src/StardewModdingAPI.Toolkit/Framework/UpdateData/UpdateKey.cs b/src/SMAPI/Toolkit/Framework/UpdateData/UpdateKey.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Framework/UpdateData/UpdateKey.cs
rename to src/SMAPI/Toolkit/Framework/UpdateData/UpdateKey.cs
diff --git a/src/StardewModdingAPI.Toolkit/ModToolkit.cs b/src/SMAPI/Toolkit/ModToolkit.cs
similarity index 90%
rename from src/StardewModdingAPI.Toolkit/ModToolkit.cs
rename to src/SMAPI/Toolkit/ModToolkit.cs
index 1b53e59e..5f09a89a 100644
--- a/src/StardewModdingAPI.Toolkit/ModToolkit.cs
+++ b/src/SMAPI/Toolkit/ModToolkit.cs
@@ -4,7 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
-using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
+//using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
 using StardewModdingAPI.Toolkit.Framework.ModData;
 using StardewModdingAPI.Toolkit.Framework.ModScanning;
 using StardewModdingAPI.Toolkit.Serialisation;
@@ -46,12 +46,12 @@ namespace StardewModdingAPI.Toolkit
             this.UserAgent = $"SMAPI Mod Handler Toolkit/{version}";
         }
 
-        /// <summary>Extract mod metadata from the wiki compatibility list.</summary>
-        public async Task<WikiModList> GetWikiCompatibilityListAsync()
-        {
-            var client = new WikiClient(this.UserAgent);
-            return await client.FetchModsAsync();
-        }
+        ///// <summary>Extract mod metadata from the wiki compatibility list.</summary>
+        //public async Task<WikiModList> GetWikiCompatibilityListAsync()
+        //{
+        //    var client = new WikiClient(this.UserAgent);
+        //    return await client.FetchModsAsync();
+        //}
 
         /// <summary>Get SMAPI's internal mod database.</summary>
         /// <param name="metadataPath">The file path for the SMAPI metadata file.</param>
diff --git a/src/StardewModdingAPI.Toolkit/SemanticVersion.cs b/src/SMAPI/Toolkit/SemanticVersion.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/SemanticVersion.cs
rename to src/SMAPI/Toolkit/SemanticVersion.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/Converters/ManifestContentPackForConverter.cs b/src/SMAPI/Toolkit/Serialisation/Converters/ManifestContentPackForConverter.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/Converters/ManifestContentPackForConverter.cs
rename to src/SMAPI/Toolkit/Serialisation/Converters/ManifestContentPackForConverter.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/Converters/ManifestDependencyArrayConverter.cs b/src/SMAPI/Toolkit/Serialisation/Converters/ManifestDependencyArrayConverter.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/Converters/ManifestDependencyArrayConverter.cs
rename to src/SMAPI/Toolkit/Serialisation/Converters/ManifestDependencyArrayConverter.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/Converters/SemanticVersionConverter.cs b/src/SMAPI/Toolkit/Serialisation/Converters/SemanticVersionConverter.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/Converters/SemanticVersionConverter.cs
rename to src/SMAPI/Toolkit/Serialisation/Converters/SemanticVersionConverter.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/Converters/SimpleReadOnlyConverter.cs b/src/SMAPI/Toolkit/Serialisation/Converters/SimpleReadOnlyConverter.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/Converters/SimpleReadOnlyConverter.cs
rename to src/SMAPI/Toolkit/Serialisation/Converters/SimpleReadOnlyConverter.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/InternalExtensions.cs b/src/SMAPI/Toolkit/Serialisation/InternalExtensions.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/InternalExtensions.cs
rename to src/SMAPI/Toolkit/Serialisation/InternalExtensions.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/JsonHelper.cs b/src/SMAPI/Toolkit/Serialisation/JsonHelper.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/JsonHelper.cs
rename to src/SMAPI/Toolkit/Serialisation/JsonHelper.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/Models/Manifest.cs b/src/SMAPI/Toolkit/Serialisation/Models/Manifest.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/Models/Manifest.cs
rename to src/SMAPI/Toolkit/Serialisation/Models/Manifest.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/Models/ManifestContentPackFor.cs b/src/SMAPI/Toolkit/Serialisation/Models/ManifestContentPackFor.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/Models/ManifestContentPackFor.cs
rename to src/SMAPI/Toolkit/Serialisation/Models/ManifestContentPackFor.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/Models/ManifestDependency.cs b/src/SMAPI/Toolkit/Serialisation/Models/ManifestDependency.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/Models/ManifestDependency.cs
rename to src/SMAPI/Toolkit/Serialisation/Models/ManifestDependency.cs
diff --git a/src/StardewModdingAPI.Toolkit/Serialisation/SParseException.cs b/src/SMAPI/Toolkit/Serialisation/SParseException.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Serialisation/SParseException.cs
rename to src/SMAPI/Toolkit/Serialisation/SParseException.cs
diff --git a/src/StardewModdingAPI.Toolkit/Utilities/FileUtilities.cs b/src/SMAPI/Toolkit/Utilities/FileUtilities.cs
similarity index 90%
rename from src/StardewModdingAPI.Toolkit/Utilities/FileUtilities.cs
rename to src/SMAPI/Toolkit/Utilities/FileUtilities.cs
index 7856fdb1..bc16ac99 100644
--- a/src/StardewModdingAPI.Toolkit/Utilities/FileUtilities.cs
+++ b/src/SMAPI/Toolkit/Utilities/FileUtilities.cs
@@ -19,9 +19,9 @@ namespace StardewModdingAPI.Toolkit.Utilities
                 return;
 
             // delete children
-            if (entry is DirectoryInfo folder)
+            if (entry is DirectoryInfo)
             {
-                foreach (FileSystemInfo child in folder.GetFileSystemInfos())
+                foreach (FileSystemInfo child in ((DirectoryInfo)entry).GetFileSystemInfos())
                     FileUtilities.ForceDelete(child);
             }
 
diff --git a/src/StardewModdingAPI.Toolkit/Utilities/PathUtilities.cs b/src/SMAPI/Toolkit/Utilities/PathUtilities.cs
similarity index 100%
rename from src/StardewModdingAPI.Toolkit/Utilities/PathUtilities.cs
rename to src/SMAPI/Toolkit/Utilities/PathUtilities.cs
diff --git a/src/StardewModdingAPI.Toolkit.CoreInterfaces/Properties/AssemblyInfo.cs b/src/StardewModdingAPI.Toolkit.CoreInterfaces/Properties/AssemblyInfo.cs
deleted file mode 100644
index a29ba6cf..00000000
--- a/src/StardewModdingAPI.Toolkit.CoreInterfaces/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using System.Reflection;
-
-[assembly: AssemblyTitle("SMAPI.Toolkit.CoreInterfaces")]
-[assembly: AssemblyDescription("Provides toolkit interfaces which are available to SMAPI mods.")]
diff --git a/src/StardewModdingAPI.Toolkit.CoreInterfaces/StardewModdingAPI.Toolkit.CoreInterfaces.csproj b/src/StardewModdingAPI.Toolkit.CoreInterfaces/StardewModdingAPI.Toolkit.CoreInterfaces.csproj
deleted file mode 100644
index 67adbd67..00000000
--- a/src/StardewModdingAPI.Toolkit.CoreInterfaces/StardewModdingAPI.Toolkit.CoreInterfaces.csproj
+++ /dev/null
@@ -1,18 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net4.5;netstandard2.0</TargetFrameworks>
-    <RootNamespace>StardewModdingAPI</RootNamespace>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <OutputPath>..\..\bin\$(Configuration)\SMAPI.Toolkit.CoreInterfaces</OutputPath>
-    <DocumentationFile>..\..\bin\$(Configuration)\SMAPI.Toolkit.CoreInterfaces\$(TargetFramework)\StardewModdingAPI.Toolkit.CoreInterfaces.xml</DocumentationFile>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs" Link="Properties\GlobalAssemblyInfo.cs" />
-  </ItemGroup>
-
-  <Import Project="..\..\build\common.targets" />
-
-</Project>
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModEntryModel.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModEntryModel.cs
deleted file mode 100644
index 8a9c0a25..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModEntryModel.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.WebApi
-{
-    /// <summary>Metadata about a mod.</summary>
-    public class ModEntryModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod's unique ID (if known).</summary>
-        public string ID { get; set; }
-
-        /// <summary>The main version.</summary>
-        public ModEntryVersionModel Main { get; set; }
-
-        /// <summary>The latest optional version, if newer than <see cref="Main"/>.</summary>
-        public ModEntryVersionModel Optional { get; set; }
-
-        /// <summary>The latest unofficial version, if newer than <see cref="Main"/> and <see cref="Optional"/>.</summary>
-        public ModEntryVersionModel Unofficial { get; set; }
-
-        /// <summary>The latest unofficial version for the current Stardew Valley or SMAPI beta, if any (see <see cref="HasBetaInfo"/>).</summary>
-        public ModEntryVersionModel UnofficialForBeta { get; set; }
-
-        /// <summary>Optional extended data which isn't needed for update checks.</summary>
-        public ModExtendedMetadataModel Metadata { get; set; }
-
-        /// <summary>Whether a Stardew Valley or SMAPI beta which affects mod compatibility is in progress. If this is true, <see cref="UnofficialForBeta"/> should be used for beta versions of SMAPI instead of <see cref="Unofficial"/>.</summary>
-        public bool HasBetaInfo { get; set; }
-
-        /// <summary>The errors that occurred while fetching update data.</summary>
-        public string[] Errors { get; set; } = new string[0];
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModEntryVersionModel.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModEntryVersionModel.cs
deleted file mode 100644
index dadb8c10..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModEntryVersionModel.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.WebApi
-{
-    /// <summary>Metadata about a version.</summary>
-    public class ModEntryVersionModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The version number.</summary>
-        public ISemanticVersion Version { get; set; }
-
-        /// <summary>The mod page URL.</summary>
-        public string Url { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ModEntryVersionModel() { }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="version">The version number.</param>
-        /// <param name="url">The mod page URL.</param>
-        public ModEntryVersionModel(ISemanticVersion version, string url)
-        {
-            this.Version = version;
-            this.Url = url;
-        }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModExtendedMetadataModel.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModExtendedMetadataModel.cs
deleted file mode 100644
index 45b46ea6..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModExtendedMetadataModel.cs
+++ /dev/null
@@ -1,126 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
-using StardewModdingAPI.Toolkit.Framework.ModData;
-
-namespace StardewModdingAPI.Toolkit.Framework.Clients.WebApi
-{
-    /// <summary>Extended metadata about a mod.</summary>
-    public class ModExtendedMetadataModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /****
-        ** Mod info
-        ****/
-        /// <summary>The mod's unique ID. A mod may have multiple current IDs in rare cases (e.g. due to parallel releases or unofficial updates).</summary>
-        public string[] ID { get; set; } = new string[0];
-
-        /// <summary>The mod's display name.</summary>
-        public string Name { get; set; }
-
-        /// <summary>The mod ID on Nexus.</summary>
-        public int? NexusID { get; set; }
-
-        /// <summary>The mod ID in the Chucklefish mod repo.</summary>
-        public int? ChucklefishID { get; set; }
-
-        /// <summary>The mod ID in the ModDrop mod repo.</summary>
-        public int? ModDropID { get; set; }
-
-        /// <summary>The GitHub repository in the form 'owner/repo'.</summary>
-        public string GitHubRepo { get; set; }
-
-        /// <summary>The URL to a non-GitHub source repo.</summary>
-        public string CustomSourceUrl { get; set; }
-
-        /// <summary>The custom mod page URL (if applicable).</summary>
-        public string CustomUrl { get; set; }
-
-        /****
-        ** SMAPI 3.0 readiness
-        ****/
-        /// <summary>Whether the mod is ready for the upcoming SMAPI 3.0.</summary>
-        public WikiSmapi3Status Smapi3Status { get; set; }
-
-        /// <summary>A URL related to the <see cref="Smapi3Status"/>.</summary>
-        public string Smapi3Url { get; set; }
-
-        /****
-        ** Stable compatibility
-        ****/
-        /// <summary>The compatibility status.</summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public WikiCompatibilityStatus? CompatibilityStatus { get; set; }
-
-        /// <summary>The human-readable summary of the compatibility status or workaround, without HTML formatitng.</summary>
-        public string CompatibilitySummary { get; set; }
-
-
-        /****
-        ** Beta compatibility
-        ****/
-        /// <summary>The compatibility status for the Stardew Valley beta (if any).</summary>
-        [JsonConverter(typeof(StringEnumConverter))]
-        public WikiCompatibilityStatus? BetaCompatibilityStatus { get; set; }
-
-        /// <summary>The human-readable summary of the compatibility status or workaround for the Stardew Valley beta (if any), without HTML formatitng.</summary>
-        public string BetaCompatibilitySummary { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        public ModExtendedMetadataModel() { }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="wiki">The mod metadata from the wiki (if available).</param>
-        /// <param name="db">The mod metadata from SMAPI's internal DB (if available).</param>
-        public ModExtendedMetadataModel(WikiModEntry wiki, ModDataRecord db)
-        {
-            // wiki data
-            if (wiki != null)
-            {
-                this.ID = wiki.ID;
-                this.Name = wiki.Name.FirstOrDefault();
-                this.NexusID = wiki.NexusID;
-                this.ChucklefishID = wiki.ChucklefishID;
-                this.ModDropID = wiki.ModDropID;
-                this.GitHubRepo = wiki.GitHubRepo;
-                this.CustomSourceUrl = wiki.CustomSourceUrl;
-                this.CustomUrl = wiki.CustomUrl;
-
-                this.Smapi3Status = wiki.Smapi3Status;
-                this.Smapi3Url = wiki.Smapi3Url;
-
-                this.CompatibilityStatus = wiki.Compatibility.Status;
-                this.CompatibilitySummary = wiki.Compatibility.Summary;
-
-                this.BetaCompatibilityStatus = wiki.BetaCompatibility?.Status;
-                this.BetaCompatibilitySummary = wiki.BetaCompatibility?.Summary;
-            }
-
-            // internal DB data
-            if (db != null)
-            {
-                this.ID = this.ID.Union(db.FormerIDs).ToArray();
-                this.Name = this.Name ?? db.DisplayName;
-            }
-        }
-
-        /// <summary>Get update keys based on the metadata.</summary>
-        public IEnumerable<string> GetUpdateKeys()
-        {
-            if (this.NexusID.HasValue)
-                yield return $"Nexus:{this.NexusID}";
-            if (this.ChucklefishID.HasValue)
-                yield return $"Chucklefish:{this.ChucklefishID}";
-            if (this.GitHubRepo != null)
-                yield return $"GitHub:{this.GitHubRepo}";
-        }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModSeachModel.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModSeachModel.cs
deleted file mode 100644
index e352e1cc..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModSeachModel.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System.Linq;
-
-namespace StardewModdingAPI.Toolkit.Framework.Clients.WebApi
-{
-    /// <summary>Specifies mods whose update-check info to fetch.</summary>
-    public class ModSearchModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mods for which to find data.</summary>
-        public ModSearchEntryModel[] Mods { get; set; }
-
-        /// <summary>Whether to include extended metadata for each mod.</summary>
-        public bool IncludeExtendedMetadata { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an empty instance.</summary>
-        public ModSearchModel()
-        {
-            // needed for JSON deserialising
-        }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="mods">The mods to search.</param>
-        /// <param name="includeExtendedMetadata">Whether to include extended metadata for each mod.</param>
-        public ModSearchModel(ModSearchEntryModel[] mods, bool includeExtendedMetadata)
-        {
-            this.Mods = mods.ToArray();
-            this.IncludeExtendedMetadata = includeExtendedMetadata;
-        }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModSearchEntryModel.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModSearchEntryModel.cs
deleted file mode 100644
index bca47647..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/ModSearchEntryModel.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.WebApi
-{
-    /// <summary>Specifies the identifiers for a mod to match.</summary>
-    public class ModSearchEntryModel
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The unique mod ID.</summary>
-        public string ID { get; set; }
-
-        /// <summary>The namespaced mod update keys (if available).</summary>
-        public string[] UpdateKeys { get; set; }
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an empty instance.</summary>
-        public ModSearchEntryModel()
-        {
-            // needed for JSON deserialising
-        }
-
-        /// <summary>Construct an instance.</summary>
-        /// <param name="id">The unique mod ID.</param>
-        /// <param name="updateKeys">The namespaced mod update keys (if available).</param>
-        public ModSearchEntryModel(string id, string[] updateKeys)
-        {
-            this.ID = id;
-            this.UpdateKeys = updateKeys ?? new string[0];
-        }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/WebApiClient.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/WebApiClient.cs
deleted file mode 100644
index 7c3df384..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/WebApi/WebApiClient.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using Newtonsoft.Json;
-using StardewModdingAPI.Toolkit.Serialisation;
-
-namespace StardewModdingAPI.Toolkit.Framework.Clients.WebApi
-{
-    /// <summary>Provides methods for interacting with the SMAPI web API.</summary>
-    public class WebApiClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The base URL for the web API.</summary>
-        private readonly Uri BaseUrl;
-
-        /// <summary>The API version number.</summary>
-        private readonly ISemanticVersion Version;
-
-        /// <summary>The JSON serializer settings to use.</summary>
-        private readonly JsonSerializerSettings JsonSettings = new JsonHelper().JsonSettings;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="baseUrl">The base URL for the web API.</param>
-        /// <param name="version">The web API version.</param>
-        public WebApiClient(string baseUrl, ISemanticVersion version)
-        {
-            this.BaseUrl = new Uri(baseUrl);
-            this.Version = version;
-        }
-
-        /// <summary>Get metadata about a set of mods from the web API.</summary>
-        /// <param name="mods">The mod keys for which to fetch the latest version.</param>
-        /// <param name="includeExtendedMetadata">Whether to include extended metadata for each mod.</param>
-        public IDictionary<string, ModEntryModel> GetModInfo(ModSearchEntryModel[] mods, bool includeExtendedMetadata = false)
-        {
-            return this.Post<ModSearchModel, ModEntryModel[]>(
-                $"v{this.Version}/mods",
-                new ModSearchModel(mods, includeExtendedMetadata)
-            ).ToDictionary(p => p.ID);
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Fetch the response from the backend API.</summary>
-        /// <typeparam name="TBody">The body content type.</typeparam>
-        /// <typeparam name="TResult">The expected response type.</typeparam>
-        /// <param name="url">The request URL, optionally excluding the base URL.</param>
-        /// <param name="content">The body content to post.</param>
-        private TResult Post<TBody, TResult>(string url, TBody content)
-        {
-            // note: avoid HttpClient for Mac compatibility
-            using (WebClient client = new WebClient())
-            {
-                Uri fullUrl = new Uri(this.BaseUrl, url);
-                string data = JsonConvert.SerializeObject(content);
-
-                client.Headers["Content-Type"] = "application/json";
-                client.Headers["User-Agent"] = $"SMAPI/{this.Version}";
-                string response = client.UploadString(fullUrl, data);
-                return JsonConvert.DeserializeObject<TResult>(response, this.JsonSettings);
-            }
-        }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiClient.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiClient.cs
deleted file mode 100644
index ac279d88..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiClient.cs
+++ /dev/null
@@ -1,243 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Net;
-using System.Threading.Tasks;
-using HtmlAgilityPack;
-using Pathoschild.Http.Client;
-
-namespace StardewModdingAPI.Toolkit.Framework.Clients.Wiki
-{
-    /// <summary>An HTTP client for fetching mod metadata from the wiki.</summary>
-    public class WikiClient : IDisposable
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="userAgent">The user agent for the wiki API.</param>
-        /// <param name="baseUrl">The base URL for the wiki API.</param>
-        public WikiClient(string userAgent, string baseUrl = "https://stardewvalleywiki.com/mediawiki/api.php")
-        {
-            this.Client = new FluentClient(baseUrl).SetUserAgent(userAgent);
-        }
-
-        /// <summary>Fetch mods from the compatibility list.</summary>
-        public async Task<WikiModList> FetchModsAsync()
-        {
-            // fetch HTML
-            ResponseModel response = await this.Client
-                .GetAsync("")
-                .WithArguments(new
-                {
-                    action = "parse",
-                    page = "Modding:Mod_compatibility",
-                    format = "json"
-                })
-                .As<ResponseModel>();
-            string html = response.Parse.Text["*"];
-
-            // parse HTML
-            var doc = new HtmlDocument();
-            doc.LoadHtml(html);
-
-            // fetch game versions
-            string stableVersion = doc.DocumentNode.SelectSingleNode("div[@class='game-stable-version']")?.InnerText;
-            string betaVersion = doc.DocumentNode.SelectSingleNode("div[@class='game-beta-version']")?.InnerText;
-            if (betaVersion == stableVersion)
-                betaVersion = null;
-
-            // find mod entries
-            HtmlNodeCollection modNodes = doc.DocumentNode.SelectNodes("table[@id='mod-list']//tr[@class='mod']");
-            if (modNodes == null)
-                throw new InvalidOperationException("Can't parse wiki compatibility list, no mods found.");
-
-            // parse
-            WikiModEntry[] mods = this.ParseEntries(modNodes).ToArray();
-            return new WikiModList
-            {
-                StableVersion = stableVersion,
-                BetaVersion = betaVersion,
-                Mods = mods
-            };
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public void Dispose()
-        {
-            this.Client?.Dispose();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Parse valid mod compatibility entries.</summary>
-        /// <param name="nodes">The HTML compatibility entries.</param>
-        private IEnumerable<WikiModEntry> ParseEntries(IEnumerable<HtmlNode> nodes)
-        {
-            foreach (HtmlNode node in nodes)
-            {
-                // extract fields
-                string[] names = this.GetAttributeAsCsv(node, "data-name");
-                string[] authors = this.GetAttributeAsCsv(node, "data-author");
-                string[] ids = this.GetAttributeAsCsv(node, "data-id");
-                string[] warnings = this.GetAttributeAsCsv(node, "data-warnings");
-                int? nexusID = this.GetAttributeAsNullableInt(node, "data-nexus-id");
-                int? chucklefishID = this.GetAttributeAsNullableInt(node, "data-cf-id");
-                int? modDropID = this.GetAttributeAsNullableInt(node, "data-moddrop-id");
-                string githubRepo = this.GetAttribute(node, "data-github");
-                string customSourceUrl = this.GetAttribute(node, "data-custom-source");
-                string customUrl = this.GetAttribute(node, "data-url");
-                string anchor = this.GetAttribute(node, "id");
-                string contentPackFor = this.GetAttribute(node, "data-content-pack-for");
-
-                // parse stable compatibility
-                WikiCompatibilityInfo compatibility = new WikiCompatibilityInfo
-                {
-                    Status = this.GetAttributeAsEnum<WikiCompatibilityStatus>(node, "data-status") ?? WikiCompatibilityStatus.Ok,
-                    BrokeIn = this.GetAttribute(node, "data-broke-in"),
-                    UnofficialVersion = this.GetAttributeAsSemanticVersion(node, "data-unofficial-version"),
-                    UnofficialUrl = this.GetAttribute(node, "data-unofficial-url"),
-                    Summary = this.GetInnerHtml(node, "mod-summary")?.Trim()
-                };
-
-                // parse beta compatibility
-                WikiCompatibilityInfo betaCompatibility = null;
-                {
-                    WikiCompatibilityStatus? betaStatus = this.GetAttributeAsEnum<WikiCompatibilityStatus>(node, "data-beta-status");
-                    if (betaStatus.HasValue)
-                    {
-                        betaCompatibility = new WikiCompatibilityInfo
-                        {
-                            Status = betaStatus.Value,
-                            BrokeIn = this.GetAttribute(node, "data-beta-broke-in"),
-                            UnofficialVersion = this.GetAttributeAsSemanticVersion(node, "data-beta-unofficial-version"),
-                            UnofficialUrl = this.GetAttribute(node, "data-beta-unofficial-url"),
-                            Summary = this.GetInnerHtml(node, "mod-beta-summary")
-                        };
-                    }
-                }
-
-                // parse SMAPI 3.0 readiness status
-                WikiSmapi3Status smapi3Status = this.GetAttributeAsEnum<WikiSmapi3Status>(node, "data-smapi-3-status") ?? WikiSmapi3Status.Unknown;
-                string smapi3Url = this.GetAttribute(node, "data-smapi-3-url");
-
-                // yield model
-                yield return new WikiModEntry
-                {
-                    ID = ids,
-                    Name = names,
-                    Author = authors,
-                    NexusID = nexusID,
-                    ChucklefishID = chucklefishID,
-                    ModDropID = modDropID,
-                    GitHubRepo = githubRepo,
-                    CustomSourceUrl = customSourceUrl,
-                    CustomUrl = customUrl,
-                    ContentPackFor = contentPackFor,
-                    Compatibility = compatibility,
-                    BetaCompatibility = betaCompatibility,
-                    Smapi3Status = smapi3Status,
-                    Smapi3Url = smapi3Url,
-                    Warnings = warnings,
-                    Anchor = anchor
-                };
-            }
-        }
-
-        /// <summary>Get an attribute value.</summary>
-        /// <param name="element">The element whose attributes to read.</param>
-        /// <param name="name">The attribute name.</param>
-        private string GetAttribute(HtmlNode element, string name)
-        {
-            string value = element.GetAttributeValue(name, null);
-            if (string.IsNullOrWhiteSpace(value))
-                return null;
-
-            return WebUtility.HtmlDecode(value);
-        }
-
-        /// <summary>Get an attribute value and parse it as a comma-delimited list of strings.</summary>
-        /// <param name="element">The element whose attributes to read.</param>
-        /// <param name="name">The attribute name.</param>
-        private string[] GetAttributeAsCsv(HtmlNode element, string name)
-        {
-            string raw = this.GetAttribute(element, name);
-            return !string.IsNullOrWhiteSpace(raw)
-                ? raw.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToArray()
-                : new string[0];
-        }
-
-        /// <summary>Get an attribute value and parse it as an enum value.</summary>
-        /// <typeparam name="TEnum">The enum type.</typeparam>
-        /// <param name="element">The element whose attributes to read.</param>
-        /// <param name="name">The attribute name.</param>
-        private TEnum? GetAttributeAsEnum<TEnum>(HtmlNode element, string name) where TEnum : struct
-        {
-            string raw = this.GetAttribute(element, name);
-            if (raw == null)
-                return null;
-            if (!Enum.TryParse(raw, true, out TEnum value) && Enum.IsDefined(typeof(TEnum), value))
-                throw new InvalidOperationException($"Unknown {typeof(TEnum).Name} value '{raw}' when parsing compatibility list.");
-            return value;
-        }
-
-        /// <summary>Get an attribute value and parse it as a semantic version.</summary>
-        /// <param name="element">The element whose attributes to read.</param>
-        /// <param name="name">The attribute name.</param>
-        private ISemanticVersion GetAttributeAsSemanticVersion(HtmlNode element, string name)
-        {
-            string raw = this.GetAttribute(element, name);
-            return SemanticVersion.TryParse(raw, out ISemanticVersion version)
-                ? version
-                : null;
-        }
-
-        /// <summary>Get an attribute value and parse it as a nullable int.</summary>
-        /// <param name="element">The element whose attributes to read.</param>
-        /// <param name="name">The attribute name.</param>
-        private int? GetAttributeAsNullableInt(HtmlNode element, string name)
-        {
-            string raw = this.GetAttribute(element, name);
-            if (raw != null && int.TryParse(raw, out int value))
-                return value;
-            return null;
-        }
-
-        /// <summary>Get the text of an element with the given class name.</summary>
-        /// <param name="container">The metadata container.</param>
-        /// <param name="className">The field name.</param>
-        private string GetInnerHtml(HtmlNode container, string className)
-        {
-            return container.Descendants().FirstOrDefault(p => p.HasClass(className))?.InnerHtml;
-        }
-
-        /// <summary>The response model for the MediaWiki parse API.</summary>
-        [SuppressMessage("ReSharper", "ClassNeverInstantiated.Local")]
-        [SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Local")]
-        private class ResponseModel
-        {
-            /// <summary>The parse API results.</summary>
-            public ResponseParseModel Parse { get; set; }
-        }
-
-        /// <summary>The inner response model for the MediaWiki parse API.</summary>
-        [SuppressMessage("ReSharper", "ClassNeverInstantiated.Local")]
-        [SuppressMessage("ReSharper", "CollectionNeverUpdated.Local")]
-        [SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Local")]
-        private class ResponseParseModel
-        {
-            /// <summary>The parsed text.</summary>
-            public IDictionary<string, string> Text { get; set; }
-        }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiCompatibilityInfo.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiCompatibilityInfo.cs
deleted file mode 100644
index 204acd2b..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiCompatibilityInfo.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.Wiki
-{
-    /// <summary>Compatibility info for a mod.</summary>
-    public class WikiCompatibilityInfo
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The compatibility status.</summary>
-        public WikiCompatibilityStatus Status { get; set; }
-
-        /// <summary>The human-readable summary of the compatibility status or workaround, without HTML formatting.</summary>
-        public string Summary { get; set; }
-
-        /// <summary>The game or SMAPI version which broke this mod (if applicable).</summary>
-        public string BrokeIn { get; set; }
-
-        /// <summary>The version of the latest unofficial update, if applicable.</summary>
-        public ISemanticVersion UnofficialVersion { get; set; }
-
-        /// <summary>The URL to the latest unofficial update, if applicable.</summary>
-        public string UnofficialUrl { get; set; }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiCompatibilityStatus.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiCompatibilityStatus.cs
deleted file mode 100644
index a1d2dfae..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiCompatibilityStatus.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.Wiki
-{
-    /// <summary>The compatibility status for a mod.</summary>
-    public enum WikiCompatibilityStatus
-    {
-        /// <summary>The mod is compatible.</summary>
-        Ok = 0,
-
-        /// <summary>The mod is compatible if you use an optional official download.</summary>
-        Optional = 1,
-
-        /// <summary>The mod is compatible if you use an unofficial update.</summary>
-        Unofficial = 2,
-
-        /// <summary>The mod isn't compatible, but the player can fix it or there's a good alternative.</summary>
-        Workaround = 3,
-
-        /// <summary>The mod isn't compatible.</summary>
-        Broken = 4,
-
-        /// <summary>The mod is no longer maintained by the author, and an unofficial update or continuation is unlikely.</summary>
-        Abandoned = 5,
-
-        /// <summary>The mod is no longer needed and should be removed.</summary>
-        Obsolete = 6
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiModEntry.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiModEntry.cs
deleted file mode 100644
index 35d43758..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiModEntry.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.Wiki
-{
-    /// <summary>A mod entry in the wiki list.</summary>
-    public class WikiModEntry
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The mod's unique ID. If the mod has alternate/old IDs, they're listed in latest to newest order.</summary>
-        public string[] ID { get; set; }
-
-        /// <summary>The mod's display name. If the mod has multiple names, the first one is the most canonical name.</summary>
-        public string[] Name { get; set; }
-
-        /// <summary>The mod's author name.  If the author has multiple names, the first one is the most canonical name.</summary>
-        public string[] Author { get; set; }
-
-        /// <summary>The mod ID on Nexus.</summary>
-        public int? NexusID { get; set; }
-
-        /// <summary>The mod ID in the Chucklefish mod repo.</summary>
-        public int? ChucklefishID { get; set; }
-
-        /// <summary>The mod ID in the ModDrop mod repo.</summary>
-        public int? ModDropID { get; set; }
-
-        /// <summary>The GitHub repository in the form 'owner/repo'.</summary>
-        public string GitHubRepo { get; set; }
-
-        /// <summary>The URL to a non-GitHub source repo.</summary>
-        public string CustomSourceUrl { get; set; }
-
-        /// <summary>The custom mod page URL (if applicable).</summary>
-        public string CustomUrl { get; set; }
-
-        /// <summary>The name of the mod which loads this content pack, if applicable.</summary>
-        public string ContentPackFor { get; set; }
-
-        /// <summary>The mod's compatibility with the latest stable version of the game.</summary>
-        public WikiCompatibilityInfo Compatibility { get; set; }
-
-        /// <summary>The mod's compatibility with the latest beta version of the game (if any).</summary>
-        public WikiCompatibilityInfo BetaCompatibility { get; set; }
-
-        /// <summary>Whether the mod is ready for the upcoming SMAPI 3.0.</summary>
-        public WikiSmapi3Status Smapi3Status { get; set; }
-
-        /// <summary>A URL related to the <see cref="Smapi3Status"/>.</summary>
-        public string Smapi3Url { get; set; }
-
-        /// <summary>Whether a Stardew Valley or SMAPI beta which affects mod compatibility is in progress. If this is true, <see cref="BetaCompatibility"/> should be used for beta versions of SMAPI instead of <see cref="Compatibility"/>.</summary>
-        public bool HasBetaInfo => this.BetaCompatibility != null;
-
-        /// <summary>The human-readable warnings for players about this mod.</summary>
-        public string[] Warnings { get; set; }
-
-        /// <summary>The link anchor for the mod entry in the wiki compatibility list.</summary>
-        public string Anchor { get; set; }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiModList.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiModList.cs
deleted file mode 100644
index 0d614f28..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiModList.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.Wiki
-{
-    /// <summary>Metadata from the wiki's mod compatibility list.</summary>
-    public class WikiModList
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>The stable game version.</summary>
-        public string StableVersion { get; set; }
-
-        /// <summary>The beta game version (if any).</summary>
-        public string BetaVersion { get; set; }
-
-        /// <summary>The mods on the wiki.</summary>
-        public WikiModEntry[] Mods { get; set; }
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiSmapi3Status.cs b/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiSmapi3Status.cs
deleted file mode 100644
index 879cfd8a..00000000
--- a/src/StardewModdingAPI.Toolkit/Framework/Clients/Wiki/WikiSmapi3Status.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-namespace StardewModdingAPI.Toolkit.Framework.Clients.Wiki
-{
-    /// <summary>Whether a mod is ready for the upcoming SMAPI 3.0.</summary>
-    public enum WikiSmapi3Status
-    {
-        /// <summary>The mod's compatibility status is unknown.</summary>
-        Unknown = 0,
-
-        /// <summary>The mod is compatible with the upcoming SMAPI 3.0.</summary>
-        Ok = 1,
-
-        /// <summary>The mod will break in SMAPI 3.0.</summary>
-        Broken = 2,
-
-        /// <summary>The mod has a pull request submitted for SMAPI 3.0 compatibility.</summary>
-        Soon = 3
-    }
-}
diff --git a/src/StardewModdingAPI.Toolkit/Properties/AssemblyInfo.cs b/src/StardewModdingAPI.Toolkit/Properties/AssemblyInfo.cs
deleted file mode 100644
index 1bb19e8c..00000000
--- a/src/StardewModdingAPI.Toolkit/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-[assembly: AssemblyTitle("SMAPI.Toolkit")]
-[assembly: AssemblyDescription("A library which encapsulates mod-handling logic for mod managers and tools. Not intended for use by mods.")]
-[assembly: InternalsVisibleTo("StardewModdingAPI")]
-[assembly: InternalsVisibleTo("StardewModdingAPI.Web")]
diff --git a/src/StardewModdingAPI.Toolkit/StardewModdingAPI.Toolkit.csproj b/src/StardewModdingAPI.Toolkit/StardewModdingAPI.Toolkit.csproj
deleted file mode 100644
index dca55198..00000000
--- a/src/StardewModdingAPI.Toolkit/StardewModdingAPI.Toolkit.csproj
+++ /dev/null
@@ -1,27 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>net4.5;netstandard2.0</TargetFrameworks>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <OutputPath>..\..\bin\$(Configuration)\SMAPI.Toolkit</OutputPath>
-    <DocumentationFile>..\..\bin\$(Configuration)\SMAPI.Toolkit\$(TargetFramework)\StardewModdingAPI.Toolkit.xml</DocumentationFile>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Include="..\..\build\GlobalAssemblyInfo.cs" Link="Properties\GlobalAssemblyInfo.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="HtmlAgilityPack" Version="1.8.11" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
-    <PackageReference Include="Pathoschild.Http.FluentClient" Version="3.2.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\StardewModdingAPI.Toolkit.CoreInterfaces\StardewModdingAPI.Toolkit.CoreInterfaces.csproj" />
-  </ItemGroup>
-
-  <Import Project="..\..\build\common.targets" />
-
-</Project>