*misc

242 files changed, 30652 insertions, 0 deletions

diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ArrayHelperTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ArrayHelperTests.cs
new file mode 100644
index 0000000..45c26fe
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ArrayHelperTests.cs
@@ -0,0 +1,79 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests
+{
+	
+    public class ArrayHelperTests
+    {
+		[Fact]
+        public void Contains_HasValue_ReturnsTrue()
+		{
+			var array = new char[] { 'a' };
+
+			var contains = ArrayHelper.Contains(array, 'a');
+
+			Assert.True(contains);
+		}
+
+		[Fact]
+		public void Contains_DoesNotHaveValue_ReturnsFalse()
+		{
+			var array = new char[] { 'a' };
+
+			var contains = ArrayHelper.Contains(array, 'b');
+
+			Assert.False(contains);
+		}
+
+		[Fact]
+		public void Trim_FullBuffer_TrimsChars()
+		{
+			var buffer = " a ".ToCharArray();
+			var trimChars = new char[] { ' ' };
+			var start = 0;
+			var length = buffer.Length;
+
+			ArrayHelper.Trim(buffer, ref start, ref length, trimChars);
+
+			Assert.Equal(1, start);
+			Assert.Equal(1, length);
+		}
+
+		[Fact]
+		public void Trim_MidBuffer_TrimsChars()
+		{
+			var buffer = "a b c".ToCharArray();
+			var trimChars = new char[] { ' ' };
+			var start = 1;
+			var length = 3;
+
+			ArrayHelper.Trim(buffer, ref start, ref length, trimChars);
+
+			Assert.Equal(2, start);
+			Assert.Equal(1, length);
+		}
+
+		[Fact]
+		public void Trim_AllWhitespace_EmptyString()
+		{
+			var buffer = new string(' ', 100).ToCharArray();
+			var trimChars = new char[] { ' ' };
+			var start = 0;
+			var length = buffer.Length;
+
+			ArrayHelper.Trim(buffer, ref start, ref length, trimChars);
+
+			Assert.Equal(100, start);
+			Assert.Equal(0, length);
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Async/ReadingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Async/ReadingTests.cs
new file mode 100644
index 0000000..fdd7af8
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Async/ReadingTests.cs
@@ -0,0 +1,103 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using System.Linq;
+
+namespace CsvHelper.Tests.Async
+{
+	
+	public class ReadingTests
+	{
+		[Fact]
+		public async Task ReadingTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+				null
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = new List<Simple>();
+				await csv.ReadAsync();
+				csv.ReadHeader();
+				while (await csv.ReadAsync())
+				{
+					records.Add(csv.GetRecord<Simple>());
+				}
+
+				Assert.Equal(2, records.Count);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+
+				record = records[1];
+				Assert.Equal(2, record.Id);
+				Assert.Equal("two", record.Name);
+			}
+		}
+
+#if NETCOREAPP
+		[Fact]
+		public async Task GetRecordsTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+				null
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecordsAsync<Simple>().GetAsyncEnumerator();
+				await records.MoveNextAsync();
+
+				Assert.Equal(1, records.Current.Id);
+				Assert.Equal("one", records.Current.Name);
+
+				await records.MoveNextAsync();
+
+				Assert.Equal(2, records.Current.Id);
+				Assert.Equal("two", records.Current.Name);
+			}
+		}
+
+		[Fact]
+		public async Task GetRecordsTestCanceled()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+				null
+			};
+			using (var source = new CancellationTokenSource())
+			using (var csv = new CsvReader(parser))
+			{
+				source.Cancel();
+				var records = csv.GetRecordsAsync<Simple>(source.Token).GetAsyncEnumerator();
+				await Assert.ThrowsAsync<OperationCanceledException>(async () => await records.MoveNextAsync());
+			}
+		}
+#endif
+
+		private class Simple
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Async/WritingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Async/WritingTests.cs
new file mode 100644
index 0000000..95fe623
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Async/WritingTests.cs
@@ -0,0 +1,119 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Async
+{
+	
+	public class WritingTests
+	{
+		[Fact]
+		public async Task WritingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var records = new List<Simple>
+				{
+					new Simple { Id = 1, Name = "one" },
+					new Simple { Id = 2, Name = "two" },
+				};
+				csv.WriteHeader<Simple>();
+				await csv.NextRecordAsync();
+				foreach (var record in records)
+				{
+					csv.WriteRecord(record);
+					await csv.NextRecordAsync();
+				}
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,one");
+				expected.AppendLine("2,two");
+
+				Assert.Equal(expected.ToString(), reader.ReadToEnd());
+			}
+		}
+
+		[Fact]
+		public async Task WriteRecordsTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var records = new List<Simple>
+				{
+					new Simple { Id = 1, Name = "one" },
+					new Simple { Id = 2, Name = "two" },
+				};
+				await csv.WriteRecordsAsync(records);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,one");
+				expected.AppendLine("2,two");
+
+				Assert.Equal(expected.ToString(), reader.ReadToEnd());
+			}
+		}
+
+		[Fact]
+		public async Task WriteRecordsTestCanceled()
+		{
+			using (var source = new CancellationTokenSource())
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var records = new List<Simple>
+				{
+					new Simple { Id = 1, Name = "one" },
+					new Simple { Id = 2, Name = "two" },
+					new Simple { Id = 3, Name = "three" },
+				};
+				source.Cancel();
+
+				try
+				{
+					await csv.WriteRecordsAsync(records, source.Token);
+				}
+				catch (WriterException ex)
+				{
+					if (ex.InnerException is OperationCanceledException || ex.InnerException is TaskCanceledException)
+					{
+						return;
+					}
+				}
+
+				throw new XUnitException("Did not throw exception");
+			}
+		}
+
+		private class Simple
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/AutoMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/AutoMappingTests.cs
new file mode 100644
index 0000000..6e9cd89
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/AutoMappingTests.cs
@@ -0,0 +1,394 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.AutoMapping
+{	
+	public class AutoMappingTests
+	{
+		public AutoMappingTests()
+		{
+			Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
+		}
+
+		[Fact]
+		public void ReaderSimpleTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var list = csv.GetRecords<Simple>().ToList();
+
+				Assert.NotNull(list);
+				Assert.Equal(2, list.Count);
+				var row = list[0];
+				Assert.Equal(1, row.Id);
+				Assert.Equal("one", row.Name);
+				row = list[1];
+				Assert.Equal(2, row.Id);
+				Assert.Equal("two", row.Name);
+			}
+		}
+
+		[Fact]
+		public void ReaderFloatingCultureDeTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.GetCultureInfo("de-DE")))
+			{
+				writer.WriteLine("Single;Double;Decimal");
+				writer.WriteLine("1,1;+0000002,20;3,30000");
+				writer.WriteLine("-0,1;-0,2;-,3");
+				writer.Flush();
+				stream.Position = 0;
+
+				var list = csv.GetRecords<Numbers>().ToList();
+
+				Assert.NotNull(list);
+				Assert.Equal(2, list.Count);
+				var row = list[0];
+				Assert.Equal(1.1f, row.Single, 4);
+				Assert.Equal(2.2d, row.Double, 4);
+				Assert.Equal(3.3m, row.Decimal);
+
+				row = list[1];
+				Assert.Equal(-0.1f, row.Single, 4);
+				Assert.Equal(-0.2d, row.Double, 4);
+				Assert.Equal(-0.3m, row.Decimal);
+			}
+		}
+
+		[Fact]
+		public void ReaderReferenceTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("AId,BId");
+				writer.WriteLine("1,2");
+				writer.Flush();
+				stream.Position = 0;
+
+				var list = csv.GetRecords<A>().ToList();
+
+				Assert.NotNull(list);
+				Assert.Single(list);
+				var row = list[0];
+				Assert.Equal(1, row.AId);
+				Assert.NotNull(row.B);
+				Assert.Equal(2, row.B.BId);
+			}
+		}
+
+		[Fact]
+		public void ReaderReferenceHasNoDefaultConstructorTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => args.Header.ToLower(),
+			};
+			var s = new StringBuilder();
+			s.AppendLine("Id,Name");
+			s.AppendLine("1,one");
+			using (var csv = new CsvReader(new StringReader(s.ToString()), config))
+			{
+				var records = csv.GetRecords<SimpleReferenceHasNoDefaultConstructor>().ToList();
+				var row = records[0];
+				Assert.Equal(1, row.Id);
+				Assert.Equal("one", row.Ref.Name);
+			}
+		}
+
+		[Fact]
+		public void ReaderHasNoDefaultConstructorReferenceHasNoDefaultConstructorTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => args.Header.ToLower(),
+			};
+			var s = new StringBuilder();
+			s.AppendLine("Id,Name");
+			s.AppendLine("1,one");
+			using (var csv = new CsvReader(new StringReader(s.ToString()), config))
+			{
+				var records = csv.GetRecords<SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor>().ToList();
+				var row = records[0];
+				Assert.Equal(1, row.Id);
+				Assert.Equal("one", row.Ref.Name);
+			}
+		}
+
+		[Fact]
+		public void WriterSimpleTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<Simple>
+				{
+					new Simple { Id = 1, Name = "one" }
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,one");
+
+				Assert.Equal(expected.ToString(), data);
+			}
+		}
+
+		[Fact]
+		public void WriterReferenceTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<A>
+				{
+					new A
+					{
+						AId = 1,
+						B = new B
+						{
+							BId = 2
+						}
+					}
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("AId,BId");
+				expected.AppendLine("1,2");
+
+				Assert.Equal(expected.ToString(), data);
+			}
+		}
+
+		[Fact]
+		public void WriterReferenceHasNoDefaultConstructorTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<SimpleReferenceHasNoDefaultConstructor>
+				{
+					new SimpleReferenceHasNoDefaultConstructor
+					{
+						Id = 1,
+						Ref = new NoDefaultConstructor( "one" )
+					}
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,one");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriterHasNoDefaultConstructorReferenceHasNoDefaultConstructorTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor>
+				{
+					new SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor(1, new NoDefaultConstructor("one"))
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,one");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void AutoMapEnumerableTest()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+
+			Assert.Throws<ConfigurationException>(() => context.AutoMap(typeof(List<string>)));
+		}
+
+		[Fact]
+		public void AutoMapWithExistingMapTest()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var existingMap = new SimpleMap();
+			context.Maps.Add(existingMap);
+			var data = new
+			{
+				Simple = new Simple
+				{
+					Id = 1,
+					Name = "one"
+				}
+			};
+			var map = context.AutoMap(data.GetType());
+
+			Assert.NotNull(map);
+			Assert.Empty(map.MemberMaps);
+			Assert.Single(map.ReferenceMaps);
+
+			// Since Simple is a reference on the anonymous object, the type won't
+			// be re-used. Types which are created from automapping aren't added
+			// to the list of registered maps either.
+			Assert.IsNotType<SimpleMap>(map.ReferenceMaps[0].Data.Mapping);
+		}
+
+		[Fact]
+		public void AutoMapWithNestedHeaders()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ReferenceHeaderPrefix = args => $"{args.MemberName}."
+			};
+			var context = new CsvContext(config);
+			var map = context.AutoMap<Nested>();
+			Assert.Equal("Simple1.Id", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]);
+			Assert.Equal("Simple1.Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[1].Data.Names[0]);
+			Assert.Equal("Simple2.Id", map.ReferenceMaps[1].Data.Mapping.MemberMaps[0].Data.Names[0]);
+			Assert.Equal("Simple2.Name", map.ReferenceMaps[1].Data.Mapping.MemberMaps[1].Data.Names[0]);
+		}
+
+		[Fact]
+		public void AutoMapWithDefaultConstructor()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			ClassMap map = context.AutoMap<SimpleReferenceHasNoDefaultConstructor>();
+
+			Assert.Equal("Id", map.MemberMaps[0].Data.Names[0]);
+			Assert.Equal("Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]);
+			Assert.Equal("name", map.ReferenceMaps[0].Data.Mapping.ParameterMaps[0].Data.Names[0]);
+		}
+
+		[Fact]
+		public void AutoMapWithNoDefaultConstructor()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor>();
+
+			Assert.Equal("Id", map.MemberMaps[0].Data.Names[0]);
+			Assert.Equal("id", map.ParameterMaps[0].Data.Names[0]);
+			Assert.Equal("name", map.ParameterMaps[1].ConstructorTypeMap.ParameterMaps[0].Data.Names[0]);
+			Assert.Equal("Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]);
+			Assert.Equal("name", map.ReferenceMaps[0].Data.Mapping.ParameterMaps[0].Data.Names[0]);
+		}
+
+		private class Nested
+		{
+			public Simple Simple1 { get; set; }
+
+			public Simple Simple2 { get; set; }
+		}
+
+		private class Simple
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class SimpleMap : ClassMap<Simple>
+		{
+			public SimpleMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+			}
+		}
+
+		private class Numbers
+		{
+			public float Single { get; set; }
+			public double Double { get; set; }
+			public decimal Decimal { get; set; }
+		}
+
+		private class A
+		{
+			public int AId { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public int BId { get; set; }
+		}
+
+		private class SimpleReferenceHasNoDefaultConstructor
+		{
+			public int Id { get; set; }
+
+			public NoDefaultConstructor Ref { get; set; }
+		}
+
+		private class SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor
+		{
+			public int Id { get; set; }
+
+			public NoDefaultConstructor Ref { get; set; }
+
+			public SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor(int id, NoDefaultConstructor ref_)
+			{
+				Id = id;
+				Ref = ref_;
+			}
+		}
+
+		private class NoDefaultConstructor
+		{
+			public string Name { get; set; }
+
+			public NoDefaultConstructor(string name)
+			{
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/BaseClassTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/BaseClassTests.cs
new file mode 100644
index 0000000..52118f3
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/BaseClassTests.cs
@@ -0,0 +1,52 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace CsvHelper.Tests.AutoMapping
+{
+	
+	public class BaseClassTests
+	{
+		[Fact]
+		public void EnsureChildNotWrittenWhenListIsParent()
+		{
+			var record = new Child
+			{
+				ChildProp = "child",
+				ParentProp = "parent"
+			};
+			Parent[] records = { record };
+
+			using( var stream = new MemoryStream() )
+			using( var writer = new StreamWriter( stream ) )
+			using( var reader = new StreamReader( stream ) )
+			using( var csv = new CsvWriter(writer, CultureInfo.InvariantCulture) )
+			{
+				csv.WriteRecords( records );
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine( "ParentProp" );
+				expected.AppendLine( "parent" );
+
+				Assert.Equal( expected.ToString(), reader.ReadToEnd() );
+			}
+		}
+
+		private class Parent
+		{
+			public string ParentProp { get; set; }
+		}
+
+		private class Child : Parent
+		{
+			public string ChildProp { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/CircularReferenceTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/CircularReferenceTests.cs
new file mode 100644
index 0000000..0ae94e7
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/CircularReferenceTests.cs
@@ -0,0 +1,98 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System.Globalization;
+
+namespace CsvHelper.Tests.AutoMapping
+{
+
+	public class CircularReferenceTests
+	{
+		[Fact]
+		public void SelfCircularDependencyTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<SelfCircularA>();
+		}
+
+		[Fact]
+		public void CircularDependencyTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<ACircular>();
+			Assert.NotNull(map);
+			Assert.Single(map.MemberMaps);
+			Assert.Single(map.ReferenceMaps);
+			Assert.Single(map.ReferenceMaps[0].Data.Mapping.MemberMaps);
+			Assert.Empty(map.ReferenceMaps[0].Data.Mapping.ReferenceMaps);
+		}
+
+		[Fact]
+		public void CircularDependencyWithMultiplePropertiesTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<A>();
+			Assert.Single(map.MemberMaps);
+			Assert.Equal(3, map.ReferenceMaps.Count);
+		}
+
+		private class SelfCircularA
+		{
+			public SelfCircularB Circular { get; set; }
+		}
+
+		private class SelfCircularB
+		{
+			public SelfCircularB Self { get; set; }
+
+			public SelfCircularC C { get; set; }
+		}
+
+		private class SelfCircularC
+		{
+			public string Id { get; set; }
+		}
+
+		private class ACircular
+		{
+			public string Id { get; set; }
+
+			public BCircular B { get; set; }
+		}
+
+		private class BCircular
+		{
+			public string Id { get; set; }
+
+			public ACircular A { get; set; }
+		}
+
+		private class A
+		{
+			public string Id { get; set; }
+
+			public B B1 { get; set; }
+
+			public B B2 { get; set; }
+
+			public B B3 { get; set; }
+		}
+
+		private class B
+		{
+			public string Id { get; set; }
+
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string Id { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/ContextTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/ContextTests.cs
new file mode 100644
index 0000000..2e41972
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/ContextTests.cs
@@ -0,0 +1,36 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.AutoMapping
+{
+	
+    public class ContextTests
+    {
+		[Fact]
+        public void AutoMap_UsesContext()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("Bar");
+
+			var map = context.AutoMap<Foo>();
+
+			Assert.Contains("Bar", map.MemberMaps.Find<Foo>(x => x.Name).Data.TypeConverterOptions.NullValues);
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/IgnoreReferencesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/IgnoreReferencesTests.cs
new file mode 100644
index 0000000..bc9e8b2
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/IgnoreReferencesTests.cs
@@ -0,0 +1,62 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.AutoMapping
+{
+	
+	public class IgnoreReferencesTests
+	{
+		[Fact]
+		public void IgnoreReferncesWritingTest()
+		{
+			var records = new List<Foo>
+			{
+				new Foo
+				{
+					Id = 1,
+					Bar = new Bar { Name = "one" }
+				}
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreReferences = true,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(records);
+				writer.Flush();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id");
+				expected.AppendLine("1");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+
+			public Bar Bar { get; set; }
+		}
+
+		private class Bar
+		{
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/MappingTypeOfTypeTest.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/MappingTypeOfTypeTest.cs
new file mode 100644
index 0000000..f244505
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/MappingTypeOfTypeTest.cs
@@ -0,0 +1,41 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CsvHelper.Tests.AutoMapping
+{
+	
+	public class MappingTypeOfTypeTest
+	{
+		[Fact]
+		public void ClassWithPropertyOfTypeTypeShouldNotCauseStackOverflowExceptionTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id" },
+				{ "1" },
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<EquipmentDataPoint>().ToList();
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+			}
+		}
+
+		public class EquipmentDataPoint
+		{
+			public int Id { get; set; }
+
+			[CsvHelper.Configuration.Attributes.Ignore]
+			public Type ValueType { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/StructTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/StructTests.cs
new file mode 100644
index 0000000..8ad3da9
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/StructTests.cs
@@ -0,0 +1,76 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.AutoMapping
+{
+	
+	public class StructTests
+	{
+		[Fact]
+		public void StructTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<B>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void StructPropertyTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ReferenceHeaderPrefix = args => $"{args.MemberName}.",
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Simple1.Id,Simple1.Name,Simple2.Id,Simple2.Name,Title");
+				writer.WriteLine("1,one,2,two,Works!");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<A>().ToList();
+
+				Assert.Equal(1, records[0].Simple1.Id);
+				Assert.Equal("one", records[0].Simple1.Name);
+				Assert.Equal(2, records[0].Simple2.Id);
+				Assert.Equal("two", records[0].Simple2.Name);
+				Assert.Equal("Works!", records[0].Title);
+			}
+		}
+
+		public class A
+		{
+			public B Simple1 { get; set; }
+			public string Title { get; set; }
+			public B Simple2 { get; set; }
+		}
+
+		public struct B
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ClassMapOrderingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ClassMapOrderingTests.cs
new file mode 100644
index 0000000..c0c4382
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ClassMapOrderingTests.cs
@@ -0,0 +1,110 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class ClassMapOrderingTests
+	{
+		[Fact]
+		public void OrderingTest()
+		{
+			var list = new List<ContainerClass>
+			{
+				new ContainerClass
+				{
+					Contents = new ThirdClass
+					{
+						Third = 3,
+						Second = new SecondClass
+						{
+							Second = 2,
+						},
+						First = new FirstClass
+						{
+							First = 1,
+						},
+					}
+				},
+			};
+
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<ContainerClassMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.Equal("First,Second,Third", reader.ReadLine());
+			}
+		}
+
+		private class ContainerClass
+		{
+			public ThirdClass Contents { get; set; }
+		}
+
+		private class ThirdClass
+		{
+			public int Third { get; set; }
+
+			public SecondClass Second { get; set; }
+
+			public FirstClass First { get; set; }
+		}
+
+		private sealed class ContainerClassMap : ClassMap<ContainerClass>
+		{
+			public ContainerClassMap()
+			{
+				References<ThirdClassMap>(m => m.Contents);
+			}
+		}
+
+		private sealed class ThirdClassMap : ClassMap<ThirdClass>
+		{
+			public ThirdClassMap()
+			{
+				References<FirstClassMap>(m => m.First);
+				References<SecondClassMap>(m => m.Second);
+				Map(m => m.Third);
+			}
+		}
+
+		private class SecondClass
+		{
+			public int Second { get; set; }
+		}
+
+		private sealed class SecondClassMap : ClassMap<SecondClass>
+		{
+			public SecondClassMap()
+			{
+				Map(m => m.Second);
+			}
+		}
+
+		private class FirstClass
+		{
+			public int First { get; set; }
+		}
+
+		private sealed class FirstClassMap : ClassMap<FirstClass>
+		{
+			public FirstClassMap()
+			{
+				Map(m => m.First);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Configuration/ClassMapBuilderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Configuration/ClassMapBuilderTests.cs
new file mode 100644
index 0000000..f1921ee
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Configuration/ClassMapBuilderTests.cs
@@ -0,0 +1,335 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.Configuration
+{
+	
+	public class ClassMapBuilderTests
+	{
+		private static readonly Factory csvFactory = new Factory();
+		private static ConvertFromString<FakeInnerClass> ConvertExpression => args => new FakeInnerClass { E = args.Row.GetField(4) };
+		private static readonly ClassMap<FakeClass> map = csvFactory.CreateClassMapBuilder<FakeClass>()
+			/*
+			.Map( m => m.A ).Constant( "a" )
+			.Map( m => m.A ).ConvertUsing( row => row.GetField( 0 ) )
+			.Map( m => m.A ).Default( "a" )
+			.Map( m => m.A ).Index( 0 )
+			.Map( m => m.A ).Index( 0 ).Validate( field => true )
+			.Map( m => m.A ).Index( 0 ).Default( "a" )
+			.Map( m => m.A ).Index( 0 ).Default( "a" ).Validate( field => true )
+			.Map( m => m.A ).Index( 0 ).Name( "a" )
+			.Map( m => m.A ).Index( 0 ).Name( "a" ).Validate( field => true )
+			.Map( m => m.A ).Index( 0 ).TypeConverter<StringConverter>()
+			.Map( m => m.A ).Index( 0 ).TypeConverter<StringConverter>().Validate( field => true )
+			.Map( m => m.A ).Name( "a" )
+			.Map( m => m.A ).Name( "a" ).Validate( field => true )
+			.Map( m => m.A ).Name( "a" ).Default( "a" )
+			.Map( m => m.A ).Name( "a" ).Default( "a" ).Validate( field => true )
+			.Map( m => m.A ).Name( "a" ).NameIndex( 0 )
+			.Map( m => m.A ).Name( "a" ).NameIndex( 0 ).Validate( field => true )
+			.Map( m => m.A ).Name( "a" ).NameIndex( 0 ).Default( "a" )
+			.Map( m => m.A ).Name( "a" ).NameIndex( 0 ).Default( "a" ).Validate( field => true )
+			.Map( m => m.A ).Name( "a" ).NameIndex( 0 ).TypeConverter<StringConverter>()
+			.Map( m => m.A ).Name( "a" ).NameIndex( 0 ).TypeConverter<StringConverter>().Validate( field => true )
+			.Map( m => m.A ).Name( "a" ).TypeConverter<StringConverter>()
+			.Map( m => m.A ).Name( "a" ).TypeConverter<StringConverter>().Validate( field => true )
+			.Map( m => m.A ).TypeConverter<StringConverter>()
+			.Map( m => m.A ).TypeConverter<StringConverter>().Validate( field => true )
+			.Map( m => m.A ).TypeConverter<StringConverter>().Default( "a" )
+			.Map( m => m.A ).TypeConverter<StringConverter>().Default( "a" ).Validate( field => true )
+			*/
+
+			.Map(m => m.A).Name("A1").NameIndex(2).Default("WEW")
+			.Map(m => m.B).Name("B2").Default(2)
+			.Map(m => m.C).Index(2).TypeConverter(new DateTimeConverter())
+			.Map(m => m.D).Name("D4").TypeConverter<DoubleConverter>().Default(4d)
+			.Map(m => m.E).ConvertUsing(ConvertExpression)
+			.Map(m => m.Optional).Optional()
+			.Build();
+
+		[Fact]
+		public void ClassMapBuilderAddsPropertyMapsCorrectly()
+		{
+			Assert.Equal(6, map.MemberMaps.Count);//IMappable
+		}
+
+		[Fact]
+		public void ClassMapBuilderAddsOptionalCorrectly()
+		{
+			Assert.True(map.MemberMaps[5].Data.IsOptional);
+		}
+
+		[Fact]
+		public void ClassMapBuilderAddsTypeConvertersCorrectly()
+		{
+			Assert.Equal(typeof(DateTimeConverter), map.MemberMaps[2].Data.TypeConverter.GetType());//2
+			Assert.Equal(typeof(DoubleConverter), map.MemberMaps[3].Data.TypeConverter.GetType());//2
+		}
+
+		[Fact]
+		public void ClassMapBuilderAddsIndexesCorrectly()
+		{
+			Assert.Equal(2, map.MemberMaps[2].Data.Index); //3
+		}
+
+		[Fact]
+		public void ClassMapBuilderAddsNamesCorrectly()
+		{
+			Assert.Equal("D4", map.MemberMaps[3].Data.Names.Single()); //4
+		}
+
+		[Fact]
+		public void ClassMapBuilderAddsNameIndexesCorrectly()
+		{
+			Assert.Equal(2, map.MemberMaps[0].Data.NameIndex); //5
+		}
+
+		//this one is kind of hacky, but i'm not sure how else to test it more robustly since the function gets converted to an expression inside the CsvClassMap
+		[Fact]
+		public void ClassMapBuilderAddsConvertUsingFunctionCorrectly()
+		{
+			var fakeRow = new BuilderRowFake();
+			var args = new ConvertFromStringArgs(fakeRow);
+			Assert.Equal(ConvertExpression(args).E, (map.MemberMaps[4].Data.ReadingConvertExpression as Expression<ConvertFromString<FakeInnerClass>>).Compile()(args).E); //6
+		}
+
+		[Fact]
+		public void ClassMapBuilderAddsDefaultsCorrectly()
+		{
+			Assert.Equal("WEW", map.MemberMaps[0].Data.Default);//7
+			Assert.Equal(4d, map.MemberMaps[3].Data.Default);//7
+		}
+
+		private class BuilderRowFake : IReaderRow
+		{
+			public IReaderConfiguration Configuration { get; }
+			public string[] FieldHeaders { get; }
+			public string[] CurrentRecord { get; }
+			public int Row { get; }
+
+			public CsvContext Context => throw new NotImplementedException();
+
+			public int CurrentIndex => throw new NotImplementedException();
+
+			public string[] HeaderRecord => throw new NotImplementedException();
+
+			public IParser Parser => throw new NotImplementedException();
+
+			public int ColumnCount => throw new NotImplementedException();
+
+			string IReaderRow.this[int index] => throw new NotImplementedException();
+
+			string IReaderRow.this[string name] => throw new NotImplementedException();
+
+			string IReaderRow.this[string name, int index] => throw new NotImplementedException();
+
+			public string GetField(int index)
+			{
+				return index.ToString();
+			}
+
+			public string GetField(string name)
+			{
+				throw new NotImplementedException();
+			}
+
+			public string GetField(string name, int index)
+			{
+				throw new NotImplementedException();
+			}
+
+			public object GetField(Type type, int index)
+			{
+				throw new NotImplementedException();
+			}
+
+			public object GetField(Type type, string name)
+			{
+				throw new NotImplementedException();
+			}
+
+			public object GetField(Type type, string name, int index)
+			{
+				throw new NotImplementedException();
+			}
+
+			public object GetField(Type type, int index, ITypeConverter converter)
+			{
+				throw new NotImplementedException();
+			}
+
+			public object GetField(Type type, string name, ITypeConverter converter)
+			{
+				throw new NotImplementedException();
+			}
+
+			public object GetField(Type type, string name, int index, ITypeConverter converter)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T>(int index)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T>(string name)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T>(string name, int index)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T>(int index, ITypeConverter converter)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T>(string name, ITypeConverter converter)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T>(string name, int index, ITypeConverter converter)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T, TConverter>(int index) where TConverter : ITypeConverter
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T, TConverter>(string name) where TConverter : ITypeConverter
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetField<T, TConverter>(string name, int index) where TConverter : ITypeConverter
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField(Type type, int index, out object field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField(Type type, string name, out object field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField(Type type, string name, int index, out object field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField(Type type, int index, ITypeConverter converter, out object field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField(Type type, string name, ITypeConverter converter, out object field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField(Type type, string name, int index, ITypeConverter converter, out object field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T>(int index, out T field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T>(string name, out T field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T>(string name, int index, out T field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T>(int index, ITypeConverter converter, out T field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T>(string name, ITypeConverter converter, out T field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T>(string name, int index, ITypeConverter converter, out T field)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T, TConverter>(int index, out T field) where TConverter : ITypeConverter
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T, TConverter>(string name, out T field) where TConverter : ITypeConverter
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool TryGetField<T, TConverter>(string name, int index, out T field) where TConverter : ITypeConverter
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool IsRecordEmpty()
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetRecord<T>()
+			{
+				throw new NotImplementedException();
+			}
+
+			public object GetRecord(Type type)
+			{
+				throw new NotImplementedException();
+			}
+
+			public T GetRecord<T>(T anonymousTypeDefinition)
+			{
+				throw new NotImplementedException();
+			}
+		}
+
+		private class FakeClass
+		{
+			public string A { get; set; }
+			public int B { get; set; }
+			public DateTime C { get; set; }
+			public double D { get; set; }
+			public FakeInnerClass E { get; set; }
+			public string Optional { get; set; }
+		}
+
+		private class FakeInnerClass
+		{
+			public string E { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Configuration/CsvClassMapCollectionTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Configuration/CsvClassMapCollectionTests.cs
new file mode 100644
index 0000000..d93b22c
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Configuration/CsvClassMapCollectionTests.cs
@@ -0,0 +1,70 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.Collections;
+using System;
+
+namespace CsvHelper.Tests.Configuration
+{
+	
+	public class CsvClassMapCollectionTests
+	{
+		[Fact]
+		public void GetChildMapWhenParentIsMappedBeforeIt()
+		{
+			var parentMap = new ParentMap();
+			var childMap = new ChildMap();
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var c = new ClassMapCollection(context);
+			c.Add(parentMap);
+			c.Add(childMap);
+
+			var map = c[typeof(Child)];
+			Assert.Equal(childMap, map);
+		}
+
+		[Fact]		
+		public void Add_Enumerable_HasConvertSet_DoesNotAssignTypeConverter()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var collection = new ClassMapCollection(context);
+
+			var map = new EnumerablePropertyClassMap();
+			collection.Add(map);
+			Assert.Null(map.MemberMaps.Find<EnumerablePropertyClass>(m => m.Enumerable).Data.TypeConverter);
+		}
+
+		private class Parent { }
+
+		private class Child : Parent { }
+
+		private sealed class ParentMap : ClassMap<Parent> { }
+
+		private sealed class ChildMap : ClassMap<Child> { }
+
+		private class EnumerablePropertyClass
+		{
+			public Enumerable Enumerable { get; set; }
+		}
+
+		private class EnumerablePropertyClassMap : ClassMap<EnumerablePropertyClass>
+		{
+			public EnumerablePropertyClassMap()
+			{
+				Map(m => m.Enumerable).Convert(_ => new Enumerable());
+			}
+		}
+
+		private class Enumerable : IEnumerable
+		{
+			public IEnumerator GetEnumerator()
+			{
+				throw new NotSupportedException();
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvClassMappingAutoMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvClassMappingAutoMapTests.cs
new file mode 100644
index 0000000..610a288
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvClassMappingAutoMapTests.cs
@@ -0,0 +1,61 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using CsvHelper.Configuration;
+using System.Globalization;
+
+namespace CsvHelper.Tests
+{
+
+	public class CsvClassMappingAutoMapTests
+	{
+		[Fact]
+		public void Test()
+		{
+			var aMap = new AMap();
+
+			Assert.Equal(3, aMap.MemberMaps.Count);
+			Assert.Equal(0, aMap.MemberMaps[0].Data.Index);
+			Assert.Equal(1, aMap.MemberMaps[1].Data.Index);
+			Assert.Equal(2, aMap.MemberMaps[2].Data.Index);
+			Assert.True(aMap.MemberMaps[2].Data.Ignore);
+
+			Assert.Single(aMap.ReferenceMaps);
+		}
+
+		private class A
+		{
+			public int One { get; set; }
+
+			public int Two { get; set; }
+
+			public int Three { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public int Four { get; set; }
+
+			public int Five { get; set; }
+
+			public int Six { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				AutoMap(CultureInfo.InvariantCulture);
+				Map(m => m.Three).Ignore();
+			}
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvConfigurationTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvConfigurationTests.cs
new file mode 100644
index 0000000..26294fa
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvConfigurationTests.cs
@@ -0,0 +1,158 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvConfigurationTests
+	{
+		[Fact]
+		public void EnsureReaderAndParserConfigIsAreSameTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			{
+				var csvReader = new CsvReader(reader, CultureInfo.InvariantCulture);
+
+				Assert.Same(csvReader.Configuration, csvReader.Parser.Configuration);
+
+				var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+				var parser = new CsvParser(reader, config);
+				csvReader = new CsvReader(parser);
+
+				Assert.Same(csvReader.Configuration, csvReader.Parser.Configuration);
+			}
+		}
+
+		[Fact]
+		public void AddingMappingsWithGenericMethod1Test()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			context.RegisterClassMap<TestClassMappings>();
+
+			Assert.Equal(2, context.Maps[typeof(TestClass)].MemberMaps.Count);
+		}
+
+		[Fact]
+		public void AddingMappingsWithGenericMethod2Test()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			context.RegisterClassMap<TestClassMappings>();
+
+			Assert.Equal(2, context.Maps[typeof(TestClass)].MemberMaps.Count);
+		}
+
+		[Fact]
+		public void AddingMappingsWithNonGenericMethodTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			context.RegisterClassMap(typeof(TestClassMappings));
+
+			Assert.Equal(2, context.Maps[typeof(TestClass)].MemberMaps.Count);
+		}
+
+		[Fact]
+		public void AddingMappingsWithInstanceMethodTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			context.RegisterClassMap(new TestClassMappings());
+
+			Assert.Equal(2, context.Maps[typeof(TestClass)].MemberMaps.Count);
+		}
+
+		[Fact]
+		public void RegisterClassMapGenericTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+
+			Assert.Null(context.Maps[typeof(TestClass)]);
+			context.RegisterClassMap<TestClassMappings>();
+			Assert.NotNull(context.Maps[typeof(TestClass)]);
+		}
+
+		[Fact]
+		public void RegisterClassMapNonGenericTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+
+			Assert.Null(context.Maps[typeof(TestClass)]);
+			context.RegisterClassMap(typeof(TestClassMappings));
+			Assert.NotNull(context.Maps[typeof(TestClass)]);
+		}
+
+		[Fact]
+		public void RegisterClassInstanceTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+
+			Assert.Null(context.Maps[typeof(TestClass)]);
+			context.RegisterClassMap(new TestClassMappings());
+			Assert.NotNull(context.Maps[typeof(TestClass)]);
+		}
+
+		[Fact]
+		public void UnregisterClassMapGenericTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+
+			Assert.Null(context.Maps[typeof(TestClass)]);
+			context.RegisterClassMap<TestClassMappings>();
+			Assert.NotNull(context.Maps[typeof(TestClass)]);
+
+			context.UnregisterClassMap<TestClassMappings>();
+			Assert.Null(context.Maps[typeof(TestClass)]);
+		}
+
+		[Fact]
+		public void UnregisterClassNonMapGenericTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+
+			Assert.Null(context.Maps[typeof(TestClass)]);
+			context.RegisterClassMap(typeof(TestClassMappings));
+			Assert.NotNull(context.Maps[typeof(TestClass)]);
+
+			context.UnregisterClassMap(typeof(TestClassMappings));
+			Assert.Null(context.Maps[typeof(TestClass)]);
+		}
+
+		[Fact]
+		public void AddingMappingsWithNonGenericMethodThrowsWhenNotACsvClassMap()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+
+			Assert.Throws<ArgumentException>(() => context.RegisterClassMap(typeof(TestClass)));
+		}
+
+		private class TestClass
+		{
+			public string StringColumn { get; set; }
+			public int IntColumn { get; set; }
+		}
+
+		private class TestClassMappings : ClassMap<TestClass>
+		{
+			public TestClassMappings()
+			{
+				Map(c => c.StringColumn);
+				Map(c => c.IntColumn);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.csproj b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.csproj
new file mode 100644
index 0000000..345fbd3
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.csproj
@@ -0,0 +1,63 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<!--<TargetFrameworks>net6.0;net5.0;netcoreapp3.1;netcoreapp2.1;net47;net45</TargetFrameworks>-->
+		<TargetFrameworks>net6.0</TargetFrameworks>
+		<LangVersion>preview</LangVersion>
+		<SignAssembly>True</SignAssembly>
+		<AssemblyOriginatorKeyFile>CsvHelper.snk</AssemblyOriginatorKeyFile>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <None Remove="*.ncrunchproject" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Castle.Core" Version="4.4.1" />
+		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+		<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+		<PackageReference Include="System.Linq.Async" Version="5.0.0" />
+		<PackageReference Include="xunit" Version="2.4.1" />
+		<PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+			<PrivateAssets>all</PrivateAssets>
+		</PackageReference>
+		<PackageReference Include="coverlet.collector" Version="3.0.3">
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+			<PrivateAssets>all</PrivateAssets>
+		</PackageReference>
+	</ItemGroup>
+
+	<!-- .NET 4.5 -->
+	<ItemGroup Condition="'$(TargetFramework)' == 'net45'">
+		<PackageReference Include="Microsoft.CSharp" Version="4.5.0" />
+		<PackageReference Include="System.Buffers" Version="4.5.1" />
+		<PackageReference Include="System.Memory" Version="4.5.4" />
+		<PackageReference Include="System.ValueTuple" Version="4.4.0" />
+        <PackageReference Remove="System.Linq.Async" Version="*" />
+    </ItemGroup>
+
+	<!-- .NET 4.7 -->
+	<ItemGroup Condition="'$(TargetFramework)' == 'net47'">
+		<PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="6.0.0" />
+		<PackageReference Include="Microsoft.Bcl.HashCode" Version="1.1.0" />
+		<PackageReference Include="Microsoft.CSharp" Version="4.5.0" />
+		<PackageReference Include="System.Buffers" Version="4.5.1" />
+		<PackageReference Include="System.Memory" Version="4.5.4" />
+		<PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
+	</ItemGroup>
+
+    <!-- .NET Standard 2.0 -->
+    <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+        <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="6.0.0" />
+        <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
+    </ItemGroup>
+
+    <ItemGroup>
+		<ProjectReference Include="..\..\src\CsvHelper\CsvHelper.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+	</ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net452.v3.ncrunchproject b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net452.v3.ncrunchproject
new file mode 100644
index 0000000..9d694dc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net452.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreventSigningOfAssembly>True</PreventSigningOfAssembly>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net47.v3.ncrunchproject b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net47.v3.ncrunchproject
new file mode 100644
index 0000000..9d694dc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net47.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreventSigningOfAssembly>True</PreventSigningOfAssembly>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net50.v3.ncrunchproject b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net50.v3.ncrunchproject
new file mode 100644
index 0000000..9d694dc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.net50.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreventSigningOfAssembly>True</PreventSigningOfAssembly>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.netcoreapp2.1.v3.ncrunchproject b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.netcoreapp2.1.v3.ncrunchproject
new file mode 100644
index 0000000..9d694dc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.netcoreapp2.1.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreventSigningOfAssembly>True</PreventSigningOfAssembly>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.netcoreapp3.1.v3.ncrunchproject b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.netcoreapp3.1.v3.ncrunchproject
new file mode 100644
index 0000000..9d694dc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.netcoreapp3.1.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreventSigningOfAssembly>True</PreventSigningOfAssembly>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.v3.ncrunchproject b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.v3.ncrunchproject
new file mode 100644
index 0000000..ba4c70e
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.Tests.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreventSigningOfAssembly>False</PreventSigningOfAssembly>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.snk b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.snk
new file mode 100644
index 0000000..8c9bfaf
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvHelper.snk
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserConstructorTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserConstructorTests.cs
new file mode 100644
index 0000000..867e551
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserConstructorTests.cs
@@ -0,0 +1,28 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvParserConstructorTests
+	{
+		[Fact]
+		public void EnsureInternalsAreSetupWhenPassingReaderAndConfigTest()
+		{
+			using( var stream = new MemoryStream() )
+			using( var reader = new StreamReader( stream ) )
+			{
+				var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+				using( var parser = new CsvParser( reader, config ) )
+				{
+					Assert.Same( config, parser.Configuration );
+				}
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserDelimiterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserDelimiterTests.cs
new file mode 100644
index 0000000..3ae27ba
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserDelimiterTests.cs
@@ -0,0 +1,344 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvParserDelimiterTests
+	{
+		[Fact]
+		public void DifferentDelimiterTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "\t",
+				WhiteSpaceChars = new[] { ' ' },
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("1\t2\t3");
+				writer.WriteLine("4\t5\t6");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.Equal("3", parser[2]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("6", parser[2]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void MultipleCharDelimiter2Test()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "``",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("1``2``3");
+				writer.WriteLine("4``5``6");
+				writer.Flush();
+				stream.Position = 0;
+
+				var hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.Equal("3", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("6", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.False(hasRecords);
+			}
+		}
+
+		[Fact]
+		public void MultipleCharDelimiter3Test()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`\t`",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("1`\t`2`\t`3");
+				writer.WriteLine("4`\t`5`\t`6");
+				writer.Flush();
+				stream.Position = 0;
+
+				var hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.Equal("3", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("6", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.False(hasRecords);
+			}
+		}
+
+		[Fact]
+		public void AllFieldsEmptyTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ";;",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine(";;;;");
+				writer.WriteLine(";;;;");
+				writer.Flush();
+				stream.Position = 0;
+
+				var hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("", parser[0]);
+				Assert.Equal("", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("", parser[0]);
+				Assert.Equal("", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.False(hasRecords);
+			}
+		}
+
+		[Fact]
+		public void AllFieldsEmptyNoEolOnLastLineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ";;",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write(";;;;\r\n");
+				writer.Write(";;;;");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("", parser[0]);
+				Assert.Equal("", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("", parser[0]);
+				Assert.Equal("", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void EmptyLastFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ";;",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("1;;2;;");
+				writer.WriteLine("4;;5;;");
+				writer.Flush();
+				stream.Position = 0;
+
+				var hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				hasRecords = parser.Read();
+				Assert.False(hasRecords);
+			}
+		}
+
+		[Fact]
+		public void EmptyLastFieldNoEolOnLastLineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ";;",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1;;2;;\r\n");
+				writer.Write("4;;5;;");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void DifferentDelimiter2ByteCountTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true,
+				Delimiter = ";;",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1;;2\r\n");
+				writer.Write("4;;5\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(6, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(12, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void DifferentDelimiter3ByteCountTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true,
+				Delimiter = ";;;",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1;;;2\r\n");
+				writer.Write("4;;;5\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(7, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(14, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void MultipleCharDelimiterWithBufferEndingInMiddleOfDelimiterTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "|~|",
+				BufferSize = 16,
+			};
+
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("12340000004321|~|2");
+				writer.Flush();
+				stream.Position = 0;
+
+				var hasRecords = parser.Read();
+				Assert.True(hasRecords);
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("12340000004321", parser[0]);
+				Assert.Equal("2", parser[1]);
+
+				hasRecords = parser.Read();
+				Assert.False(hasRecords);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserRawRecordTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserRawRecordTests.cs
new file mode 100644
index 0000000..ec127da
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserRawRecordTests.cs
@@ -0,0 +1,143 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvParserRawRecordTests
+	{
+		[Fact]
+		public void RawRecordCrLfTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("3,4\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal("1,2\r\n", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal("3,4\r\n", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal(string.Empty, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void RawRecordCrTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("1,2\r");
+				writer.Write("3,4\r");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal("1,2\r", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal("3,4\r", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal(string.Empty, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void RawRecordLfTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("1,2\n");
+				writer.Write("3,4\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal("1,2\n", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal("3,4\n", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal(string.Empty, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void RawRecordCr2DelimiterTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ";;",
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1;;2\r");
+				writer.Write("3;;4\r");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal("1;;2\r", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal("3;;4\r", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal(string.Empty, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void TinyBufferTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 1,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("3,4\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal("1,2\r\n", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal("3,4\r\n", parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal(string.Empty, parser.RawRecord.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserTests.cs
new file mode 100644
index 0000000..78beeaf
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvParserTests.cs
@@ -0,0 +1,1370 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvParserTests
+	{
+		[Fact]
+		public void SimpleParseTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("3,4\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.True(parser.Read());
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ParseNewRecordTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,two,three");
+			writer.WriteLine("four,five,six");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, CultureInfo.InvariantCulture);
+
+			var count = 0;
+			while (parser.Read())
+			{
+				count++;
+			}
+
+			Assert.Equal(2, count);
+		}
+
+		[Fact]
+		public void ParseEmptyRowsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = true,
+			};
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,two,three");
+			writer.WriteLine("four,five,six");
+			writer.WriteLine(",,");
+			writer.WriteLine("");
+			writer.WriteLine("");
+			writer.WriteLine("seven,eight,nine");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, config);
+
+			var records = new List<string[]>();
+			while (parser.Read())
+			{
+				records.Add(parser.Record);
+			}
+
+			Assert.Equal(4, records.Count);
+		}
+
+		[Fact]
+		public void ParseTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,two,three");
+			writer.WriteLine("four,five,six");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, CultureInfo.InvariantCulture);
+
+			Assert.True(parser.Read());
+			Assert.Equal("one", parser[0]);
+			Assert.Equal("two", parser[1]);
+			Assert.Equal("three", parser[2]);
+
+			Assert.True(parser.Read());
+			Assert.Equal("four", parser[0]);
+			Assert.Equal("five", parser[1]);
+			Assert.Equal("six", parser[2]);
+
+			Assert.False(parser.Read());
+		}
+
+		[Fact]
+		public void ParseFieldQuotesTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,\"two\",three");
+			writer.WriteLine("four,\"\"\"five\"\"\",six");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, CultureInfo.InvariantCulture);
+
+			Assert.True(parser.Read());
+			Assert.Equal("one", parser[0]);
+			Assert.Equal("two", parser[1]);
+			Assert.Equal("three", parser[2]);
+
+			Assert.True(parser.Read());
+			Assert.Equal("four", parser[0]);
+			Assert.Equal("\"five\"", parser[1]);
+			Assert.Equal("six", parser[2]);
+
+			Assert.False(parser.Read());
+		}
+
+		[Fact]
+		public void ParseSpacesTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine(" one , \"two three\" , four ");
+			writer.WriteLine(" \" five \"\" six \"\" seven \" ");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BadDataFound = null,
+			};
+			var parser = new CsvParser(reader, config);
+
+			Assert.True(parser.Read());
+			Assert.Equal(" one ", parser[0]);
+			Assert.Equal(" \"two three\" ", parser[1]);
+			Assert.Equal(" four ", parser[2]);
+
+			Assert.True(parser.Read());
+			Assert.Equal(" \" five \"\" six \"\" seven \" ", parser[0]);
+
+			Assert.False(parser.Read());
+		}
+
+		[Fact]
+		public void CallingReadMultipleTimesAfterDoneReadingTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,two,three");
+			writer.WriteLine("four,five,six");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, CultureInfo.InvariantCulture);
+
+			parser.Read();
+			parser.Read();
+			parser.Read();
+			parser.Read();
+		}
+
+		[Fact]
+		public void ParseEmptyTest()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ParseCrOnlyTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("\r");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ParseLfOnlyTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ParseCrLnOnlyTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Parse1RecordWithNoCrlfTest()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.Write("one,two,three");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("one", parser[0]);
+				Assert.Equal("two", parser[1]);
+				Assert.Equal("three", parser[2]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Parse2RecordsLastWithNoCrlfTest()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.WriteLine("one,two,three");
+				streamWriter.Write("four,five,six");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				parser.Read();
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("four", parser[0]);
+				Assert.Equal("five", parser[1]);
+				Assert.Equal("six", parser[2]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ParseFirstFieldIsEmptyQuotedTest()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.WriteLine("\"\",\"two\",\"three\"");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("", parser[0]);
+				Assert.Equal("two", parser[1]);
+				Assert.Equal("three", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void ParseLastFieldIsEmptyQuotedTest()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.WriteLine("\"one\",\"two\",\"\"");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("one", parser[0]);
+				Assert.Equal("two", parser[1]);
+				Assert.Equal("", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void ParseQuoteOnlyQuotedFieldTest()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.WriteLine("\"\"\"\",\"two\",\"three\"");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("\"", parser[0]);
+				Assert.Equal("two", parser[1]);
+				Assert.Equal("three", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void ParseRecordsWithOnlyOneField()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.WriteLine("row one");
+				streamWriter.WriteLine("row two");
+				streamWriter.WriteLine("row three");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(1, parser.Count);
+				Assert.Equal("row one", parser[0]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(1, parser.Count);
+				Assert.Equal("row two", parser[0]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(1, parser.Count);
+				Assert.Equal("row three", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void ParseRecordWhereOnlyCarriageReturnLineEndingIsUsed()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.Write("one,two\r");
+				streamWriter.Write("three,four\r");
+				streamWriter.Write("five,six\r");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("one", parser[0]);
+				Assert.Equal("two", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("three", parser[0]);
+				Assert.Equal("four", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("five", parser[0]);
+				Assert.Equal("six", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void ParseRecordWhereOnlyLineFeedLineEndingIsUsed()
+		{
+			using (var memoryStream = new MemoryStream())
+			using (var streamReader = new StreamReader(memoryStream))
+			using (var streamWriter = new StreamWriter(memoryStream))
+			using (var parser = new CsvParser(streamReader, CultureInfo.InvariantCulture))
+			{
+				streamWriter.Write("one,two\n");
+				streamWriter.Write("three,four\n");
+				streamWriter.Write("five,six\n");
+				streamWriter.Flush();
+				memoryStream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("one", parser[0]);
+				Assert.Equal("two", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("three", parser[0]);
+				Assert.Equal("four", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("five", parser[0]);
+				Assert.Equal("six", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void ParseCommentedOutLineWithCommentsOn()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,two,three");
+			writer.WriteLine("#four,five,six");
+			writer.WriteLine("seven,eight,nine");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			var parser = new CsvParser(reader, config);
+
+			parser.Read();
+			parser.Read();
+			Assert.Equal("seven", parser[0]);
+		}
+
+		[Fact]
+		public void ParseCommentedOutLineWithCommentsOff()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = false,
+			};
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,two,three");
+			writer.WriteLine("#four,five,six");
+			writer.WriteLine("seven,eight,nine");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, config);
+
+			parser.Read();
+			parser.Read();
+			Assert.Equal("#four", parser[0]);
+		}
+
+		[Fact]
+		public void ParseCommentedOutLineWithDifferentCommentCommentsOn()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one,two,three");
+			writer.WriteLine("*four,five,six");
+			writer.WriteLine("seven,eight,nine");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+				Comment = '*',
+			};
+			var parser = new CsvParser(reader, config);
+
+			parser.Read();
+			parser.Read();
+			Assert.Equal("seven", parser[0]);
+		}
+
+		[Fact]
+		public void ParseUsingDifferentDelimiter()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("one\ttwo\tthree");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "\t",
+				WhiteSpaceChars = new[] { ' ' },
+			};
+			var parser = new CsvParser(reader, config);
+
+			Assert.True(parser.Read());
+			Assert.Equal("one", parser[0]);
+			Assert.Equal("two", parser[1]);
+			Assert.Equal("three", parser[2]);
+		}
+
+		[Fact]
+		public void ParseUsingDifferentQuote()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("'one','two','three'");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Quote = '\''
+			};
+			var parser = new CsvParser(reader, config);
+
+			Assert.True(parser.Read());
+			Assert.Equal("one", parser[0]);
+			Assert.Equal("two", parser[1]);
+			Assert.Equal("three", parser[2]);
+		}
+
+		[Fact]
+		public void ParseFinalRecordWithNoEndOfLineTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.WriteLine("1,2,");
+			writer.Write("4,5,");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, CultureInfo.InvariantCulture);
+
+			Assert.True(parser.Read());
+			Assert.Equal("", parser[2]);
+
+			Assert.True(parser.Read());
+			Assert.Equal("", parser[2]);
+
+			Assert.False(parser.Read());
+		}
+
+		[Fact]
+		public void ParseLastLineHasNoCrLf()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			writer.Write("a");
+			writer.Flush();
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+
+			var parser = new CsvParser(reader, CultureInfo.InvariantCulture);
+
+			Assert.True(parser.Read());
+			Assert.Equal("a", parser[0]);
+
+			Assert.False(parser.Read());
+		}
+
+		[Fact]
+		public void CharReadTotalTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new TestStreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				// This is a breakdown of the char counts.
+				// Read() will read up to the first line end char
+				// and any more on the line will get read with the next read.
+
+				// [I][d][,][N][a][m][e][\r][\n]
+				//  1  2  3  4  5  6  7   8   9
+				// [1][,][o][n][e][\r][\n]
+				// 10 11 12 13 14  15  16
+				// [,][\r][\n]
+				// 17  18  19
+				// [\r][\n]
+				//  20  21
+				// [#][ ][c][o][m][m][e][n][t][s][\r][\n]
+				// 22 23 24 25 26 27 28 29 30 31  32  33
+				// [2][,][t][w][o][\r][\n]
+				// 34 35 36 37 38  39  40
+				// [3][,]["][t][h][r][e][e][,][ ][f][o][u][r]["][\r][\n]
+				// 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55  56  57
+
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine(",");
+				writer.WriteLine("");
+				writer.WriteLine("# comments");
+				writer.WriteLine("2,two");
+				writer.WriteLine("3,\"three, four\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(9, parser.CharCount);
+
+				parser.Read();
+				Assert.Equal(16, parser.CharCount);
+
+				parser.Read();
+				Assert.Equal(19, parser.CharCount);
+
+				parser.Read();
+				Assert.Equal(40, parser.CharCount);
+
+				parser.Read();
+				Assert.Equal(57, parser.CharCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void StreamSeekingUsingCharPositionTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				// This is a breakdown of the char counts.
+				// Read() will read up to the first line end char
+				// and any more on the line will get read with the next read.
+
+				// [I][d][,][N][a][m][e][\r][\n]
+				//  1  2  3  4  5  6  7   8   9
+				// [1][,][o][n][e][\r][\n]
+				// 10 11 12 13 14  15  16
+				// [,][\r][\n]
+				// 17  18  19
+				// [\r][\n]
+				//  20  21
+				// [#][ ][c][o][m][m][e][n][t][s][\r][\n]
+				// 22 23 24 25 26 27 28 29 30 31  32  33
+				// [2][,][t][w][o][\r][\n]
+				// 34 35 36 37 38  39  40
+				// [3][,]["][t][h][r][e][e][,][ ][f][o][u][r]["][\r][\n]
+				// 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55  56  57
+
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine(",");
+				writer.WriteLine("");
+				writer.WriteLine("# comments");
+				writer.WriteLine("2,two");
+				writer.WriteLine("3,\"three, four\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.CharCount, SeekOrigin.Begin);
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.CharCount, SeekOrigin.Begin);
+				parser.Read();
+				Assert.Equal("", parser[0]);
+				Assert.Equal("", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.CharCount, SeekOrigin.Begin);
+				parser.Read();
+				Assert.Equal("2", parser[0]);
+				Assert.Equal("two", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.CharCount, SeekOrigin.Begin);
+				parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("three, four", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void RowTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("3,4\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				var rowCount = 0;
+				while (parser.Read())
+				{
+					rowCount++;
+					Assert.Equal(rowCount, parser.Row);
+				}
+			}
+		}
+
+		[Fact]
+		public void RowBlankLinesTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("\r\n");
+				writer.Write("3,4\r\n");
+				writer.Write("\r\n");
+				writer.Write("5,6\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				var rowCount = 1;
+				while (parser.Read())
+				{
+					Assert.Equal(rowCount, parser.Row);
+					rowCount += 2;
+				}
+			}
+		}
+
+		[Fact]
+		public void IgnoreBlankLinesRowCountTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("1,a");
+				writer.WriteLine();
+				writer.WriteLine("3,c");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(1, parser.Row);
+				Assert.Equal("1", parser[0]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Row);
+				Assert.Equal("3", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void DoNotIgnoreBlankLinesRowCountTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("1,a");
+				writer.WriteLine();
+				writer.WriteLine("3,c");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal(1, parser.Row);
+				Assert.Equal("1", parser[0]);
+
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Row);
+				Assert.Equal(1, parser.Count);
+
+				Assert.True(parser.Read());
+				Assert.Equal(3, parser.Row);
+				Assert.Equal("3", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void RowCommentLinesTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("# comment 1\r\n");
+				writer.Write("3,4\r\n");
+				writer.Write("# comment 2\r\n");
+				writer.Write("5,6\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				var rowCount = 1;
+				while (parser.Read())
+				{
+					Assert.Equal(rowCount, parser.Row);
+					rowCount += 2;
+				}
+			}
+		}
+
+		[Fact]
+		public void RowRawTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new TestStreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("1,\"2");
+				writer.WriteLine("2 continued");
+				writer.WriteLine("end of 2\",3");
+				writer.WriteLine("4,5,6");
+				writer.WriteLine("7,\"8");
+				writer.WriteLine("8 continued");
+				writer.WriteLine("end of 8\",9");
+				writer.WriteLine("10,11,12");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2\r\n2 continued\r\nend of 2", parser[1]);
+				Assert.Equal("3", parser[2]);
+				Assert.Equal(3, parser.RawRow);
+
+				Assert.True(parser.Read());
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("6", parser[2]);
+				Assert.Equal(4, parser.RawRow);
+
+				Assert.True(parser.Read());
+				Assert.Equal("7", parser[0]);
+				Assert.Equal("8\r\n8 continued\r\nend of 8", parser[1]);
+				Assert.Equal("9", parser[2]);
+				Assert.Equal(7, parser.RawRow);
+
+				Assert.True(parser.Read());
+				Assert.Equal("10", parser[0]);
+				Assert.Equal("11", parser[1]);
+				Assert.Equal("12", parser[2]);
+				Assert.Equal(8, parser.RawRow);
+			}
+		}
+
+		[Fact]
+		public void ByteCountTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream, config.Encoding))
+			using (var reader = new StreamReader(stream, config.Encoding))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("3,4\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(5, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(10, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ByteCountTestWithQuotedFields()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream, config.Encoding))
+			using (var reader = new StreamReader(stream, config.Encoding))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,\"2\"\r\n");
+				writer.Write("\"3\",4\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(7, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(14, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ByteCountTestWithQuotedFieldsEmptyQuotedField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream, config.Encoding))
+			using (var reader = new StreamReader(stream, config.Encoding))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,\"\",2\r\n");
+				writer.Write("\"3\",4,\"5\"\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(8, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(19, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ByteCountTestWithQuotedFieldsClosingQuoteAtStartOfBuffer()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true,
+				BufferSize = 4
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream, config.Encoding))
+			using (var reader = new StreamReader(stream, config.Encoding))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,\"2\",3\r\n");
+				writer.Write("\"4\",5,\"6\"\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(9, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(20, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ByteCountTestWithQuotedFieldsEscapedQuoteAtStartOfBuffer()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true,
+				BufferSize = 4
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream, config.Encoding))
+			using (var reader = new StreamReader(stream, config.Encoding))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,\"2a\",3\r\n");
+				writer.Write("\"\"\"4\"\"\",5,\"6\"\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(10, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(25, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void ByteCountUsingCharWithMoreThanSingleByteTest()
+		{
+			var encoding = Encoding.Unicode;
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CountBytes = true,
+				Encoding = encoding,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream, encoding))
+			using (var reader = new StreamReader(stream, encoding))
+			using (var parser = new CsvParser(reader, config))
+			{
+				//崔钟铉
+				writer.Write("1,崔\r\n");
+				writer.Write("3,钟\r\n");
+				writer.Write("5,铉\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal(10, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(20, parser.ByteCount);
+
+				parser.Read();
+				Assert.Equal(30, parser.ByteCount);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void StreamSeekingUsingByteCountTest()
+		{
+			var encoding = Encoding.Unicode;
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+				CountBytes = true,
+				Encoding = encoding,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream, encoding))
+			using (var reader = new StreamReader(stream, encoding))
+			using (var parser = new CsvParser(reader, config))
+			{
+				// This is a breakdown of the char counts.
+				// Read() will read up to the first line end char
+				// and any more on the line will get read with the next read.
+
+				// [I][d][,][N][a][m][e][\r][\n]
+				//  1  2  3  4  5  6  7   8   9
+				// [1][,][o][n][e][\r][\n]
+				// 10 11 12 13 14  15  16
+				// [,][\r][\n]
+				// 17  18  19
+				// [\r][\n]
+				//  20  21
+				// [#][ ][c][o][m][m][e][n][t][s][\r][\n]
+				// 22 23 24 25 26 27 28 29 30 31  32  33
+				// [2][,][t][w][o][\r][\n]
+				// 34 35 36 37 38  39  40
+				// [3][,]["][t][h][r][e][e][,][ ][f][o][u][r]["][\r][\n]
+				// 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55  56  57
+
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine(",");
+				writer.WriteLine("");
+				writer.WriteLine("# comments");
+				writer.WriteLine("2,two");
+				writer.WriteLine("3,\"three, four\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				var record = parser.Read();
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.ByteCount, SeekOrigin.Begin);
+				record = parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.ByteCount, SeekOrigin.Begin);
+				record = parser.Read();
+				Assert.Equal("", parser[0]);
+				Assert.Equal("", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.ByteCount, SeekOrigin.Begin);
+				record = parser.Read();
+				Assert.Equal("2", parser[0]);
+				Assert.Equal("two", parser[1]);
+
+				stream.Position = 0;
+				stream.Seek(parser.ByteCount, SeekOrigin.Begin);
+				record = parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("three, four", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void SimulateSeekingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				// Already read:
+				// 1,2,3\r
+				// Seeked to this position.
+				writer.Write("\n4,5,6\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				// Make sure this doesn't throw an exception.
+				Assert.True(parser.Read());
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("6", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void NullCharTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("1,\0,3");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("\0", parser[1]);
+				Assert.Equal("3", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void RawRecordCorruptionTest()
+		{
+			var row1 = new string('a', 2038) + ",b\r\n";
+			var row2 = "test1,test2";
+			var val = row1 + row2;
+
+			using (var reader = new StringReader(val))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal(row1, parser.RawRecord.ToString());
+
+				parser.Read();
+				Assert.Equal(row2, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void ParseNoQuotesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("one,\"two\",three \" four, \"five\" \n"); // `one,"two",three " four, "five" `
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal("one", parser[0]);
+				Assert.Equal("\"two\"", parser[1]);
+				Assert.Equal("three \" four", parser[2]);
+				Assert.Equal(" \"five\" ", parser[3]);
+			}
+		}
+
+		[Fact]
+		public void LastLineHasCommentTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("#comment");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void LastLineHasCommentNoEolTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("#c");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void DoNotIgnoreBlankLinesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.WriteLine("1,2,3");
+				writer.WriteLine(",,");
+				writer.WriteLine("");
+				writer.WriteLine("4,5,6");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.Equal("3", parser[2]);
+
+				parser.Read();
+				Assert.Equal("", parser[0]);
+				Assert.Equal("", parser[1]);
+				Assert.Equal("", parser[2]);
+
+				parser.Read();
+				Assert.Equal(1, parser.Count);
+
+				parser.Read();
+				Assert.Equal("4", parser[0]);
+				Assert.Equal("5", parser[1]);
+				Assert.Equal("6", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void QuotedFieldWithCarriageReturnTest()
+		{
+			using (var reader = new StringReader("\"a\r\",b"))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal(new[] { "a\r", "b" }, parser.Record);
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void QuotedFieldWithLineFeedTest()
+		{
+			using (var reader = new StringReader("\"a\n\",b"))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal(new[] { "a\n", "b" }, parser.Record);
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void RowCountWithSingleLineAndNoLineEndingTest()
+		{
+			using (var reader = new StringReader("a,b"))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal(1, parser.Row);
+			}
+		}
+
+		[Fact]
+		public void RawRowCountWithSingleLineAndNoLineEndingTest()
+		{
+			using (var reader = new StringReader("a,b"))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal(1, parser.RawRow);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderConstructorTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderConstructorTests.cs
new file mode 100644
index 0000000..fe24eac
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderConstructorTests.cs
@@ -0,0 +1,52 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvReaderConstructorTests
+	{
+		[Fact]
+		public void EnsureInternalsAreSetupCorrectlyWhenPassingTextReaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				Assert.Same(csv.Configuration, csv.Parser.Configuration);
+			}
+		}
+
+		[Fact]
+		public void EnsureInternalsAreSetupCorrectlyWhenPassingTextReaderAndConfigurationTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)))
+			{
+				Assert.Same(csv.Configuration, csv.Parser.Configuration);
+			}
+		}
+
+		[Fact]
+		public void EnsureInternalsAreSetupCorrectlyWhenPassingParserTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			{
+				var parser = new CsvParser(reader, CultureInfo.InvariantCulture);
+
+				using (var csv = new CsvReader(parser))
+				{
+					Assert.Same(csv.Configuration, csv.Parser.Configuration);
+					Assert.Same(parser, csv.Parser);
+				}
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderDefaultValueTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderDefaultValueTests.cs
new file mode 100644
index 0000000..ba5d832
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderDefaultValueTests.cs
@@ -0,0 +1,106 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvReaderDefaultValueTests
+	{
+		[Fact]
+		public void DefaultValueTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name,Order");
+				writer.WriteLine(",,");
+				writer.WriteLine("2,two,2");
+				writer.WriteLine(",three,");
+				writer.Flush();
+				stream.Position = 0;
+
+				csvReader.Context.RegisterClassMap<TestMap>();
+
+				var records = csvReader.GetRecords<Test>().ToList();
+
+				var record = records[0];
+				Assert.Equal(-1, record.Id);
+				Assert.Null(record.Name);
+				Assert.Equal(-2, record.Order);
+
+				record = records[1];
+				Assert.Equal(2, record.Id);
+				Assert.Equal("two", record.Name);
+			}
+		}
+
+		[Fact]
+		public void DefaultStringValueTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name,Order");
+				writer.WriteLine(",,");
+				writer.WriteLine("2,two,2");
+				writer.WriteLine(",three,");
+				writer.Flush();
+				stream.Position = 0;
+
+				csvReader.Context.RegisterClassMap<TestStringMap>();
+
+				var records = csvReader.GetRecords<Test>().ToList();
+
+				var record = records[0];
+				Assert.Equal(-1, record.Id);
+				Assert.Null(record.Name);
+				Assert.Equal(-2, record.Order);
+
+				record = records[1];
+				Assert.Equal(2, record.Id);
+				Assert.Equal("two", record.Name);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+
+			public int Order { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Id).Default(-1);
+				Map(m => m.Name).Default((string)null);
+				Map(m => m.Order).Default(-2);
+			}
+		}
+
+		private sealed class TestStringMap : ClassMap<Test>
+		{
+			public TestStringMap()
+			{
+				Map(m => m.Id).Default("-1");
+				Map(m => m.Name).Default(null);
+				Map(m => m.Order).Default("-2");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderDynamicMappingsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderDynamicMappingsTests.cs
new file mode 100644
index 0000000..e2d9336
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderDynamicMappingsTests.cs
@@ -0,0 +1,63 @@
+// Copyright 2009-2020 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	public class CsvReaderDynamicMappingsTests
+	{
+		[Fact]
+		public void CanMapDynamics()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "IntCol", "StringCol" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<DynamicMappingsTypeClassMap>();
+
+			var records = csvReader.GetRecords<DynamicMappingsType>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0].IntCol);
+			Assert.Equal("one", records[0].StringCol);
+			Assert.Equal(2, records[1].IntCol);
+			Assert.Equal("two", records[1].StringCol);
+		}
+
+		private class DynamicMappingsType
+		{
+			public int IntCol { get; set; }
+			public string StringCol { get; set; }
+
+			public static IEnumerable<Expression<Func<DynamicMappingsType, dynamic>>> Mappings =>
+				new List<Expression<Func<DynamicMappingsType, dynamic>>>
+			{
+				i => i.IntCol,
+				i => i.StringCol
+			};
+		}
+
+		private class DynamicMappingsTypeClassMap : ClassMap<DynamicMappingsType>
+		{
+			public DynamicMappingsTypeClassMap()
+			{
+				foreach (var mapping in DynamicMappingsType.Mappings)
+				{
+					Map(mapping);
+				}
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderErrorMessageTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderErrorMessageTests.cs
new file mode 100644
index 0000000..be9db27
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderErrorMessageTests.cs
@@ -0,0 +1,258 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvReaderErrorMessageTests
+	{
+		public CsvReaderErrorMessageTests()
+		{
+			Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
+		}
+
+		[Fact]
+		public void FirstColumnEmptyFirstRowErrorWithNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				csvReader.Context.RegisterClassMap<Test1Map>();
+				writer.WriteLine(",one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				try
+				{
+					var records = csvReader.GetRecords<Test1>().ToList();
+					throw new Exception();
+				}
+				catch (TypeConverterException ex)
+				{
+					Assert.Equal(1, ex.Context.Parser.Row);
+					Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+				}
+			}
+		}
+
+		[Fact]
+		public void FirstColumnEmptySecondRowErrorWithHeader()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				csvReader.Context.RegisterClassMap<Test1Map>();
+				writer.WriteLine("IntColumn,StringColumn");
+				writer.WriteLine("1,one");
+				writer.WriteLine(",two");
+				writer.Flush();
+				stream.Position = 0;
+
+				try
+				{
+					var records = csvReader.GetRecords<Test1>().ToList();
+					throw new Exception();
+				}
+				catch (TypeConverterException ex)
+				{
+					Assert.Equal(3, ex.Context.Parser.Row);
+					Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+				}
+			}
+		}
+
+		[Fact]
+		public void FirstColumnEmptyErrorWithHeaderAndCommentRowTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				csvReader.Context.RegisterClassMap<Test1Map>();
+				writer.WriteLine("IntColumn,StringColumn");
+				writer.WriteLine("# comment");
+				writer.WriteLine();
+				writer.WriteLine(",one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				try
+				{
+					var records = csvReader.GetRecords<Test1>().ToList();
+					throw new Exception();
+				}
+				catch (TypeConverterException ex)
+				{
+					Assert.Equal(4, ex.Context.Parser.Row);
+					Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+				}
+			}
+		}
+
+		[Fact]
+		public void FirstColumnErrorTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				csvReader.Context.RegisterClassMap<Test1Map>();
+				writer.WriteLine("IntColumn,StringColumn");
+				writer.WriteLine();
+				writer.WriteLine("one,one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				try
+				{
+					var records = csvReader.GetRecords<Test1>().ToList();
+					throw new Exception();
+				}
+				catch (TypeConverterException ex)
+				{
+					Assert.Equal(3, ex.Context.Parser.Row);
+					Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+				}
+			}
+		}
+
+		[Fact]
+		public void SecondColumnEmptyErrorTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				csvReader.Context.RegisterClassMap<Test2Map>();
+				writer.WriteLine("StringColumn,IntColumn");
+				writer.WriteLine("one,");
+				writer.WriteLine("two,2");
+				writer.Flush();
+				stream.Position = 0;
+
+				try
+				{
+					var records = csvReader.GetRecords<Test2>().ToList();
+					throw new Exception();
+				}
+				catch (TypeConverterException ex)
+				{
+					Assert.Equal(2, ex.Context.Parser.Row);
+					Assert.Equal(1, ex.Context.Reader.CurrentIndex);
+				}
+			}
+		}
+
+		[Fact]
+		public void Test()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,9/24/2012");
+				writer.Flush();
+				stream.Position = 0;
+
+				try
+				{
+					csvReader.Context.RegisterClassMap<Test3Map>();
+					var records = csvReader.GetRecords<Test3>().ToList();
+				}
+				catch (ReaderException)
+				{
+					// Should throw this exception.
+				}
+			}
+		}
+
+		private class Test1
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+		}
+
+		private sealed class Test1Map : ClassMap<Test1>
+		{
+			public Test1Map()
+			{
+				Map(m => m.IntColumn).Index(0);
+				Map(m => m.StringColumn).Index(1);
+			}
+		}
+
+		private class Test2
+		{
+			public string StringColumn { get; set; }
+
+			public int IntColumn { get; set; }
+		}
+
+		private sealed class Test2Map : ClassMap<Test2>
+		{
+			public Test2Map()
+			{
+				Map(m => m.StringColumn);
+				Map(m => m.IntColumn);
+			}
+		}
+
+		private class Test3
+		{
+			public int Id { get; set; }
+
+			public DateTime CreationDate { get; set; }
+
+			public string Description { get; set; }
+		}
+
+		private sealed class Test3Map : ClassMap<Test3>
+		{
+			public Test3Map()
+			{
+				Map(m => m.Id).Index(0);
+				Map(m => m.CreationDate).Index(1);
+				Map(m => m.Description).Index(2);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderMappingTests.cs
new file mode 100644
index 0000000..38255da
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderMappingTests.cs
@@ -0,0 +1,355 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+
+	public class CsvReaderMappingTests
+	{
+		[Fact]
+		public void ReadWithConvertUsingTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "int2", "string.3" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			// csvReader.Configuration.HeaderValidated = (isValid, headerNames, headerNameIndex, context) => {};
+			csvReader.Context.RegisterClassMap<ConvertUsingClassMap>();
+
+			var records = csvReader.GetRecords<MultipleNamesClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0].IntColumn);
+			Assert.Equal("one", records[0].StringColumn);
+			Assert.Equal(2, records[1].IntColumn);
+			Assert.Equal("two", records[1].StringColumn);
+		}
+
+		[Fact]
+		public void ReadMultipleNamesTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "int2", "string3" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<MultipleNamesClassMap>();
+
+			var records = csvReader.GetRecords<MultipleNamesClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0].IntColumn);
+			Assert.Equal("one", records[0].StringColumn);
+			Assert.Equal(2, records[1].IntColumn);
+			Assert.Equal("two", records[1].StringColumn);
+		}
+
+		[Fact]
+		public void ConvertUsingTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" },
+				{ "3", "4" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<ConvertUsingMap>();
+
+			var records = csvReader.GetRecords<TestClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(3, records[0].IntColumn);
+			Assert.Equal(7, records[1].IntColumn);
+		}
+
+		[Fact]
+		public void ConvertUsingCovarianceTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<CovarianceClassMap>();
+
+			var records = csvReader.GetRecords<CovarianceClass>().ToList();
+		}
+
+		[Fact]
+		public void ConvertUsingBlockTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" },
+				{ "3", "4" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<ConvertUsingBlockMap>();
+
+			var records = csvReader.GetRecords<TestClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(3, records[0].IntColumn);
+			Assert.Equal(7, records[1].IntColumn);
+		}
+
+		[Fact]
+		public void ConvertUsingConstantTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" },
+				{ "3", "4" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<ConvertUsingConstantMap>();
+
+			var records = csvReader.GetRecords<TestClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0].IntColumn);
+			Assert.Equal(1, records[1].IntColumn);
+		}
+
+		[Fact]
+		public void ReadSameNameMultipleTimesTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "ColumnName", "ColumnName", "ColumnName" },
+				{ "2", "3", "1" },
+			};
+
+			var csv = new CsvReader(parserMock);
+			csv.Context.RegisterClassMap<SameNameMultipleTimesClassMap>();
+
+			var records = csv.GetRecords<SameNameMultipleTimesClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Single(records);
+		}
+
+		[Fact]
+		public void ConvertUsingInstanceMethodTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" },
+				{ "3", "4" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<ConvertUsingInstanceMethodMap>();
+
+			var records = csvReader.GetRecords<TestClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(3, records[0].IntColumn);
+			Assert.Equal(7, records[1].IntColumn);
+		}
+
+		[Fact]
+		public void ConvertUsingStaticFunctionTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" },
+				{ "3", "4" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<ConvertUsingStaticFunctionMap>();
+
+			var records = csvReader.GetRecords<TestClass>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(3, records[0].IntColumn);
+			Assert.Equal(7, records[1].IntColumn);
+		}
+
+		private class CovarianceClass
+		{
+			public int? Id { get; set; }
+		}
+
+		private sealed class CovarianceClassMap : ClassMap<CovarianceClass>
+		{
+			public CovarianceClassMap()
+			{
+				Map(m => m.Id).Convert(args => args.Row.GetField<int>(0));
+			}
+		}
+
+		private class ContravarianceClass
+		{
+			public int Id { get; set; }
+		}
+
+		private class TestClass
+		{
+			public int IntColumn { get; set; }
+		}
+
+		private class SameNameMultipleTimesClass
+		{
+			public string Name1 { get; set; }
+
+			public string Name2 { get; set; }
+
+			public string Name3 { get; set; }
+		}
+
+		private sealed class SameNameMultipleTimesClassMap : ClassMap<SameNameMultipleTimesClass>
+		{
+			public SameNameMultipleTimesClassMap()
+			{
+				Map(m => m.Name1).Name("ColumnName").NameIndex(1);
+				Map(m => m.Name2).Name("ColumnName").NameIndex(2);
+				Map(m => m.Name3).Name("ColumnName").NameIndex(0);
+			}
+		}
+
+		private class MultipleNamesClass
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+		}
+
+		private sealed class MultipleNamesClassMap : ClassMap<MultipleNamesClass>
+		{
+			public MultipleNamesClassMap()
+			{
+				Map(m => m.IntColumn).Name("int1", "int2", "int3");
+				Map(m => m.StringColumn).Name("string1", "string2", "string3");
+			}
+		}
+
+
+		private class ConstructorMappingClass
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+
+			public ConstructorMappingClass(string stringColumn)
+			{
+				StringColumn = stringColumn;
+			}
+		}
+
+		private sealed class ConvertUsingMap : ClassMap<TestClass>
+		{
+			public ConvertUsingMap()
+			{
+				Map(m => m.IntColumn).Convert(args => args.Row.GetField<int>(0) + args.Row.GetField<int>(1));
+			}
+		}
+
+		private sealed class ConvertUsingBlockMap : ClassMap<TestClass>
+		{
+			public ConvertUsingBlockMap()
+			{
+				Map(m => m.IntColumn).Convert(args =>
+			 {
+				 var x = args.Row.GetField<int>(0);
+				 var y = args.Row.GetField<int>(1);
+				 return x + y;
+			 });
+			}
+		}
+
+		private sealed class ConvertUsingConstantMap : ClassMap<TestClass>
+		{
+			public ConvertUsingConstantMap()
+			{
+				Map(m => m.IntColumn).Convert(row => 1);
+			}
+		}
+
+		private sealed class ConvertUsingClassMap : ClassMap<MultipleNamesClass>
+		{
+			public ConvertUsingClassMap()
+			{
+				Map(m => m.IntColumn).Name("int2");
+				Map(m => m.StringColumn).Convert(args => args.Row.GetField("string.3"));
+			}
+		}
+
+		private sealed class ConvertUsingInstanceMethodMap : ClassMap<TestClass>
+		{
+			public ConvertUsingInstanceMethodMap()
+			{
+				Map(m => m.IntColumn).Convert(ConvertFromStringFunction);
+			}
+
+			private int ConvertFromStringFunction(ConvertFromStringArgs args)
+			{
+				return args.Row.GetField<int>(0) + args.Row.GetField<int>(1);
+			}
+		}
+
+		private sealed class ConvertUsingStaticFunctionMap : ClassMap<TestClass>
+		{
+			public ConvertUsingStaticFunctionMap()
+			{
+				Map(m => m.IntColumn).Convert(ConvertFromStringFunction);
+			}
+
+			private static int ConvertFromStringFunction(ConvertFromStringArgs args)
+			{
+				return args.Row.GetField<int>(0) + args.Row.GetField<int>(1);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderReferenceMappingPrefixTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderReferenceMappingPrefixTests.cs
new file mode 100644
index 0000000..4116ada
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderReferenceMappingPrefixTests.cs
@@ -0,0 +1,92 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.IO;
+using System.Linq;
+using Xunit;
+using CsvHelper.Configuration;
+using System.Globalization;
+using CsvHelper.Tests.Mocks;
+
+namespace CsvHelper.Tests
+{	
+	public class CsvReaderReferenceMappingPrefixTests
+	{
+		[Fact]
+		public void ReferencesWithPrefixTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "BPrefix_Id", "C.CId" },
+				{ "a1", "b1", "c1" },
+				{ "a2", "b2", "c2" },
+				{ "a3", "b3", "c3" },
+				{ "a4", "b4", "c4" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<AMap>();
+
+				var list = csv.GetRecords<A>().ToList();
+
+				Assert.NotNull(list);
+				Assert.Equal(4, list.Count);
+
+				for (var i = 0; i < 4; i++)
+				{
+					var rowId = i + 1;
+					var row = list[i];
+					Assert.Equal("a" + rowId, row.Id);
+					Assert.Equal("b" + rowId, row.B.Id);
+					Assert.Equal("c" + rowId, row.B.C.Id);
+				}
+			}
+		}
+
+		private class A
+		{
+			public string Id { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public string Id { get; set; }
+
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string Id { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				Map(m => m.Id);
+				References<BMap>(m => m.B).Prefix("BPrefix_", false);
+			}
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+			public BMap()
+			{
+				Map(m => m.Id);
+				References<CMap>(m => m.C).Prefix();
+			}
+		}
+
+		private sealed class CMap : ClassMap<C>
+		{
+			public CMap()
+			{
+				Map(m => m.Id).Name("CId");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderReferenceMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderReferenceMappingTests.cs
new file mode 100644
index 0000000..32907ef
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderReferenceMappingTests.cs
@@ -0,0 +1,113 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.IO;
+using System.Linq;
+using Xunit;
+using CsvHelper.Configuration;
+using System.Globalization;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvReaderReferenceMappingTests
+	{
+		[Fact]
+		public void NestedReferencesClassMappingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<AMap>();
+
+				writer.WriteLine("AId,BId,CId,DId");
+				writer.WriteLine("a1,b1,c1,d1");
+				writer.WriteLine("a2,b2,c2,d2");
+				writer.WriteLine("a3,b3,c3,d3");
+				writer.WriteLine("a4,b4,c4,d4");
+				writer.Flush();
+				stream.Position = 0;
+
+				var list = csv.GetRecords<A>().ToList();
+
+				Assert.NotNull(list);
+				Assert.Equal(4, list.Count);
+
+				for (var i = 0; i < 4; i++)
+				{
+					var rowId = i + 1;
+					var row = list[i];
+					Assert.Equal("a" + rowId, row.Id);
+					Assert.Equal("b" + rowId, row.B.Id);
+					Assert.Equal("c" + rowId, row.B.C.Id);
+					Assert.Equal("d" + rowId, row.B.C.D.Id);
+				}
+			}
+		}
+
+		private class A
+		{
+			public string Id { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public string Id { get; set; }
+
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string Id { get; set; }
+
+			public D D { get; set; }
+		}
+
+		private class D
+		{
+			public string Id { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				Map(m => m.Id).Name("AId");
+				References<BMap>(m => m.B);
+			}
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+			public BMap()
+			{
+				Map(m => m.Id).Name("BId");
+				References<CMap>(m => m.C);
+			}
+		}
+
+		private sealed class CMap : ClassMap<C>
+		{
+			public CMap()
+			{
+				Map(m => m.Id).Name("CId");
+				References<DMap>(m => m.D);
+			}
+		}
+
+		private sealed class DMap : ClassMap<D>
+		{
+			public DMap()
+			{
+				Map(m => m.Id).Name("DId");
+			}
+		}
+
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderSubClassingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderSubClassingTests.cs
new file mode 100644
index 0000000..2a530d7
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderSubClassingTests.cs
@@ -0,0 +1,40 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Linq;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvReaderSubClassingTests
+	{
+		[Fact]
+		public void GetRecordTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+
+			var csvReader = new MyCsvReader(parserMock);
+			csvReader.GetRecords<Test>().ToList();
+		}
+
+		private class MyCsvReader : CsvReader
+		{
+			public MyCsvReader(IParser parser) : base(parser) { }
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderTests.cs
new file mode 100644
index 0000000..09df221
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvReaderTests.cs
@@ -0,0 +1,1166 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+#pragma warning disable 649
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvReaderTests
+	{
+		[Fact]
+		public void HasHeaderRecordNotReadExceptionTest()
+		{
+			var parserMock = new ParserMock();
+			var reader = new CsvReader(parserMock);
+
+			Assert.Throws<ReaderException>(() => reader.GetField<int>(0));
+		}
+
+		[Fact]
+		public void HasHeaderRecordTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "One", "Two" },
+				{ "1", "2" },
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			// Check to see if the header record and first record are set properly.
+			Assert.Equal(Convert.ToInt32("1"), reader.GetField<int>("One"));
+			Assert.Equal(Convert.ToInt32("2"), reader.GetField<int>("Two"));
+			Assert.Equal(Convert.ToInt32("1"), reader.GetField<int>(0));
+			Assert.Equal(Convert.ToInt32("2"), reader.GetField<int>(1));
+		}
+
+		[Fact]
+		public void GetTypeTest()
+		{
+			var data = new[]
+			{
+				"1",
+				"blah",
+				DateTime.Now.ToString("O"),
+				"true",
+				"c",
+				"",
+				Guid.NewGuid().ToString(),
+			};
+
+			var parserMock = new ParserMock();
+			parserMock.Add(data);
+			parserMock.Add(data);
+			parserMock.Add(null);
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			Assert.Equal(Convert.ToInt16(data[0]), reader.GetField<short>(0));
+			Assert.Equal(Convert.ToInt16(data[0]), reader.GetField<short?>(0));
+			Assert.Null(reader.GetField<short?>(5));
+			Assert.Equal(Convert.ToInt32(data[0]), reader.GetField<int>(0));
+			Assert.Equal(Convert.ToInt32(data[0]), reader.GetField<int?>(0));
+			Assert.Null(reader.GetField<int?>(5));
+			Assert.Equal(Convert.ToInt64(data[0]), reader.GetField<long>(0));
+			Assert.Equal(Convert.ToInt64(data[0]), reader.GetField<long?>(0));
+			Assert.Null(reader.GetField<long?>(5));
+			Assert.Equal(Convert.ToDecimal(data[0]), reader.GetField<decimal>(0));
+			Assert.Equal(Convert.ToDecimal(data[0]), reader.GetField<decimal?>(0));
+			Assert.Null(reader.GetField<decimal?>(5));
+			Assert.Equal(Convert.ToSingle(data[0]), reader.GetField<float>(0));
+			Assert.Equal(Convert.ToSingle(data[0]), reader.GetField<float?>(0));
+			Assert.Null(reader.GetField<float?>(5));
+			Assert.Equal(Convert.ToDouble(data[0]), reader.GetField<double>(0));
+			Assert.Equal(Convert.ToDouble(data[0]), reader.GetField<double?>(0));
+			Assert.Null(reader.GetField<double?>(5));
+			Assert.Equal(data[1], reader.GetField<string>(1));
+			Assert.Equal(string.Empty, reader.GetField<string>(5));
+			Assert.Equal(Convert.ToDateTime(data[2]), reader.GetField<DateTime>(2));
+			Assert.Equal(Convert.ToDateTime(data[2]), reader.GetField<DateTime?>(2));
+			Assert.Null(reader.GetField<DateTime?>(5));
+			Assert.Equal(Convert.ToBoolean(data[3]), reader.GetField<bool>(3));
+			Assert.Equal(Convert.ToBoolean(data[3]), reader.GetField<bool?>(3));
+			Assert.Null(reader.GetField<bool?>(5));
+			Assert.Equal(Convert.ToChar(data[4]), reader.GetField<char>(4));
+			Assert.Equal(Convert.ToChar(data[4]), reader.GetField<char?>(4));
+			Assert.Null(reader.GetField<char?>(5));
+			Assert.Equal(new Guid(data[6]), reader.GetField<Guid>(6));
+			Assert.Null(reader.GetField<Guid?>(5));
+		}
+
+		[Fact]
+		public void GetFieldByIndexTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" },
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			Assert.Equal(1, reader.GetField<int>(0));
+			Assert.Equal(2, reader.GetField<int>(1));
+		}
+
+		[Fact]
+		public void GetFieldByNameTest()
+		{
+			var data1 = new[] { "One", "Two" };
+			var data2 = new[] { "1", "2" };
+			var parserMock = new ParserMock();
+			parserMock.Add(data1);
+			parserMock.Add(data2);
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			Assert.Equal(Convert.ToInt32(data2[0]), reader.GetField<int>("One"));
+			Assert.Equal(Convert.ToInt32(data2[1]), reader.GetField<int>("Two"));
+		}
+
+		[Fact]
+		public void GetFieldByNameAndIndexTest()
+		{
+			var data1 = new[] { "One", "One" };
+			var data2 = new[] { "1", "2" };
+			var parserMock = new ParserMock();
+			parserMock.Add(data1);
+			parserMock.Add(data2);
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			Assert.Equal(Convert.ToInt32(data2[0]), reader.GetField<int>("One", 0));
+			Assert.Equal(Convert.ToInt32(data2[1]), reader.GetField<int>("One", 1));
+		}
+
+		[Fact]
+		public void GetMissingFieldByNameTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			var data1 = new[] { "One", "Two" };
+			var data2 = new[] { "1", "2" };
+			var parserMock = new ParserMock(config);
+			parserMock.Add(data1);
+			parserMock.Add(data2);
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+
+			Assert.Null(reader.GetField<string>("blah"));
+		}
+
+		[Fact]
+		public void GetMissingFieldByNameStrictTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "One", "Two" },
+				{ "1", "2" },
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+
+			Assert.Throws<MissingFieldException>(() => reader.GetField<string>("blah"));
+		}
+
+		[Fact]
+		public void GetMissingFieldByIndexStrictTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "One", "Two" },
+				{ "1", "2" },
+				null,
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			Assert.Throws<MissingFieldException>(() => reader.GetField(2));
+		}
+
+		[Fact]
+		public void GetMissingFieldGenericByIndexStrictTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "One", "Two" },
+				{ "1", "2" },
+				null,
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = false,
+			};
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			Assert.Throws<MissingFieldException>(() => reader.GetField<string>(2));
+		}
+
+		[Fact]
+		public void GetMissingFieldByIndexStrictOffTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "One", "Two" },
+				{ "1", "2" },
+				null,
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			Assert.Null(reader.GetField(2));
+		}
+
+		[Fact]
+		public void GetMissingFieldGenericByIndexStrictOffTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "One", "Two" },
+				{ "1", "2" },
+				null,
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			Assert.Null(reader.GetField<string>(2));
+		}
+
+		[Fact]
+		public void GetFieldByNameNoHeaderExceptionTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2" }
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			Assert.Throws<ReaderException>(() => reader.GetField<int>("One"));
+		}
+
+		[Fact]
+		public void GetRecordWithDuplicateHeaderFields()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "Field1", "Field1" },
+				{ "Field1", "Field1" },
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+		}
+
+		[Fact]
+		public void GetRecordGenericTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+				HeaderValidated = null,
+			};
+			var headerData = new[]
+			{
+				"IntColumn",
+				"String Column",
+				"GuidColumn",
+			};
+			var recordData = new[]
+			{
+				"1",
+				"string column",
+				Guid.NewGuid().ToString(),
+			};
+			var csvParserMock = new ParserMock(config)
+			{
+				headerData,
+				recordData,
+				null,
+			};
+
+			var csv = new CsvReader(csvParserMock);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+			csv.Read();
+			var record = csv.GetRecord<TestRecord>();
+
+			Assert.Equal(Convert.ToInt32(recordData[0]), record.IntColumn);
+			Assert.Equal(recordData[1], record.StringColumn);
+			Assert.Equal("test", record.TypeConvertedColumn);
+			Assert.Equal(Convert.ToInt32(recordData[0]), record.FirstColumn);
+			Assert.Equal(new Guid(recordData[2]), record.GuidColumn);
+		}
+
+		[Fact]
+		public void GetRecordTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+				HeaderValidated = null,
+			};
+			var headerData = new[]
+			{
+				"IntColumn",
+				"String Column",
+				"GuidColumn",
+			};
+			var recordData = new[]
+			{
+				"1",
+				"string column",
+				Guid.NewGuid().ToString(),
+			};
+			var csvParserMock = new ParserMock(config)
+			{
+				headerData,
+				recordData,
+				null,
+			};
+
+			var csv = new CsvReader(csvParserMock);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+			csv.Read();
+			var record = (TestRecord)csv.GetRecord(typeof(TestRecord));
+
+			Assert.Equal(Convert.ToInt32(recordData[0]), record.IntColumn);
+			Assert.Equal(recordData[1], record.StringColumn);
+			Assert.Equal("test", record.TypeConvertedColumn);
+			Assert.Equal(Convert.ToInt32(recordData[0]), record.FirstColumn);
+			Assert.Equal(new Guid(recordData[2]), record.GuidColumn);
+		}
+
+		[Fact]
+		public void GetRecordsGenericTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+				HeaderValidated = null,
+			};
+			var headerData = new[]
+			{
+				"IntColumn",
+				"String Column",
+				"GuidColumn",
+			};
+			var guid = Guid.NewGuid();
+			var csvParserMock = new ParserMock(config)
+			{
+				headerData,
+				{ "1", "string column 1", guid.ToString() },
+				{ "2", "string column 2", guid.ToString() },
+			};
+
+			var csv = new CsvReader(csvParserMock);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+			var records = csv.GetRecords<TestRecord>().ToList();
+
+			Assert.Equal(2, records.Count);
+
+			for (var i = 1; i <= records.Count; i++)
+			{
+				var record = records[i - 1];
+				Assert.Equal(i, record.IntColumn);
+				Assert.Equal("string column " + i, record.StringColumn);
+				Assert.Equal("test", record.TypeConvertedColumn);
+				Assert.Equal(i, record.FirstColumn);
+				Assert.Equal(guid, record.GuidColumn);
+			}
+		}
+
+		[Fact]
+		public void GetRecordsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+				HeaderValidated = null,
+			};
+			var headerData = new[]
+			{
+				"IntColumn",
+				"String Column",
+				"GuidColumn",
+			};
+			var guid = Guid.NewGuid();
+			var csvParserMock = new ParserMock(config)
+			{
+				headerData,
+				{ "1", "string column 1", guid.ToString() },
+				{ "2", "string column 2", guid.ToString() },
+			};
+
+			var csv = new CsvReader(csvParserMock);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+			var records = csv.GetRecords(typeof(TestRecord)).ToList();
+
+			Assert.Equal(2, records.Count);
+
+			for (var i = 1; i <= records.Count; i++)
+			{
+				var record = (TestRecord)records[i - 1];
+				Assert.Equal(i, record.IntColumn);
+				Assert.Equal("string column " + i, record.StringColumn);
+				Assert.Equal("test", record.TypeConvertedColumn);
+				Assert.Equal(i, record.FirstColumn);
+				Assert.Equal(guid, record.GuidColumn);
+			}
+		}
+
+		[Fact]
+		public void GetRecordsWithDuplicateHeaderNames()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			var headerData = new[]
+			{
+				"Column",
+				"Column",
+				"Column"
+			};
+
+			var csvParserMock = new ParserMock(config)
+			{
+				headerData,
+				{ "one", "two", "three" },
+				{ "one", "two", "three" },
+			};
+
+			var csv = new CsvReader(csvParserMock);
+			csv.Context.RegisterClassMap<TestRecordDuplicateHeaderNamesMap>();
+			var records = csv.GetRecords<TestRecordDuplicateHeaderNames>().ToList();
+
+			Assert.Equal(2, records.Count);
+
+			for (var i = 1; i <= records.Count; i++)
+			{
+				var record = records[i - 1];
+				Assert.Equal("one", record.Column1);
+				Assert.Equal("two", record.Column2);
+				Assert.Equal("three", record.Column3);
+			}
+		}
+
+		[Fact]
+		public void GetRecordEmptyFileWithHeaderOnTest()
+		{
+			var parserMock = new ParserMock
+			{
+				null,
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			try
+			{
+				csvReader.Read();
+				csvReader.ReadHeader();
+				csvReader.Read();
+				throw new XUnitException();
+			}
+			catch (ReaderException) { }
+		}
+
+		[Fact]
+		public void GetRecordEmptyValuesNullableTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+
+			writer.WriteLine("StringColumn,IntColumn,GuidColumn");
+			writer.WriteLine("one,1,11111111-1111-1111-1111-111111111111");
+			writer.WriteLine(",,");
+			writer.WriteLine("three,3,33333333-3333-3333-3333-333333333333");
+			writer.Flush();
+			stream.Position = 0;
+
+			var reader = new StreamReader(stream);
+			var csvReader = new CsvReader(reader, CultureInfo.InvariantCulture);
+
+			csvReader.Read();
+			var record = csvReader.GetRecord<TestNullable>();
+			Assert.NotNull(record);
+			Assert.Equal("one", record.StringColumn);
+			Assert.Equal(1, record.IntColumn);
+			Assert.Equal(new Guid("11111111-1111-1111-1111-111111111111"), record.GuidColumn);
+
+			csvReader.Read();
+			record = csvReader.GetRecord<TestNullable>();
+			Assert.NotNull(record);
+			Assert.Equal(string.Empty, record.StringColumn);
+			Assert.Null(record.IntColumn);
+			Assert.Null(record.GuidColumn);
+
+			csvReader.Read();
+			record = csvReader.GetRecord<TestNullable>();
+			Assert.NotNull(record);
+			Assert.Equal("three", record.StringColumn);
+			Assert.Equal(3, record.IntColumn);
+			Assert.Equal(new Guid("33333333-3333-3333-3333-333333333333"), record.GuidColumn);
+		}
+
+		[Fact]
+		public void CaseInsensitiveHeaderMatchingTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => args.Header.ToLower(),
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("One,Two,Three");
+				writer.WriteLine("1,2,3");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+
+				Assert.Equal("1", csv.GetField("one"));
+				Assert.Equal("2", csv.GetField("TWO"));
+				Assert.Equal("3", csv.GetField("ThreE"));
+			}
+		}
+
+		[Fact]
+		public void SpacesInHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => Regex.Replace(args.Header, @"\s", string.Empty),
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ " Int Column ", " String Column " },
+				{ "1", "one" },
+			};
+			var reader = new CsvReader(parserMock);
+			var data = reader.GetRecords<TestDefaultValues>().ToList();
+			Assert.NotNull(data);
+			Assert.Single(data);
+			Assert.Equal(1, data[0].IntColumn);
+			Assert.Equal("one", data[0].StringColumn);
+		}
+
+		[Fact]
+		public void BooleanTypeConverterTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+
+			writer.WriteLine("BoolColumn,BoolNullableColumn,StringColumn");
+			writer.WriteLine("true,true,1");
+			writer.WriteLine("True,True,2");
+			writer.WriteLine("1,1,3");
+			writer.WriteLine("false,false,4");
+			writer.WriteLine("False,False,5");
+			writer.WriteLine("0,0,6");
+
+			writer.Flush();
+			stream.Position = 0;
+
+			var reader = new StreamReader(stream);
+			var csvReader = new CsvReader(reader, CultureInfo.InvariantCulture);
+
+			var records = csvReader.GetRecords<TestBoolean>().ToList();
+
+			Assert.True(records[0].BoolColumn);
+			Assert.True(records[0].BoolNullableColumn);
+			Assert.True(records[1].BoolColumn);
+			Assert.True(records[1].BoolNullableColumn);
+			Assert.True(records[2].BoolColumn);
+			Assert.True(records[2].BoolNullableColumn);
+			Assert.False(records[3].BoolColumn);
+			Assert.False(records[3].BoolNullableColumn);
+			Assert.False(records[4].BoolColumn);
+			Assert.False(records[4].BoolNullableColumn);
+			Assert.False(records[5].BoolColumn);
+			Assert.False(records[5].BoolNullableColumn);
+		}
+
+		[Fact]
+		public void SkipEmptyRecordsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+				ShouldSkipRecord = args => args.Row.Parser.Record.All(string.IsNullOrWhiteSpace),
+			};
+
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2", "3" },
+				{ "", "", "" },
+				{ "4", "5", "6" },
+			};
+
+			var reader = new CsvReader(parserMock);
+
+			reader.Read();
+			Assert.Equal("1", reader.Parser.Record[0]);
+			Assert.Equal("2", reader.Parser.Record[1]);
+			Assert.Equal("3", reader.Parser.Record[2]);
+
+			reader.Read();
+			Assert.Equal("4", reader.Parser.Record[0]);
+			Assert.Equal("5", reader.Parser.Record[1]);
+			Assert.Equal("6", reader.Parser.Record[2]);
+
+			Assert.False(reader.Read());
+		}
+
+		[Fact]
+		public void SkipRecordCallbackTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+				ShouldSkipRecord = args => args.Row[1] == "2",
+			};
+
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "2", "3" },
+				{ " ", "", "" },
+				{ "4", "5", "6" },
+			};
+
+			var reader = new CsvReader(parserMock);
+
+			reader.Read();
+			Assert.Equal(" ", reader.Parser.Record[0]);
+			Assert.Equal("", reader.Parser.Record[1]);
+			Assert.Equal("", reader.Parser.Record[2]);
+
+			reader.Read();
+			Assert.Equal("4", reader.Parser.Record[0]);
+			Assert.Equal("5", reader.Parser.Record[1]);
+			Assert.Equal("6", reader.Parser.Record[2]);
+
+			Assert.False(reader.Read());
+		}
+
+		[Fact]
+		public void MultipleGetRecordsCalls()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("IntColumn,String Column");
+				writer.WriteLine("1,one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				csvReader.Context.RegisterClassMap<TestRecordMap>();
+				var records = csvReader.GetRecords<TestRecord>();
+				Assert.Equal(2, records.Count());
+				Assert.Empty(records);
+			}
+		}
+
+		[Fact]
+		public void IgnoreExceptionsTest()
+		{
+			var callbackCount = 0;
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ReadingExceptionOccurred = (ex) =>
+				{
+					callbackCount++;
+					return false;
+				},
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "BoolColumn", "BoolNullableColumn", "StringColumn" },
+				{ "1", "1", "one" },
+				{ "two", "1", "two" },
+				{ "1", "1", "three" },
+				{ "four", "1", "four" },
+				{ "1", "1", "five" },
+			};
+			var csv = new CsvReader(parserMock);
+
+			var records = csv.GetRecords<TestBoolean>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(3, records.Count);
+			Assert.Equal(2, callbackCount);
+			Assert.Equal("one", records[0].StringColumn);
+			Assert.Equal("three", records[1].StringColumn);
+			Assert.Equal("five", records[2].StringColumn);
+		}
+
+		[Fact]
+		public void ReadStructRecordsTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+			var csv = new CsvReader(parserMock);
+			var records = csv.GetRecords<TestStruct>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0].Id);
+			Assert.Equal("one", records[0].Name);
+			Assert.Equal(2, records[1].Id);
+			Assert.Equal("two", records[1].Name);
+		}
+
+		[Fact]
+		public void WriteStructReferenceRecordsTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+			};
+			var csv = new CsvReader(parserMock);
+			csv.Context.RegisterClassMap<TestStructParentMap>();
+			var records = csv.GetRecords<TestStructParent>().ToList();
+			Assert.NotNull(records);
+			Assert.Single(records);
+			Assert.Equal(1, records[0].Test.Id);
+			Assert.Equal("one", records[0].Test.Name);
+		}
+
+		[Fact]
+		public void ReadPrimitiveRecordsHasHeaderTrueTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id" },
+				{ "1" },
+				{ "2" },
+			};
+			var csv = new CsvReader(parserMock);
+			var records = csv.GetRecords<int>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0]);
+			Assert.Equal(2, records[1]);
+		}
+
+		[Fact]
+		public void ReadPrimitiveRecordsHasHeaderFalseTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1" },
+				{ "2" },
+			};
+			var csv = new CsvReader(parserMock);
+			var records = csv.GetRecords<int>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0]);
+			Assert.Equal(2, records[1]);
+		}
+
+		[Fact]
+		public void TrimHeadersTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+				PrepareHeaderForMatch = args => args.Header.Trim(),
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ " one ", " two three " },
+				{ "1", "2" },
+			};
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+			Assert.Equal("1", reader.GetField("one"));
+			Assert.Equal("2", reader.GetField("two three"));
+			Assert.Null(reader.GetField("twothree"));
+		}
+
+		[Fact]
+		public void RowTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+
+			var csv = new CsvReader(parserMock);
+
+			csv.Read();
+			Assert.Equal(1, csv.Parser.Row);
+
+			csv.Read();
+			Assert.Equal(2, csv.Parser.Row);
+		}
+
+		[Fact]
+		public void DoNotIgnoreBlankLinesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ",",
+				IgnoreBlankLines = false,
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				csv.Context.RegisterClassMap<SimpleMap>();
+
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine(",");
+				writer.WriteLine("");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<Simple>().ToList();
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+				Assert.Null(records[1].Id);
+				Assert.Equal("", records[1].Name);
+				Assert.Null(records[2].Id);
+				Assert.Equal("", records[2].Name);
+				Assert.Equal(2, records[3].Id);
+				Assert.Equal("two", records[3].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteNestedHeadersTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ReferenceHeaderPrefix = args => $"{args.MemberName}.",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Simple1.Id,Simple1.Name,Simple2.Id,Simple2.Name");
+				writer.WriteLine("1,one,2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<Nested>().ToList();
+				Assert.NotNull(records);
+				Assert.Equal(1, records[0].Simple1.Id);
+				Assert.Equal("one", records[0].Simple1.Name);
+				Assert.Equal(2, records[0].Simple2.Id);
+				Assert.Equal("two", records[0].Simple2.Name);
+			}
+		}
+
+		[Fact]
+		public void ReaderDynamicHasHeaderTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+				null
+			};
+
+			var csv = new CsvReader(parserMock);
+			csv.Read();
+			var row = csv.GetRecord<dynamic>();
+
+			Assert.Equal("1", row.Id);
+			Assert.Equal("one", row.Name);
+		}
+
+		[Fact]
+		public void ReaderDynamicNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+
+			var parserMock = new ParserMock(config)
+			{
+				{ "1", "one" },
+				{ "2", "two" },
+				null,
+			};
+
+		var csv = new CsvReader(parserMock);
+			csv.Read();
+			var row = csv.GetRecord<dynamic>();
+
+			Assert.Equal("1", row.Field1);
+			Assert.Equal("one", row.Field2);
+		}
+
+		[Fact]
+		public void TryGetFieldNotInHeaderTest() // https://github.com/JoshClose/CsvHelper/issues/1981
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "piz z/a"},
+				{ "1", "one" },
+				{ "Id" },
+				{ "2" }
+			};
+			var csv = new CsvReader(parserMock);
+			csv.Read();
+			csv.ReadHeader();
+			csv.Read();
+			csv.GetField<string>("piz z/a");
+
+			csv.Read();
+			csv.ReadHeader();
+			csv.Read();
+
+			Assert.False(csv.TryGetField<string>("piz z/a", out var tmp));
+		}
+		private class Nested
+		{
+			public Simple Simple1 { get; set; }
+
+			public Simple Simple2 { get; set; }
+		}
+
+		private class Simple
+		{
+			public int? Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class SimpleMap : ClassMap<Simple>
+		{
+			public SimpleMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+			}
+		}
+
+		private class TestStructParent
+		{
+			public TestStruct Test { get; set; }
+		}
+
+		private sealed class TestStructParentMap : ClassMap<TestStructParent>
+		{
+			public TestStructParentMap()
+			{
+				References<TestStructMap>(m => m.Test);
+			}
+		}
+
+		private struct TestStruct
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class TestStructMap : ClassMap<TestStruct>
+		{
+			public TestStructMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+			}
+		}
+
+		private class OnlyFields
+		{
+			public string Name;
+		}
+
+		private sealed class OnlyFieldsMap : ClassMap<OnlyFields>
+		{
+			public OnlyFieldsMap()
+			{
+				Map(m => m.Name);
+			}
+		}
+
+		private class TestBoolean
+		{
+			public bool BoolColumn { get; set; }
+
+			public bool BoolNullableColumn { get; set; }
+
+			public string StringColumn { get; set; }
+		}
+
+		private class TestDefaultValues
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+		}
+
+		private sealed class TestDefaultValuesMap : ClassMap<TestDefaultValues>
+		{
+			public TestDefaultValuesMap()
+			{
+				Map(m => m.IntColumn).Default(-1);
+				Map(m => m.StringColumn).Default((string)null);
+			}
+		}
+
+		private class TestNullable
+		{
+			public int? IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+
+			public Guid? GuidColumn { get; set; }
+		}
+
+		[DebuggerDisplay("IntColumn = {IntColumn}, StringColumn = {StringColumn}, IgnoredColumn = {IgnoredColumn}, TypeConvertedColumn = {TypeConvertedColumn}, FirstColumn = {FirstColumn}")]
+		private class TestRecord
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+
+			public string IgnoredColumn { get; set; }
+
+			public string TypeConvertedColumn { get; set; }
+
+			public int FirstColumn { get; set; }
+
+			public Guid GuidColumn { get; set; }
+
+			public int NoMatchingFields { get; set; }
+		}
+
+		private sealed class TestRecordMap : ClassMap<TestRecord>
+		{
+			public TestRecordMap()
+			{
+				Map(m => m.IntColumn).TypeConverter<Int32Converter>();
+				Map(m => m.StringColumn).Name("String Column");
+				Map(m => m.TypeConvertedColumn).Index(1).TypeConverter<TestTypeConverter>();
+				Map(m => m.FirstColumn).Index(0);
+				Map(m => m.GuidColumn);
+				Map(m => m.NoMatchingFields);
+			}
+		}
+
+		private class TestRecordDuplicateHeaderNames
+		{
+			public string Column1 { get; set; }
+
+			public string Column2 { get; set; }
+
+			public string Column3 { get; set; }
+		}
+
+		private sealed class TestRecordDuplicateHeaderNamesMap : ClassMap<TestRecordDuplicateHeaderNames>
+		{
+			public TestRecordDuplicateHeaderNamesMap()
+			{
+				Map(m => m.Column1).Name("Column").NameIndex(0);
+				Map(m => m.Column2).Name("Column").NameIndex(1);
+				Map(m => m.Column3).Name("Column").NameIndex(2);
+			}
+		}
+
+		private class TestTypeConverter : DefaultTypeConverter
+		{
+			public override object ConvertFromString(string text, IReaderRow row, MemberMapData propertyMapData)
+			{
+				return "test";
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterBoxedTypesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterBoxedTypesTests.cs
new file mode 100644
index 0000000..2064889
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterBoxedTypesTests.cs
@@ -0,0 +1,65 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvWriterBoxedTypesTests
+	{
+		[Fact]
+		public void TypeMixedWithBoxedTypeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var recordsTyped = new List<A>
+				{
+					new A { Id = 1, Name = "one" },
+				};
+				var recordsBoxed = new List<object>
+				{
+					new A { Id = 2, Name = "two" },
+				};
+
+				csv.Context.RegisterClassMap<AMap>();
+				csv.WriteRecords(recordsTyped);
+				csv.WriteRecords(recordsBoxed);
+				writer.Flush();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("1,one");
+				expected.AppendLine("2,two");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+	}
+
+	public class A
+	{
+		public int Id { get; set; }
+
+		public string Name { get; set; }
+	}
+
+	public sealed class AMap : ClassMap<A>
+	{
+		public AMap()
+		{
+			Map(m => m.Id).Index(0);
+			Map(m => m.Name).Index(1);
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterConstructorTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterConstructorTests.cs
new file mode 100644
index 0000000..47a887b
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterConstructorTests.cs
@@ -0,0 +1,28 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvWriterConstructorTests
+	{
+		[Fact]
+		public void EnsureInternalsAreSetupWhenPassingWriterAndConfigTest()
+		{
+			using( var stream = new MemoryStream() )
+			using( var writer = new StreamWriter( stream ) )
+			{
+				var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+				using( var csv = new CsvWriter( writer, config ) )
+				{
+					Assert.Same( config, csv.Configuration );
+				}
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterFormatTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterFormatTests.cs
new file mode 100644
index 0000000..08a2c43
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterFormatTests.cs
@@ -0,0 +1,201 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvWriterFormatTests
+	{
+		[Fact]
+		public void WriteFieldTest()
+		{
+			var record = new TestRecord
+			{
+				IntColumn = 1,
+				DateColumn = new DateTime(2012, 10, 1, 12, 12, 12),
+				DecimalColumn = 150.99m,
+				FirstColumn = "first column",
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, new CultureInfo("en-US"));
+			csv.Context.RegisterClassMap<TestRecordMap>();
+
+			csv.WriteRecord(record);
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = "first column,0001,10/1/2012,$150.99\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteFieldShouldQuoteNoTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+
+			csv.WriteField("a \"b\" c", false);
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = "a \"b\" c\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteFieldShouldQuoteYesTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+
+			csv.WriteField("a \"b\" c", true);
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = "\"a \"\"b\"\" c\"\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteRecordWithReferencesTest()
+		{
+			var record = new Person
+			{
+				FirstName = "First Name",
+				LastName = "Last Name",
+				Updated = new DateTime(2012, 10, 1, 12, 12, 12, 123),
+				HomeAddress = new Address
+				{
+					Street = "Home Street",
+					City = "Home City",
+					State = "Home State",
+					Zip = 02201,
+				},
+				WorkAddress = new Address
+				{
+					Street = "Work Street",
+					City = "Work City",
+					State = "Work State",
+					Zip = 04100,
+				}
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+			csv.Context.RegisterClassMap<PersonMap>();
+
+			csv.WriteRecord(record);
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+
+			var expected = "First Name,Last Name,2012-10-01 12:12:12.123,Home Street,Home City,Home State,02201,Work Street,Work City,Work State,04100\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		private class TestRecord
+		{
+			public int IntColumn { get; set; }
+
+			public DateTime DateColumn { get; set; }
+
+			public decimal DecimalColumn { get; set; }
+
+			public string FirstColumn { get; set; }
+		}
+
+		private sealed class TestRecordMap : ClassMap<TestRecord>
+		{
+			public TestRecordMap()
+			{
+				Map(m => m.IntColumn).Name("Int Column").Index(1).TypeConverterOption.Format("0000");
+				Map(m => m.DateColumn).Index(2).TypeConverterOption.Format("d");
+				Map(m => m.DecimalColumn).Index(3).TypeConverterOption.Format("c");
+				Map(m => m.FirstColumn).Index(0);
+			}
+		}
+
+		private class Person
+		{
+			public string FirstName { get; set; }
+
+			public string LastName { get; set; }
+
+			public DateTime Updated { get; set; }
+
+			public Address HomeAddress { get; set; }
+
+			public Address WorkAddress { get; set; }
+		}
+
+		private class Address
+		{
+			public string Street { get; set; }
+
+			public string City { get; set; }
+
+			public string State { get; set; }
+
+			public int Zip { get; set; }
+		}
+
+		private sealed class PersonMap : ClassMap<Person>
+		{
+			public PersonMap()
+			{
+				Map(m => m.FirstName);
+				Map(m => m.LastName);
+				Map(m => m.Updated).TypeConverterOption.Format("yyyy-MM-dd HH:mm:ss.fff");
+				References<HomeAddressMap>(m => m.HomeAddress);
+				References<WorkAddressMap>(m => m.WorkAddress);
+			}
+		}
+
+		private sealed class HomeAddressMap : ClassMap<Address>
+		{
+			public HomeAddressMap()
+			{
+				Map(m => m.Street).Name("HomeStreet");
+				Map(m => m.City).Name("HomeCity");
+				Map(m => m.State).Name("HomeState");
+				Map(m => m.Zip).Name("HomeZip").TypeConverterOption.Format("00000");
+			}
+		}
+
+		private sealed class WorkAddressMap : ClassMap<Address>
+		{
+			public WorkAddressMap()
+			{
+				Map(m => m.Street).Name("WorkStreet");
+				Map(m => m.City).Name("WorkCity");
+				Map(m => m.State).Name("WorkState");
+				Map(m => m.Zip).Name("WorkZip").TypeConverterOption.Format("00000");
+			}
+		}
+
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterMappingTests.cs
new file mode 100644
index 0000000..82ddc1f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterMappingTests.cs
@@ -0,0 +1,350 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+
+	public class CsvWriterMappingTests
+	{
+		[Fact]
+		public void WriteMultipleNamesTest()
+		{
+			var records = new List<MultipleNamesClass>
+			{
+				new MultipleNamesClass { IntColumn = 1, StringColumn = "one" },
+				new MultipleNamesClass { IntColumn = 2, StringColumn = "two" }
+			};
+
+			string csv;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csvWriter.Context.RegisterClassMap<MultipleNamesClassMap>();
+				csvWriter.WriteRecords(records);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				csv = reader.ReadToEnd();
+			}
+
+			var expected = string.Empty;
+			expected += "int1,string1\r\n";
+			expected += "1,one\r\n";
+			expected += "2,two\r\n";
+
+			Assert.NotNull(csv);
+			Assert.Equal(expected, csv);
+		}
+
+		[Fact]
+		public void SameNameMultipleTimesTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var records = new List<SameNameMultipleTimesClass>
+				{
+					new SameNameMultipleTimesClass
+					{
+						Name1 = "1",
+						Name2 = "2",
+						Name3 = "3"
+					}
+				};
+				csv.Context.RegisterClassMap<SameNameMultipleTimesClassMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+				var expected = "ColumnName,ColumnName,ColumnName\r\n1,2,3\r\n";
+				Assert.Equal(expected, text);
+			}
+		}
+
+		[Fact]
+		public void ConvertUsingTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			string result;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<TestClass>
+				{
+					new TestClass { IntColumn = 1 }
+				};
+
+				csv.Context.RegisterClassMap<ConvertUsingMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				result = reader.ReadToEnd();
+			}
+
+			Assert.Equal("Converted1\r\n", result);
+		}
+
+		[Fact]
+		public void ConvertUsingBlockTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			string result;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<TestClass>
+				{
+					new TestClass { IntColumn = 1 }
+				};
+
+				csv.Context.RegisterClassMap<ConvertUsingBlockMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				result = reader.ReadToEnd();
+			}
+
+			Assert.Equal("Converted1\r\n", result);
+		}
+
+		[Fact]
+		public void ConvertUsingConstantTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			string result;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<TestClass>
+				{
+					new TestClass { IntColumn = 1 }
+				};
+
+				csv.Context.RegisterClassMap<ConvertUsingConstantMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				result = reader.ReadToEnd();
+			}
+
+			Assert.Equal("Constant\r\n", result);
+		}
+
+
+		[Fact]
+		public void ConvertUsingNullTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ";",
+				HasHeaderRecord = false,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<MultipleNamesClass>
+				{
+					new MultipleNamesClass { IntColumn = 1, StringColumn = "test" }
+				};
+
+				csv.Context.RegisterClassMap<ConvertUsingNullMap>();
+				csv.WriteRecords(records);
+
+				Assert.Equal(";test\r\n", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void ConvertUsingInstanceMethodTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			string result;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<TestClass>
+				{
+					new TestClass { IntColumn = 1 }
+				};
+
+				csv.Context.RegisterClassMap<ConvertUsingInstanceMethodMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				result = reader.ReadToEnd();
+			}
+
+			Assert.Equal("Converted1\r\n", result);
+		}
+
+		[Fact]
+		public void ConvertUsingStaticFunctionTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			string result;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<TestClass>
+				{
+					new TestClass { IntColumn = 1 }
+				};
+
+				csv.Context.RegisterClassMap<ConvertUsingStaticFunctionMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				result = reader.ReadToEnd();
+			}
+
+			Assert.Equal("Converted1\r\n", result);
+		}
+
+		private class SameNameMultipleTimesClass
+		{
+			public string Name1 { get; set; }
+
+			public string Name2 { get; set; }
+
+			public string Name3 { get; set; }
+		}
+
+		private sealed class SameNameMultipleTimesClassMap : ClassMap<SameNameMultipleTimesClass>
+		{
+			public SameNameMultipleTimesClassMap()
+			{
+				Map(m => m.Name1).Name("ColumnName").NameIndex(1);
+				Map(m => m.Name2).Name("ColumnName").NameIndex(2);
+				Map(m => m.Name3).Name("ColumnName").NameIndex(0);
+			}
+		}
+
+		private class MultipleNamesClass
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+		}
+
+		private sealed class MultipleNamesClassMap : ClassMap<MultipleNamesClass>
+		{
+			public MultipleNamesClassMap()
+			{
+				Map(m => m.IntColumn).Name("int1", "int2", "int3");
+				Map(m => m.StringColumn).Name("string1", "string2", "string3");
+			}
+		}
+
+		private class TestClass
+		{
+			public int IntColumn { get; set; }
+		}
+
+		private sealed class ConvertUsingMap : ClassMap<TestClass>
+		{
+			public ConvertUsingMap()
+			{
+				Map(m => m.IntColumn).Convert(args => $"Converted{args.Value.IntColumn}");
+			}
+		}
+
+		private sealed class ConvertUsingBlockMap : ClassMap<TestClass>
+		{
+			public ConvertUsingBlockMap()
+			{
+				Map(m => m.IntColumn).Convert(args =>
+				{
+					var x = "Converted";
+					x += args.Value.IntColumn;
+					return x;
+				});
+			}
+		}
+
+		private sealed class ConvertUsingConstantMap : ClassMap<TestClass>
+		{
+			public ConvertUsingConstantMap()
+			{
+				Map(m => m.IntColumn).Convert(m => "Constant");
+			}
+		}
+
+		private sealed class ConvertUsingNullMap : ClassMap<MultipleNamesClass>
+		{
+			public ConvertUsingNullMap()
+			{
+				Map(m => m.IntColumn).Convert(m => (string)null);
+				Map(m => m.StringColumn).Convert(args => args.Value.StringColumn);
+			}
+		}
+
+		private sealed class ConvertUsingInstanceMethodMap : ClassMap<TestClass>
+		{
+			public ConvertUsingInstanceMethodMap()
+			{
+				Map(m => m.IntColumn).Convert(ConvertToStringFunction);
+			}
+
+			private string ConvertToStringFunction(ConvertToStringArgs<TestClass> args)
+			{
+				return $"Converted{args.Value.IntColumn}";
+			}
+		}
+
+		private sealed class ConvertUsingStaticFunctionMap : ClassMap<TestClass>
+		{
+			public ConvertUsingStaticFunctionMap()
+			{
+				Map(m => m.IntColumn).Convert(ConvertToStringFunction);
+			}
+
+			private static string ConvertToStringFunction(ConvertToStringArgs<TestClass> args)
+			{
+				return $"Converted{args.Value.IntColumn}";
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterReferenceMappingPrefixTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterReferenceMappingPrefixTests.cs
new file mode 100644
index 0000000..45a5243
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterReferenceMappingPrefixTests.cs
@@ -0,0 +1,106 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvWriterReferenceMappingPrefixTests
+	{
+		[Fact]
+		public void ReferencesWithPrefixTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<AMap>();
+
+				var list = new List<A>();
+				for (var i = 0; i < 4; i++)
+				{
+					var row = i + 1;
+					list.Add(new A
+					{
+						Id = "a" + row,
+						B = new B
+						{
+							Id = "b" + row,
+							C = new C
+							{
+								Id = "c" + row
+							}
+						}
+					});
+				}
+
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,BPrefix_Id,C.CId");
+				expected.AppendLine("a1,b1,c1");
+				expected.AppendLine("a2,b2,c2");
+				expected.AppendLine("a3,b3,c3");
+				expected.AppendLine("a4,b4,c4");
+				Assert.Equal(expected.ToString(), data);
+			}
+		}
+
+		private class A
+		{
+			public string Id { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public string Id { get; set; }
+
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string Id { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				Map(m => m.Id);
+				References<BMap>(m => m.B).Prefix("BPrefix_", false);
+			}
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+			public BMap()
+			{
+				Map(m => m.Id);
+				References<CMap>(m => m.C).Prefix();
+			}
+		}
+
+		private sealed class CMap : ClassMap<C>
+		{
+			public CMap()
+			{
+				Map(m => m.Id).Name("CId");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterReferenceMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterReferenceMappingTests.cs
new file mode 100644
index 0000000..4a0053f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterReferenceMappingTests.cs
@@ -0,0 +1,156 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvWriterReferenceMappingTests
+	{
+		[Fact]
+		public void NestedReferencesTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<AMap>();
+
+				var list = new List<A>();
+				for (var i = 0; i < 4; i++)
+				{
+					var row = i + 1;
+					list.Add(
+							 new A
+							 {
+								 Id = "a" + row,
+								 B = new B
+								 {
+									 Id = "b" + row,
+									 C = new C
+									 {
+										 Id = "c" + row,
+										 D = new D
+										 {
+											 Id = "d" + row
+										 }
+									 }
+								 }
+							 });
+				};
+
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("AId,BId,CId,DId");
+				expected.AppendLine("a1,b1,c1,d1");
+				expected.AppendLine("a2,b2,c2,d2");
+				expected.AppendLine("a3,b3,c3,d3");
+				expected.AppendLine("a4,b4,c4,d4");
+				Assert.Equal(expected.ToString(), data);
+			}
+		}
+
+		[Fact]
+		public void NullReferenceTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<AMap>();
+
+				var list = new List<A>
+				{
+					new A
+					{
+						Id = "1",
+					}
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("AId,BId,CId,DId");
+				expected.AppendLine("1,,,");
+				Assert.Equal(expected.ToString(), data);
+			}
+		}
+
+		private class A
+		{
+			public string Id { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public string Id { get; set; }
+
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string Id { get; set; }
+
+			public D D { get; set; }
+		}
+
+		private class D
+		{
+			public string Id { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				Map(m => m.Id).Name("AId");
+				References<BMap>(m => m.B);
+			}
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+			public BMap()
+			{
+				Map(m => m.Id).Name("BId");
+				References<CMap>(m => m.C);
+			}
+		}
+
+		private sealed class CMap : ClassMap<C>
+		{
+			public CMap()
+			{
+				Map(m => m.Id).Name("CId");
+				References<DMap>(m => m.D);
+			}
+		}
+
+		private sealed class DMap : ClassMap<D>
+		{
+			public DMap()
+			{
+				Map(m => m.Id).Name("DId");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterSubClassingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterSubClassingTests.cs
new file mode 100644
index 0000000..fcd4241
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterSubClassingTests.cs
@@ -0,0 +1,42 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvWriterSubClassingTests
+	{
+		[Fact]
+		public void WriteRecordTest()
+		{
+			var data = new List<Test>
+			{
+				new Test { Id = 1, Name = "one" },
+				new Test { Id = 2, Name = "two" }
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream);
+			var csvWriter = new MyCsvWriter(writer);
+
+			csvWriter.WriteRecords(data);
+		}
+
+		private class MyCsvWriter : CsvWriter
+		{
+			public MyCsvWriter(TextWriter writer) : base(writer, CultureInfo.InvariantCulture) { }
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs
new file mode 100644
index 0000000..2309ef7
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/CsvWriterTests.cs
@@ -0,0 +1,1030 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Int32Converter = CsvHelper.TypeConversion.Int32Converter;
+using System.Dynamic;
+using Xunit;
+using System.Threading;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvWriterTests
+	{
+		public CsvWriterTests()
+		{
+			Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
+		}
+
+		[Fact]
+		public void WriteFieldTest()
+		{
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+
+			var date = DateTime.Now.ToString();
+			var guid = Guid.NewGuid().ToString();
+			csv.WriteField("one");
+			csv.WriteField("one, two");
+			csv.WriteField("one \"two\" three");
+			csv.WriteField(" one ");
+			csv.WriteField(date);
+			csv.WriteField((short)1);
+			csv.WriteField(2);
+			csv.WriteField((long)3);
+			csv.WriteField((float)4);
+			csv.WriteField((double)5);
+			csv.WriteField(guid);
+			csv.NextRecord();
+
+			var reader = new StreamReader(stream);
+			stream.Position = 0;
+			var data = reader.ReadToEnd();
+
+			Assert.Equal("one,\"one, two\",\"one \"\"two\"\" three\",\" one \"," + date + ",1,2,3,4,5," + guid + "\r\n", data);
+		}
+
+		[Fact]
+		public void WriteRecordTest()
+		{
+			var record = new TestRecord
+			{
+				IntColumn = 1,
+				StringColumn = "string column",
+				IgnoredColumn = "ignored column",
+				FirstColumn = "first column",
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+
+			csv.WriteRecord(record);
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = "first column,1,string column,test\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteRecordNoIndexesTest()
+		{
+			var record = new TestRecordNoIndexes
+			{
+				IntColumn = 1,
+				StringColumn = "string column",
+				IgnoredColumn = "ignored column",
+				FirstColumn = "first column",
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream) { AutoFlush = true })
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<TestRecordNoIndexesMap>();
+
+				csv.WriteRecord(record);
+				csv.NextRecord();
+
+				stream.Position = 0;
+				var reader = new StreamReader(stream);
+				var csvFile = reader.ReadToEnd();
+
+				var expected = "1,string column,first column,test\r\n";
+
+				Assert.Equal(expected, csvFile);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordsTest()
+		{
+			var records = new List<TestRecord>
+			{
+				new TestRecord
+				{
+					IntColumn = 1,
+					StringColumn = "string column",
+					IgnoredColumn = "ignored column",
+					FirstColumn = "first column",
+				},
+				new TestRecord
+				{
+					IntColumn = 2,
+					StringColumn = "string column 2",
+					IgnoredColumn = "ignored column 2",
+					FirstColumn = "first column 2",
+				},
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+
+			csv.WriteRecords(records);
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n";
+			expected += "first column,1,string column,test\r\n";
+			expected += "first column 2,2,string column 2,test\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteEmptyArrayTest()
+		{
+			var records = new TestRecord[] { };
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+
+			csv.WriteRecords(records);
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteRecordsCalledWithTwoParametersTest()
+		{
+			var records = new List<object>
+			{
+				new TestRecord
+				{
+					IntColumn = 1,
+					StringColumn = "string column",
+					IgnoredColumn = "ignored column",
+					FirstColumn = "first column",
+				},
+				new TestRecord
+				{
+					IntColumn = 2,
+					StringColumn = "string column 2",
+					IgnoredColumn = "ignored column 2",
+					FirstColumn = "first column 2",
+				},
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+
+			csv.WriteRecords(records);
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n";
+			expected += "first column,1,string column,test\r\n";
+			expected += "first column 2,2,string column 2,test\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteRecordNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, config);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+			csv.WriteRecord(new TestRecord());
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+
+			Assert.Equal(",0,,test\r\n", csvFile);
+		}
+
+		[Fact]
+		public void WriteRecordWithNullRecordTest()
+		{
+			var record = new TestRecord
+			{
+				IntColumn = 1,
+				StringColumn = "string column",
+				IgnoredColumn = "ignored column",
+				FirstColumn = "first column",
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+			csv.Context.RegisterClassMap<TestRecordMap>();
+
+			csv.WriteRecord(record);
+			csv.NextRecord();
+			csv.WriteRecord((TestRecord)null);
+			csv.NextRecord();
+			csv.WriteRecord(record);
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+			var expected = new TestStringBuilder(csv.Configuration.NewLine);
+			expected.AppendLine("first column,1,string column,test");
+			expected.AppendLine(",,,");
+			expected.AppendLine("first column,1,string column,test");
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteRecordWithReferencesTest()
+		{
+			var record = new Person
+			{
+				FirstName = "First Name",
+				LastName = "Last Name",
+				HomeAddress = new Address
+				{
+					Street = "Home Street",
+					City = "Home City",
+					State = "Home State",
+					Zip = "Home Zip",
+				},
+				WorkAddress = new Address
+				{
+					Street = "Work Street",
+					City = "Work City",
+					State = "Work State",
+					Zip = "Work Zip",
+				}
+			};
+
+			var stream = new MemoryStream();
+			var writer = new StreamWriter(stream) { AutoFlush = true };
+			var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
+			csv.Context.RegisterClassMap<PersonMap>();
+
+			csv.WriteRecord(record);
+			csv.NextRecord();
+
+			stream.Position = 0;
+			var reader = new StreamReader(stream);
+			var csvFile = reader.ReadToEnd();
+
+			var expected = "First Name,Last Name,Home Street,Home City,Home State,Home Zip,Work Street,Work City,Work State,Work Zip\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		[Fact]
+		public void WriteRecordsAllFieldsQuotedTest()
+		{
+			var record = new TestRecord
+			{
+				IntColumn = 1,
+				StringColumn = "string column",
+				IgnoredColumn = "ignored column",
+				FirstColumn = "first column",
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = _ => true,
+			};
+
+			string csv;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				csvWriter.Context.RegisterClassMap<TestRecordMap>();
+				csvWriter.WriteRecord(record);
+				csvWriter.NextRecord();
+
+				writer.Flush();
+				stream.Position = 0;
+
+				csv = reader.ReadToEnd();
+			}
+
+			var expected = "\"first column\",\"1\",\"string column\",\"test\"\r\n";
+
+			Assert.Equal(expected, csv);
+		}
+
+		[Fact]
+		public void WriteRecordsNoFieldsQuotedTest()
+		{
+			var record = new TestRecord
+			{
+				IntColumn = 1,
+				StringColumn = "string \" column",
+				IgnoredColumn = "ignored column",
+				FirstColumn = "first, column",
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = _ => false,
+			};
+			string csv;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				csvWriter.Context.RegisterClassMap<TestRecordMap>();
+				csvWriter.WriteRecord(record);
+				csvWriter.NextRecord();
+
+				writer.Flush();
+				stream.Position = 0;
+
+				csv = reader.ReadToEnd();
+			}
+
+			var expected = "first, column,1,string \" column,test\r\n";
+
+			Assert.Equal(expected, csv);
+		}
+
+		[Fact]
+		public void WriteHeaderTest()
+		{
+			string csv;
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csvWriter.Context.RegisterClassMap<TestRecordMap>();
+				csvWriter.WriteHeader(typeof(TestRecord));
+				csvWriter.NextRecord();
+
+				writer.Flush();
+				stream.Position = 0;
+
+				csv = reader.ReadToEnd();
+			}
+
+			const string Expected = "FirstColumn,Int Column,StringColumn,TypeConvertedColumn\r\n";
+			Assert.Equal(Expected, csv);
+		}
+
+		[Fact]
+		public void WriteRecordWithDelimiterInFieldTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var record = new TestSinglePropertyRecord
+				{
+					Name = "one,two"
+				};
+				csv.WriteRecord(record);
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+
+				Assert.Equal("\"one,two\"\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordWithQuoteInFieldTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var record = new TestSinglePropertyRecord
+				{
+					Name = "one\"two"
+				};
+				csv.WriteRecord(record);
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+
+				Assert.Equal("\"one\"\"two\"\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordWithQuoteAllFieldsOnAndDelimiterInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = _ => true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var record = new TestSinglePropertyRecord
+				{
+					Name = "one,two"
+				};
+				csv.WriteRecord(record);
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+
+				Assert.Equal("\"one,two\"\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordWithQuoteAllFieldsOnAndQuoteInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = _ => true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var record = new TestSinglePropertyRecord
+				{
+					Name = "one\"two"
+				};
+				csv.WriteRecord(record);
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+
+				Assert.Equal("\"one\"\"two\"\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordsWithInvariantCultureTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<TestRecordMap>();
+
+				var record = new TestRecord
+				{
+					IntColumn = 1,
+					FirstColumn = "first column",
+					IgnoredColumn = "ignored column",
+					StringColumn = "string column",
+				};
+
+				csv.WriteRecord(record);
+				writer.Flush();
+				stream.Position = 0;
+
+				var csvString = reader.ReadToEnd();
+			}
+		}
+
+		[Fact]
+		public void WriteNoGetterTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<TestPrivateGet>
+				{
+					new TestPrivateGet
+					{
+						Id = 1,
+						Name = "one"
+					}
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id");
+				expected.AppendLine("1");
+
+				Assert.Equal(expected.ToString(), data);
+			}
+		}
+
+		[Fact]
+		public void WriteDynamicTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecord(new { Id = 1, Name = "one" });
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+				Assert.Equal("1,one\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WritePrimitivesRecordsHasHeaderTrueTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<int> { 1, 2, 3 };
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+
+				Assert.Equal("1\r\n2\r\n3\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WritePrimitivesRecordsHasHeaderFalseTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<int> { 1, 2, 3 };
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+
+				Assert.Equal("1\r\n2\r\n3\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WriteStructRecordsTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<TestStruct>
+				{
+					new TestStruct { Id = 1, Name = "one" },
+					new TestStruct { Id = 2, Name = "two" },
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+
+				Assert.Equal("Id,Name\r\n1,one\r\n2,two\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WriteStructReferenceRecordsTest()
+		{
+			var list = new List<TestStructParent>
+			{
+				new TestStructParent
+				{
+					Test = new TestStruct
+					{
+						Id = 1,
+						Name = "one",
+					},
+				},
+			};
+
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<TestStructParentMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+				Assert.Equal("Id,Name\r\n1,one\r\n", data);
+			}
+		}
+
+		[Fact]
+		public void WriteNestedHeadersTest()
+		{
+			var list = new List<Person>
+			{
+				new Person
+				{
+					FirstName = "first",
+					LastName = "last",
+					HomeAddress = new Address
+					{
+						City = "home city",
+						State = "home state",
+						Street = "home street",
+						Zip = "home zip",
+					},
+					WorkAddress = new Address
+					{
+						City = "work city",
+						State = "work state",
+						Street = "work street",
+						Zip = "work zip",
+					},
+				},
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ReferenceHeaderPrefix = args => $"{args.MemberName}."
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("FirstName,LastName,HomeAddress.Street,HomeAddress.City,HomeAddress.State,HomeAddress.Zip,WorkAddress.Street,WorkAddress.City,WorkAddress.State,WorkAddress.Zip");
+				expected.AppendLine("first,last,home street,home city,home state,home zip,work street,work city,work state,work zip");
+				Assert.Equal(expected.ToString(), text);
+			}
+		}
+
+		[Fact]
+		public void WriteEmptyListTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<TestRecord>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+				Assert.False(string.IsNullOrWhiteSpace(data));
+			}
+		}
+
+		[Fact]
+		public void ClassWithStaticAutoMappingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				TestWithStatic.Name = "one";
+				var records = new List<TestWithStatic>
+				{
+					new TestWithStatic
+					{
+						Id = 1
+					},
+				};
+
+				csv.WriteRecords(records);
+			}
+		}
+
+		[Fact]
+		public void ClassWithStaticUsingMappingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<TestWithStaticMap>();
+
+				TestWithStatic.Name = "one";
+				var records = new List<TestWithStatic>
+				{
+					new TestWithStatic
+					{
+						Id = 1
+					},
+				};
+
+				csv.WriteRecords(records);
+			}
+		}
+
+		[Fact]
+		public void WriteDynamicListTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<dynamic>();
+				dynamic record = new { Id = 1, Name = "one" };
+				list.Add(record);
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+				Assert.Equal("Id,Name\r\n1,one\r\n", text);
+			}
+		}
+
+		[Fact]
+		public void WriteExpandoListTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<dynamic>();
+				dynamic record = new ExpandoObject();
+				record.Id = 1;
+				record.Name = "one";
+				list.Add(record);
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+				Assert.Equal("Id,Name\r\n1,one\r\n", text);
+			}
+		}
+
+
+		[Fact]
+		public void WriteInternalConstructorClassTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(new List<GetOnly>());
+				writer.Flush();
+				stream.Position = 0;
+
+				var text = reader.ReadToEnd();
+				Assert.Equal("One\r\n", text);
+			}
+		}
+
+		private class GetOnly
+		{
+			internal GetOnly(string someParam)
+			{
+			}
+
+			public int One { get; }
+		}
+
+		private class TestWithStatic
+		{
+			public int Id { get; set; }
+
+			public static string Name { get; set; }
+		}
+
+		private sealed class TestWithStaticMap : ClassMap<TestWithStatic>
+		{
+			public TestWithStaticMap()
+			{
+				Map(m => m.Id);
+			}
+		}
+
+		private class TestStructParent
+		{
+			public TestStruct Test { get; set; }
+		}
+
+		private sealed class TestStructParentMap : ClassMap<TestStructParent>
+		{
+			public TestStructParentMap()
+			{
+				References<TestStructMap>(m => m.Test);
+			}
+		}
+
+		private struct TestStruct
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class TestStructMap : ClassMap<TestStruct>
+		{
+			public TestStructMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+			}
+		}
+
+		private class TestPrivateGet
+		{
+			public int Id { get; set; }
+
+			public string Name { private get; set; }
+		}
+
+		private class TestSinglePropertyRecord
+		{
+			public string Name { get; set; }
+		}
+
+		private class TestRecord
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+
+			public string IgnoredColumn { get; set; }
+
+			public string FirstColumn { get; set; }
+
+			public string TypeConvertedColumn { get; set; }
+		}
+
+		private sealed class TestRecordMap : ClassMap<TestRecord>
+		{
+			public TestRecordMap()
+			{
+				Map(m => m.IntColumn).Name("Int Column").Index(1).TypeConverter<Int32Converter>();
+				Map(m => m.StringColumn);
+				Map(m => m.FirstColumn).Index(0);
+				Map(m => m.TypeConvertedColumn).TypeConverter<TestTypeConverter>();
+			}
+		}
+
+		private class TestRecordNoIndexes
+		{
+			public int IntColumn { get; set; }
+
+			public string StringColumn { get; set; }
+
+			public string IgnoredColumn { get; set; }
+
+			public string FirstColumn { get; set; }
+
+			public string TypeConvertedColumn { get; set; }
+		}
+
+		private sealed class TestRecordNoIndexesMap : ClassMap<TestRecordNoIndexes>
+		{
+			public TestRecordNoIndexesMap()
+			{
+				Map(m => m.IntColumn).Name("Int Column").TypeConverter<Int32Converter>();
+				Map(m => m.StringColumn);
+				Map(m => m.FirstColumn);
+				Map(m => m.TypeConvertedColumn).TypeConverter<TestTypeConverter>();
+			}
+		}
+
+		private class TestTypeConverter : ITypeConverter
+		{
+			public string ConvertToString(object value, IWriterRow row, MemberMapData propertyMapData)
+			{
+				return "test";
+			}
+
+			public object ConvertFromString(string text, IReaderRow row, MemberMapData propertyMapData)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool CanConvertFrom(Type type)
+			{
+				throw new NotImplementedException();
+			}
+
+			public bool CanConvertTo(Type type)
+			{
+				return true;
+			}
+		}
+
+		private class Person
+		{
+			public string FirstName { get; set; }
+
+			public string LastName { get; set; }
+
+			public Address HomeAddress { get; set; }
+
+			public Address WorkAddress { get; set; }
+		}
+
+		private class Address
+		{
+			public string Street { get; set; }
+
+			public string City { get; set; }
+
+			public string State { get; set; }
+
+			public string Zip { get; set; }
+		}
+
+		private sealed class PersonMap : ClassMap<Person>
+		{
+			public PersonMap()
+			{
+				Map(m => m.FirstName);
+				Map(m => m.LastName);
+				References<HomeAddressMap>(m => m.HomeAddress);
+				References<WorkAddressMap>(m => m.WorkAddress);
+			}
+		}
+
+		private sealed class HomeAddressMap : ClassMap<Address>
+		{
+			public HomeAddressMap()
+			{
+				Map(m => m.Street).Name("HomeStreet");
+				Map(m => m.City).Name("HomeCity");
+				Map(m => m.State).Name("HomeState");
+				Map(m => m.Zip).Name("HomeZip");
+			}
+		}
+
+		private sealed class WorkAddressMap : ClassMap<Address>
+		{
+			public WorkAddressMap()
+			{
+				Map(m => m.Street).Name("WorkStreet");
+				Map(m => m.City).Name("WorkCity");
+				Map(m => m.State).Name("WorkState");
+				Map(m => m.Zip).Name("WorkZip");
+			}
+		}
+
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Culture/TypeConverterOptionsFactoryTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Culture/TypeConverterOptionsFactoryTests.cs
new file mode 100644
index 0000000..05997bc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Culture/TypeConverterOptionsFactoryTests.cs
@@ -0,0 +1,229 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.Culture
+{
+	
+	public class TypeConverterOptionsFactoryTests
+	{
+		[Fact]
+		public void AddGetRemoveTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var customOptions = new TypeConverterOptions
+			{
+				Formats = new string[] { "custom" },
+			};
+			context.TypeConverterOptionsCache.AddOptions<string>(customOptions);
+			var options = context.TypeConverterOptionsCache.GetOptions<string>();
+
+			Assert.Equal(customOptions.Formats, options.Formats);
+
+			context.TypeConverterOptionsCache.RemoveOptions<string>();
+
+			options = context.TypeConverterOptionsCache.GetOptions<string>();
+
+			Assert.NotEqual(customOptions.Formats, options.Formats);
+		}
+
+		[Fact]
+		public void GetFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("\"1,234\",\"5,678\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				var options = new TypeConverterOptions { NumberStyles = NumberStyles.AllowThousands };
+				csvReader.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvReader.Read();
+				Assert.Equal(1234, csvReader.GetField<int>(0));
+				Assert.Equal(5678, csvReader.GetField(typeof(int), 1));
+			}
+		}
+
+		[Fact]
+		public void GetFieldSwitchCulturesTest()
+		{
+			GetFieldForCultureTest("\"1234,32\",\"5678,44\"", "fr-FR", 1234.32M, 5678.44M);
+			GetFieldForCultureTest("\"9876.54\",\"3210.98\"", "en-GB", 9876.54M, 3210.98M);
+			GetFieldForCultureTest("\"4455,6677\",\"9988,77\"", "el-GR", 4455.6677M, 9988.77M);
+		}
+
+		private static void GetFieldForCultureTest(string csvText, string culture, decimal expected1, decimal expected2)
+		{
+			var config = new CsvConfiguration(new CultureInfo(culture))
+			{
+				HasHeaderRecord = false,
+				Delimiter = ",",
+			};
+			using (var reader = new StringReader(csvText))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				csvReader.Read();
+				Assert.Equal(expected1, csvReader.GetField<decimal>(0));
+				Assert.Equal(expected2, csvReader.GetField(typeof(decimal), 1));
+			}
+		}
+
+		[Fact]
+		public void GetRecordsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("\"1,234\",\"5,678\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				var options = new TypeConverterOptions { NumberStyles = NumberStyles.AllowThousands };
+				csvReader.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvReader.GetRecords<Test>().ToList();
+			}
+		}
+
+		[Fact]
+		public void GetRecordsAppliedWhenMappedTest()
+		{
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("\"1,234\",\"$5,678\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				var options = new TypeConverterOptions { NumberStyles = NumberStyles.AllowThousands };
+				csvReader.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvReader.Context.RegisterClassMap<TestMap>();
+				csvReader.GetRecords<Test>().ToList();
+			}
+		}
+
+		[Fact]
+		public void WriteFieldTest()
+		{
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				var options = new TypeConverterOptions { Formats = new string[] { "c" } };
+				csvWriter.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvWriter.WriteField(1234);
+				csvWriter.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+				var record = reader.ReadToEnd();
+
+				Assert.Equal("\"$1,234.00\"\r\n", record);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordsTest()
+		{
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Number = 1234, NumberOverridenInMap = 5678 },
+				};
+				var options = new TypeConverterOptions { Formats = new string[] { "c" } };
+				csvWriter.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvWriter.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+				var record = reader.ReadToEnd();
+
+				Assert.Equal("\"$1,234.00\",\"$5,678.00\"\r\n", record);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordsAppliedWhenMappedTest()
+		{
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Number = 1234, NumberOverridenInMap = 5678 },
+				};
+				var options = new TypeConverterOptions { Formats = new string[] { "c" } };
+				csvWriter.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvWriter.Context.RegisterClassMap<TestMap>();
+				csvWriter.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+				var record = reader.ReadToEnd();
+
+				Assert.Equal("\"$1,234.00\",\"5,678.00\"\r\n", record);
+			}
+		}
+
+		private class Test
+		{
+			public int Number { get; set; }
+
+			public int NumberOverridenInMap { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Number);
+				Map(m => m.NumberOverridenInMap)
+					.TypeConverterOption.NumberStyles(NumberStyles.AllowThousands | NumberStyles.AllowCurrencySymbol)
+					.TypeConverterOption.Format("N2");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DataTableTests/CsvDataReaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DataTableTests/CsvDataReaderTests.cs
new file mode 100644
index 0000000..726862b
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DataTableTests/CsvDataReaderTests.cs
@@ -0,0 +1,509 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.DataTableTests
+{
+	
+	public class CsvDataReaderTests
+	{
+		[Fact]
+		public void GetValuesTest()
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Boolean,Byte,Bytes,Char,Chars,DateTime,Decimal,Double,Float,Guid,Short,Int,Long,Null");
+			s.AppendLine("true,1,0x0102,a,ab,1/1/2019,1.23,4.56,7.89,eca0c8c6-9a2a-4e6c-8599-3561abda13f1,1,2,3,null");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("null");
+				var dataReader = new CsvDataReader(csv);
+				dataReader.Read();
+
+				Assert.True(dataReader.GetBoolean(0));
+				Assert.Equal(1, dataReader.GetByte(1));
+
+				byte[] byteBuffer = new byte[2];
+				dataReader.GetBytes(2, 0, byteBuffer, 0, byteBuffer.Length);
+				Assert.Equal(0x1, byteBuffer[0]);
+				Assert.Equal(0x2, byteBuffer[1]);
+
+				Assert.Equal('a', dataReader.GetChar(3));
+
+				char[] charBuffer = new char[2];
+				dataReader.GetChars(4, 0, charBuffer, 0, charBuffer.Length);
+				Assert.Equal('a', charBuffer[0]);
+				Assert.Equal('b', charBuffer[1]);
+
+				Assert.Throws<NotSupportedException>(() => dataReader.GetData(0));
+				Assert.Equal(DateTime.Parse("1/1/2019"), dataReader.GetDateTime(5));
+				Assert.Equal(typeof(string).Name, dataReader.GetDataTypeName(0));
+				Assert.Equal(1.23m, dataReader.GetDecimal(6));
+				Assert.Equal(4.56d, dataReader.GetDouble(7));
+				Assert.Equal(typeof(string), dataReader.GetFieldType(0));
+				Assert.Equal(7.89f, dataReader.GetFloat(8));
+				Assert.Equal(Guid.Parse("eca0c8c6-9a2a-4e6c-8599-3561abda13f1"), dataReader.GetGuid(9));
+				Assert.Equal(1, dataReader.GetInt16(10));
+				Assert.Equal(2, dataReader.GetInt32(11));
+				Assert.Equal(3, dataReader.GetInt64(12));
+				Assert.Equal("Boolean", dataReader.GetName(0));
+				Assert.Equal(0, dataReader.GetOrdinal("Boolean"));
+
+				Assert.Equal("true", dataReader.GetString(0));
+				Assert.Equal("true", dataReader.GetValue(0));
+
+				var objectBuffer = new object[14];
+				dataReader.GetValues(objectBuffer);
+				Assert.Equal("true", objectBuffer[0]);
+				Assert.Equal(DBNull.Value, objectBuffer[13]);
+				Assert.True(dataReader.IsDBNull(13));
+			}
+		}
+
+		[Fact]
+		public void GetSchemaTableTest()
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Id,Name");
+			s.AppendLine("1,one");
+			s.AppendLine("2,two");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var dataReader = new CsvDataReader(csv);
+
+				var schemaTable = dataReader.GetSchemaTable();
+				Assert.Equal(25, schemaTable.Columns.Count);
+				Assert.Equal(2, schemaTable.Rows.Count);
+			}
+		}
+
+		[Fact]
+		public void DataTableLoadTest()
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Id,Name");
+			s.AppendLine("1,one");
+			s.AppendLine("2,two");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var dataReader = new CsvDataReader(csv);
+
+				var dataTable = new DataTable();
+				dataTable.Columns.Add("Id", typeof(int));
+				dataTable.Columns.Add("Name", typeof(string));
+
+				dataTable.Load(dataReader);
+
+				Assert.Equal(2, dataTable.Rows.Count);
+				Assert.Equal(1, dataTable.Rows[0]["Id"]);
+				Assert.Equal("one", dataTable.Rows[0]["Name"]);
+				Assert.Equal(2, dataTable.Rows[1]["Id"]);
+				Assert.Equal("two", dataTable.Rows[1]["Name"]);
+			}
+		}
+
+		[Fact]
+		public void DataTableLoadHeaderAndRowsHaveDifferentLengthTest()
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Id,Name");
+			s.AppendLine("1,one,a");
+			s.AppendLine("2,two,b");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var dataReader = new CsvDataReader(csv);
+
+				var dataTable = new DataTable();
+				dataTable.Columns.Add("Id", typeof(int));
+				dataTable.Columns.Add("Name", typeof(string));
+
+				dataTable.Load(dataReader);
+
+				Assert.Equal(2, dataTable.Rows.Count);
+				Assert.Equal(1, dataTable.Rows[0]["Id"]);
+				Assert.Equal("one", dataTable.Rows[0]["Name"]);
+				Assert.Equal(2, dataTable.Rows[1]["Id"]);
+				Assert.Equal("two", dataTable.Rows[1]["Name"]);
+			}
+		}
+
+		[Fact]
+		public void DataTableLoadNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var s = new StringBuilder();
+			s.AppendLine("1,one");
+			s.AppendLine("2,two");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var dataReader = new CsvDataReader(csv);
+
+				var dataTable = new DataTable();
+
+				dataTable.Load(dataReader);
+
+				Assert.Equal(0, dataTable.Rows.Count);
+			}
+		}
+
+		[Fact]
+		public void ReadWithNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var s = new StringBuilder();
+			s.AppendLine("1,one");
+			s.AppendLine("2,two");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var dataReader = new CsvDataReader(csv);
+
+				dataReader.Read();
+				Assert.Equal(1, dataReader.GetInt32(0));
+				Assert.Equal("one", dataReader.GetString(1));
+
+				dataReader.Read();
+				Assert.Equal(2, dataReader.GetInt32(0));
+				Assert.Equal("two", dataReader.GetString(1));
+			}
+		}
+
+		[Fact]
+		public void IsNullTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var s = new StringBuilder();
+			s.AppendLine(",null");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("null");
+
+				var dataReader = new CsvDataReader(csv);
+				Assert.False(dataReader.IsDBNull(0));
+				Assert.True(dataReader.IsDBNull(1));
+			}
+		}
+
+		[Fact]
+		public void DbNullTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var s = new StringBuilder();
+			s.AppendLine(",null");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("null");
+
+				var dataReader = new CsvDataReader(csv);
+				Assert.Equal(string.Empty, dataReader.GetValue(0));
+				Assert.Equal(DBNull.Value, dataReader.GetValue(1));
+
+				var values = new object[2];
+				dataReader.GetValues(values);
+				Assert.Equal(string.Empty, values[0]);
+				Assert.Equal(DBNull.Value, values[1]);
+			}
+		}
+
+		[Fact]
+		public void GetOrdinalCaseInsensitiveTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				null,
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				using (var dr = new CsvDataReader(csv))
+				{
+					var ordinal = dr.GetOrdinal("name");
+
+					Assert.Equal(1, ordinal);
+				}
+			}
+		}
+
+		[Fact]
+		public void GetOrdinalMissingTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				null,
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				using (var dr = new CsvDataReader(csv))
+				{
+					Assert.Throws<IndexOutOfRangeException>(() =>
+					{
+						dr.GetOrdinal("Foo");
+					});
+				}
+			}
+		}
+
+		[Fact]
+		public void DataTableLoadEmptyTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var reader = new StringReader(string.Empty))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var dataReader = new CsvDataReader(csv);
+				Assert.Equal(0, dataReader.FieldCount);
+			}
+		}
+
+		[Fact]
+		public void DataTableNullableValueTypeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "Id", "Name", "DateTime" },
+				{ "1", "one", DateTime.Now.ToString() },
+			};
+			using (var csv = new CsvReader(parser))
+			using (var dr = new CsvDataReader(csv))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("");
+
+				var table = new DataTable();
+				table.Columns.Add("Id", typeof(int));
+				table.Columns.Add("Name", typeof(string));
+				var column = table.Columns.Add("DateTime", typeof(DateTime));
+				column.AllowDBNull = true;
+
+				table.Load(dr);
+			}
+		}
+
+		[Theory]
+		[InlineData(true)]
+		[InlineData(false)]
+		public void GetDataTypeNameTest(bool useDefaultSchema)
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Boolean,Byte,Int,Decimal,Double,DateTime,String,Guid");
+			s.AppendLine("true,1,2,4.56,7.89,2/17/2022,foo,eca0c8c6-9a2a-4e6c-8599-3561abda13f1");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = true,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				if (useDefaultSchema)
+				{
+					var dataReader = new CsvDataReader(csv);
+					dataReader.Read();
+					for (var i = 0; i < dataReader.FieldCount; ++i)
+					{
+						Assert.Equal(typeof(string).Name, dataReader.GetDataTypeName(i));
+					}
+				}
+				else
+				{
+					var expectedDataTypeNames = new[]
+					{
+						typeof(bool).Name,
+						typeof(byte).Name,
+						typeof(int).Name,
+						typeof(decimal).Name,
+						typeof(double).Name,
+						typeof(DateTime).Name,
+						typeof(string).Name,
+						typeof(Guid).Name,
+					};
+					var dataReader = new CsvDataReader(csv, GetOverridingSchemaTable());
+					for (var i = 0; i < expectedDataTypeNames.Length; ++i)
+					{
+						Assert.Equal(expectedDataTypeNames[i], dataReader.GetDataTypeName(i));
+					}
+				}
+			}
+		}
+
+		[Fact]
+		public void GetDataTypeNameThrowsArgumentOutOfRangeExceptionWhenGivenAnEmptySchema()
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Boolean,Byte,Int,Decimal,Double,DateTime,String,Guid");
+			s.AppendLine("true,1,2,4.56,7.89,2/17/2022,foo,eca0c8c6-9a2a-4e6c-8599-3561abda13f1");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = true,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var badSchema = new DataTable();
+				var dataReader = new CsvDataReader(csv, badSchema);
+				dataReader.Read();
+				Assert.Throws<IndexOutOfRangeException>(() => dataReader.GetDataTypeName(0));
+			}
+		}
+
+		[Fact]
+		public void GetDataTypeNameThrowsArgumentExceptionWhenGivenASchemaMissingDataType()
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Boolean,Byte,Int,Decimal,Double,DateTime,String,Guid");
+			s.AppendLine("true,1,2,4.56,7.89,2/17/2022,foo,eca0c8c6-9a2a-4e6c-8599-3561abda13f1");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = true,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var badSchema = new DataTable();
+				badSchema.Rows.Add(badSchema.NewRow());
+				var dataReader = new CsvDataReader(csv, badSchema);
+				dataReader.Read();
+				Assert.Throws<ArgumentException>(() => dataReader.GetDataTypeName(0));
+			}
+		}
+
+		[Fact]
+		public void GetDataTypeNameThrowsInvalidCastExceptionWhenGivenASchemaWithAnUnexpectedDataTypeValue()
+		{
+			var s = new StringBuilder();
+			s.AppendLine("Boolean,Byte,Int,Decimal,Double,DateTime,String,Guid");
+			s.AppendLine("true,1,2,4.56,7.89,2/17/2022,foo,eca0c8c6-9a2a-4e6c-8599-3561abda13f1");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = true,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var badSchema = new DataTable();
+				badSchema.Columns.Add("DataType");
+				var row = badSchema.NewRow();
+				row["DataType"] = "foo";
+				badSchema.Rows.Add(row);
+				var dataReader = new CsvDataReader(csv, badSchema);
+				dataReader.Read();
+				Assert.Throws<InvalidOperationException>(() => dataReader.GetDataTypeName(0));
+			}
+		}
+
+		private DataTable GetOverridingSchemaTable()
+		{
+			var columnTypeMapping = new Tuple<string, Type, DbType>[]
+			{
+				new Tuple<string, Type, DbType>("Boolean", typeof(bool), DbType.Boolean),
+				new Tuple<string, Type, DbType>("Byte", typeof(byte), DbType.Byte),
+				new Tuple<string, Type, DbType>("Int", typeof(int), DbType.Int32),
+				new Tuple<string, Type, DbType>("Decimal", typeof(decimal), DbType.Decimal),
+				new Tuple<string, Type, DbType>("Double", typeof(double), DbType.Double),
+				new Tuple<string, Type, DbType>("DateTime", typeof(DateTime), DbType.DateTime),
+				new Tuple<string, Type, DbType>("String", typeof(string), DbType.String),
+				new Tuple<string, Type, DbType>("Guid", typeof(Guid), DbType.Guid),
+			};
+
+			// https://docs.microsoft.com/en-us/dotnet/api/system.data.datatablereader.getschematable?view=netframework-4.7.2
+			var dt = new DataTable("SchemaTable");
+			dt.Columns.Add("AllowDBNull", typeof(bool));
+			dt.Columns.Add("AutoIncrementSeed", typeof(long));
+			dt.Columns.Add("AutoIncrementStep", typeof(long));
+			dt.Columns.Add("BaseCatalogName");
+			dt.Columns.Add("BaseColumnName");
+			dt.Columns.Add("BaseColumnNamespace");
+			dt.Columns.Add("BaseSchemaName");
+			dt.Columns.Add("BaseTableName");
+			dt.Columns.Add("BaseTableNamespace");
+			dt.Columns.Add("ColumnName");
+			dt.Columns.Add("ColumnMapping", typeof(MappingType));
+			dt.Columns.Add("ColumnOrdinal", typeof(int));
+			dt.Columns.Add("ColumnSize", typeof(int));
+			dt.Columns.Add("DataType", typeof(Type));
+			dt.Columns.Add("DefaultValue", typeof(object));
+			dt.Columns.Add("Expression");
+			dt.Columns.Add("IsAutoIncrement", typeof(bool));
+			dt.Columns.Add("IsKey", typeof(bool));
+			dt.Columns.Add("IsLong", typeof(bool));
+			dt.Columns.Add("IsReadOnly", typeof(bool));
+			dt.Columns.Add("IsRowVersion", typeof(bool));
+			dt.Columns.Add("IsUnique", typeof(bool));
+			dt.Columns.Add("NumericPrecision", typeof(short));
+			dt.Columns.Add("NumericScale", typeof(short));
+			dt.Columns.Add("ProviderType", typeof(int));
+
+			for (var i = 0; i < columnTypeMapping.Length; i++)
+			{
+				var row = dt.NewRow();
+				row["AllowDBNull"] = true;
+				row["AutoIncrementSeed"] = DBNull.Value;
+				row["AutoIncrementStep"] = DBNull.Value;
+				row["BaseCatalogName"] = null;
+				row["BaseColumnName"] = columnTypeMapping[i].Item1;
+				row["BaseColumnNamespace"] = null;
+				row["BaseSchemaName"] = null;
+				row["BaseTableName"] = null;
+				row["BaseTableNamespace"] = null;
+				row["ColumnName"] = columnTypeMapping[i].Item1;
+				row["ColumnMapping"] = MappingType.Element;
+				row["ColumnOrdinal"] = i;
+				row["ColumnSize"] = int.MaxValue;
+				row["DataType"] = columnTypeMapping[i].Item2;
+				row["DefaultValue"] = null;
+				row["Expression"] = null;
+				row["IsAutoIncrement"] = false;
+				row["IsKey"] = false;
+				row["IsLong"] = false;
+				row["IsReadOnly"] = true;
+				row["IsRowVersion"] = false;
+				row["IsUnique"] = false;
+				row["NumericPrecision"] = columnTypeMapping[i].Item3 == DbType.Decimal ? 10 : DBNull.Value;
+				row["NumericScale"] = columnTypeMapping[i].Item3 == DbType.Decimal ? 2 : DBNull.Value;
+				row["ProviderType"] = columnTypeMapping[i].Item3;
+
+				dt.Rows.Add(row);
+			}
+
+			return dt;
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Defaults/WritingDefaultsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Defaults/WritingDefaultsTests.cs
new file mode 100644
index 0000000..85ab8ea
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Defaults/WritingDefaultsTests.cs
@@ -0,0 +1,118 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Defaults
+{
+	
+	public class WritingDefaultsTests
+	{
+		[Fact]
+		public void EmptyFieldsOnNullReferencePropertyTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				UseNewObjectForNullReferenceMembers = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<A>
+				{
+					new A
+					{
+						AId = 1,
+					},
+					new A
+					{
+						AId = 2,
+						B = new B
+						{
+							BId = 3,
+						},
+					},
+				};
+
+				csv.Context.RegisterClassMap<AMap>();
+				csv.WriteRecords(records);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+				var expected = "AId,BId,CId\r\n" +
+							   "1,,\r\n" +
+							   "2,3,0\r\n";
+				Assert.Equal(expected, data);
+			}
+		}
+
+		[Fact]
+		public void DefaultFieldsOnNullReferencePropertyTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var records = new List<A>
+				{
+					new A
+					{
+						AId = 1,
+					},
+					new A
+					{
+						AId = 2,
+						B = new B
+						{
+							BId = 3,
+						},
+					},
+				};
+
+				csv.Context.RegisterClassMap<AMap>();
+				csv.WriteRecords(records);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+				var expected = "AId,BId,CId\r\n" +
+							   "1,0,0\r\n" +
+							   "2,3,0\r\n";
+				Assert.Equal(expected, data);
+			}
+		}
+
+		private class A
+		{
+			public int AId { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				AutoMap(CultureInfo.InvariantCulture);
+				Map(m => m.AId).Default(1);
+			}
+		}
+
+		public class B
+		{
+			public int BId { get; set; }
+			public int CId { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DisposeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DisposeTests.cs
new file mode 100644
index 0000000..b9d1f63
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DisposeTests.cs
@@ -0,0 +1,55 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+
+namespace CsvHelper.Tests
+{
+	
+	public class DisposeTests
+	{
+		[Fact]
+		public void WriterFlushOnDisposeTest()
+		{
+			using (var writer = new StringWriter())
+			{
+				using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+				{
+					csv.WriteField("A");
+				}
+
+				Assert.Equal("A", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriterFlushOnDisposeWithFlushTest()
+		{
+			using (var writer = new StringWriter())
+			{
+				using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+				{
+					csv.WriteField("A");
+					csv.Flush();
+				}
+
+				Assert.Equal("A", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void DisposeShouldBeCallableMultipleTimes()
+		{
+			var parserMock = new ParserMock();
+			var reader = new CsvReader(parserMock);
+
+			reader.Dispose();
+			reader.Dispose();
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DynamicProxyTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DynamicProxyTests.cs
new file mode 100644
index 0000000..aa501f2
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/DynamicProxyTests.cs
@@ -0,0 +1,65 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class DynamicProxyTests
+	{
+		[Fact]
+		public void WriteDynamicProxyObjectTest()
+		{
+			var list = new List<TestClass>();
+			var proxyGenerator = new Castle.DynamicProxy.ProxyGenerator();
+			for (var i = 0; i < 1; i++)
+			{
+				var proxy = proxyGenerator.CreateClassProxy<TestClass>();
+				proxy.Id = i + 1;
+				proxy.Name = "name" + proxy.Id;
+				list.Add(proxy);
+			}
+
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<TestClassMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var data = reader.ReadToEnd();
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("id,name");
+				expected.AppendLine("1,name1");
+
+				Assert.Equal(expected.ToString(), data);
+			}
+		}
+
+		public class TestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class TestClassMap : ClassMap<TestClass>
+		{
+			public TestClassMap()
+			{
+				Map(m => m.Id).Name("id");
+				Map(m => m.Name).Name("name");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/EnumerateRecordsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/EnumerateRecordsTests.cs
new file mode 100644
index 0000000..5afdd52
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/EnumerateRecordsTests.cs
@@ -0,0 +1,181 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+
+namespace CsvHelper.Tests
+{
+	
+	public class EnumerateRecordsTests
+	{
+		[Fact]
+		public void BasicTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var record = new Basic
+				{
+					Id = -1,
+					Name = "-one"
+				};
+
+				var count = 1;
+				foreach (var r in csv.EnumerateRecords(record))
+				{
+					if (count == 1)
+					{
+						Assert.Equal(1, r.Id);
+						Assert.Equal("one", r.Name);
+					}
+					else if (count == 2)
+					{
+						Assert.Equal(2, r.Id);
+						Assert.Equal("two", r.Name);
+					}
+
+					count++;
+				}
+			}
+		}
+
+		[Fact]
+		public void UnUsedPropertyTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var record = new UnUsedProperty
+				{
+					Id = -1,
+					Name = "-one",
+					UnUsed = "nothing",
+				};
+
+				var count = 1;
+				foreach (var r in csv.EnumerateRecords(record))
+				{
+					if (count == 1)
+					{
+						Assert.Equal(1, r.Id);
+						Assert.Equal("one", r.Name);
+						Assert.Equal("nothing", r.UnUsed);
+					}
+					else if (count == 2)
+					{
+						Assert.Equal(2, r.Id);
+						Assert.Equal("two", r.Name);
+						Assert.Equal("nothing", r.UnUsed);
+					}
+
+					count++;
+				}
+			}
+		}
+
+		[Fact]
+		public void ReferenceTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var record = new HasReferences
+				{
+					Id = -1,
+					Reference = new Reference
+					{
+						Name = "one"
+					}
+				};
+
+				var count = 1;
+				foreach (var r in csv.EnumerateRecords(record))
+				{
+					if (count == 1)
+					{
+						Assert.Equal(1, r.Id);
+						Assert.Equal("one", r.Reference.Name);
+					}
+					else if (count == 2)
+					{
+						Assert.Equal(2, r.Id);
+						Assert.Equal("two", r.Reference.Name);
+					}
+
+					count++;
+				}
+			}
+		}
+
+		private class Basic
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private class UnUsedProperty
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+
+			public string UnUsed { get; set; }
+		}
+
+		public class HasReferences
+		{
+			public int Id { get; set; }
+
+			public Reference Reference { get; set; }
+		}
+
+		public class Reference
+		{
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Exceptions/ExceptionMessageTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Exceptions/ExceptionMessageTests.cs
new file mode 100644
index 0000000..acf3c25
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Exceptions/ExceptionMessageTests.cs
@@ -0,0 +1,208 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.Exceptions
+{
+	
+	public class ExceptionMessageTests
+	{
+		[Fact]
+		public void GetMissingFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "Id", "Name" },
+				{ "a", "b" },
+				null
+			};
+			var reader = new CsvReader(parser);
+			reader.Read();
+			reader.Read();
+			try
+			{
+				reader.GetField(2);
+				throw new XUnitException();
+			}
+			catch (MissingFieldException ex)
+			{
+				Assert.Equal(2, ex.Context.Parser.Row);
+				Assert.Equal(2, ex.Context.Reader.CurrentIndex);
+			}
+		}
+
+		[Fact]
+		public void GetGenericMissingFieldWithTypeTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "a", "b" },
+				null
+			};
+
+			var reader = new CsvReader(parser);
+			reader.Read();
+			reader.Read();
+			try
+			{
+				reader.GetField<int>(2);
+				throw new XUnitException();
+			}
+			catch (MissingFieldException ex)
+			{
+				Assert.Equal(2, ex.Context.Parser.Row);
+				Assert.Equal(2, ex.Context.Reader.CurrentIndex);
+			}
+		}
+
+		[Fact]
+		public void GetRecordGenericTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "a", "b" },
+				null
+			};
+
+			var reader = new CsvReader(parser);
+			reader.Read();
+			try
+			{
+				reader.GetRecord<Simple>();
+				throw new XUnitException();
+			}
+			catch (TypeConverterException ex)
+			{
+				//var expected = "Row: '2' (1 based)\r\n" +
+				//        "Type: 'CsvHelper.Tests.Exceptions.ExceptionMessageTests+Simple'\r\n" +
+				//        "Field Index: '0' (0 based)\r\n" +
+				//        "Field Name: 'Id'\r\n" +
+				//        "Field Value: 'a'\r\n";
+				//Assert.Equal( expected, ex.Data["CsvHelper"] );
+
+				Assert.Equal(2, ex.Context.Parser.Row);
+				//Assert.Equal( typeof( Simple ), ex.Type );
+				Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+			}
+		}
+
+		[Fact]
+		public void GetRecordTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "a", "b" },
+				null
+			};
+
+			var reader = new CsvReader(parser);
+			reader.Read();
+			try
+			{
+				reader.GetRecord(typeof(Simple));
+				throw new XUnitException();
+			}
+			catch (TypeConverterException ex)
+			{
+				Assert.Equal(2, ex.Context.Parser.Row);
+				Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+			}
+		}
+
+		[Fact]
+		public void GetRecordsGenericTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "a", "b" },
+				null
+			};
+
+			var reader = new CsvReader(parser);
+			try
+			{
+				reader.GetRecords<Simple>().ToList();
+				throw new XUnitException();
+			}
+			catch (TypeConverterException ex)
+			{
+				Assert.Equal(2, ex.Context.Parser.Row);
+				Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+			}
+		}
+
+		[Fact]
+		public void GetRecordsTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "a", "b" },
+				null
+			};
+
+			var reader = new CsvReader(parser);
+			try
+			{
+				reader.GetRecords(typeof(Simple)).ToList();
+				throw new XUnitException();
+			}
+			catch (TypeConverterException ex)
+			{
+				Assert.Equal(2, ex.Context.Parser.Row);
+				//Assert.Equal( typeof( Simple ), ex.Type );
+				Assert.Equal(0, ex.Context.Reader.CurrentIndex);
+			}
+		}
+
+		[Fact]
+		public void GetFieldIndexTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "a", "b" },
+				null
+			};
+
+			var reader = new CsvReader(parser);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			try
+			{
+				reader.GetField("c");
+				throw new XUnitException();
+			}
+			catch (MissingFieldException ex)
+			{
+				Assert.Equal(2, ex.Context.Parser.Row);
+				Assert.Equal(-1, ex.Context.Reader.CurrentIndex);
+			}
+		}
+
+		private class Simple
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Exceptions/ExceptionTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Exceptions/ExceptionTests.cs
new file mode 100644
index 0000000..bec1ee5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Exceptions/ExceptionTests.cs
@@ -0,0 +1,52 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Exceptions
+{
+	
+	public class ExceptionTests
+	{
+		[Fact]
+		public void NoDefaultConstructorTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,2");
+				writer.WriteLine("3,4");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.Throws<MissingFieldException>(() => csv.GetRecords<NoDefaultConstructor>().ToList());
+			}
+		}
+
+		private class NoDefaultConstructor
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+
+			public NoDefaultConstructor(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/HeaderValidationTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/HeaderValidationTests.cs
new file mode 100644
index 0000000..a1775ac
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/HeaderValidationTests.cs
@@ -0,0 +1,280 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace CsvHelper.Tests
+{
+	
+	public class HeaderValidationTests
+	{
+		[Fact]
+		public void ValidateHeader_ValidHeaders_NoException()
+		{
+			using (var csv = new CsvReader(new StringReader("Id,Name"), CultureInfo.InvariantCulture))
+			{
+				csv.Read();
+				csv.ReadHeader();
+				csv.ValidateHeader<Test>();
+			}
+		}
+
+		[Fact]
+		public void ValidateHeader_PropertiesDontMatch_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("bad data"), CultureInfo.InvariantCulture))
+			{
+				csv.Read();
+				csv.ReadHeader();
+				try
+				{
+					csv.ValidateHeader<Test>();
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Equal(2, ex.InvalidHeaders.Length);
+				}
+			}
+		}
+
+		[Fact]
+		public void ValidateHeader_ReferencePropertiesDontMatch_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("bad data"), CultureInfo.InvariantCulture))
+			{
+				csv.Read();
+				csv.ReadHeader();
+				try
+				{
+					csv.ValidateHeader<HasReference>();
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Equal(2, ex.InvalidHeaders.Length);
+				}
+			}
+		}
+
+		[Fact]
+		public void ValidateHeader_ConstructorParametersDontMatch_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("bad data"), CultureInfo.InvariantCulture))
+			{
+				csv.Read();
+				csv.ReadHeader();
+				try
+				{
+					csv.ValidateHeader<HasConstructor>();
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Equal(2, ex.InvalidHeaders.Length);
+				}
+			}
+		}
+
+		[Fact]
+		public void GetRecord_PropertiesDontMatch_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("bad data"), CultureInfo.InvariantCulture))
+			{
+				csv.Read();
+				try
+				{
+					csv.GetRecord(typeof(Test));
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Equal(2, ex.InvalidHeaders.Length);
+				}
+			}
+		}
+
+		[Fact]
+		public void GetRecordGeneric_PropertiesDontMatch_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("bad data"), CultureInfo.InvariantCulture))
+			{
+				csv.Read();
+				try
+				{
+					csv.GetRecord<Test>();
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Equal(2, ex.InvalidHeaders.Length);
+				}
+			}
+		}
+
+		[Fact]
+		public void GetRecords_PropertiesDontMatch_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("bad data"), CultureInfo.InvariantCulture))
+			{
+				try
+				{
+					csv.GetRecords(typeof(Test)).ToList();
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Equal(2, ex.InvalidHeaders.Length);
+				}
+			}
+		}
+
+		[Fact]
+		public void GetRecordsGeneric_PropertiesDontMatch_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("bad data"), CultureInfo.InvariantCulture))
+			{
+				try
+				{
+					csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Equal(2, ex.InvalidHeaders.Length);
+				}
+			}
+		}
+
+		[Fact]
+		public void GetRecordsGeneric_PrivateSetter_NoException()
+		{
+			var data = new StringBuilder();
+			data.AppendLine("Number");
+			data.AppendLine("1");
+			using (var csv = new CsvReader(new StringReader(data.ToString()), CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<HasPrivateSetter>().ToList();
+				var record = records[0];
+				Assert.Equal(1, record.Number);
+				Assert.Equal(2, record.Double);
+			}
+		}
+
+		[Fact]
+		public void GetRecordsGeneric_IgnoreProperty_NoException()
+		{
+			var data = new StringBuilder();
+			data.AppendLine("Id");
+			data.AppendLine("1");
+			using (var csv = new CsvReader(new StringReader(data.ToString()), CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<HasIgnoredPropertyMap>();
+				var records = csv.GetRecords<Test>().ToList();
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Null(record.Name);
+			}
+		}
+
+		[Fact]
+		public void ValidateHeader_NoNamesMapped_NoException()
+		{
+			using (var csv = new CsvReader(new StringReader("Id"), CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<HasIndexNoNameMap>();
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.ValidateHeader<Test>();
+			}
+		}
+
+		[Fact]
+		public void ValidateHeader_HasIndexAndName_ThrowsHeaderValidationException()
+		{
+			using (var csv = new CsvReader(new StringReader("Id"), CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<HasIndexAndNameMap>();
+
+				csv.Read();
+				csv.ReadHeader();
+				try
+				{
+					csv.ValidateHeader<Test>();
+					throw new XUnitException();
+				}
+				catch (HeaderValidationException ex)
+				{
+					Assert.Single(ex.InvalidHeaders);
+					Assert.Equal("Name", ex.InvalidHeaders[0].Names[0]);
+				}
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private class HasReference
+		{
+			public Test Reference { get; set; }
+		}
+
+		private class HasConstructor
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public HasConstructor(int Id, string Name)
+			{
+				this.Id = Id;
+				this.Name = Name;
+			}
+		}
+
+		private class HasPrivateSetter
+		{
+			public int Number { get; set; }
+
+			public int Double => Number * 2;
+		}
+
+		private sealed class HasIgnoredPropertyMap : ClassMap<Test>
+		{
+			public HasIgnoredPropertyMap()
+			{
+				AutoMap(CultureInfo.InvariantCulture);
+				Map(m => m.Name).Ignore();
+			}
+		}
+
+		private sealed class HasIndexNoNameMap : ClassMap<Test>
+		{
+			public HasIndexNoNameMap()
+			{
+				Map(m => m.Id).Index(0);
+				Map(m => m.Name).Index(1);
+			}
+		}
+
+		private sealed class HasIndexAndNameMap : ClassMap<Test>
+		{
+			public HasIndexAndNameMap()
+			{
+				Map(m => m.Id).Index(0).Name("Id");
+				Map(m => m.Name).Index(1).Name("Name");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Issues/Issue1954.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Issues/Issue1954.cs
new file mode 100644
index 0000000..0fc4b55
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Issues/Issue1954.cs
@@ -0,0 +1,178 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.Issues
+{
+	public class Issue1954
+	{
+		[Fact]
+		public void Test1()
+		{
+			var data = @"field1, field2, field3
+1, 2, ""test""
+3, 4, ""TEST""";
+
+			var opts = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ",",
+				TrimOptions = TrimOptions.Trim,
+				BufferSize = 44
+			};
+
+			using (var sr = new StringReader(data))
+			using (var csv = new CsvReader(sr, opts))
+			{
+				var records = csv.GetRecords<Row>().ToArray();
+
+				Assert.Equal(2, records.Length);
+
+				Assert.Equal(1, records[0].Field1);
+				Assert.Equal(2, records[0].Field2);
+				Assert.Equal("test", records[0].Field3);
+
+				Assert.Equal(3, records[1].Field1);
+				Assert.Equal(4, records[1].Field2);
+				Assert.Equal("TEST", records[1].Field3);
+			}
+		}
+
+		[Fact]
+		public void Test2()
+		{
+			var data = @"field1, field2, field3
+1, 2, ""test""
+3, 4, ""TEST""";
+
+			var opts = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ",",
+				TrimOptions = TrimOptions.Trim,
+				BufferSize = 45
+			};
+
+			using (var sr = new StringReader(data))
+			using (var csv = new CsvReader(sr, opts))
+			{
+				var records = csv.GetRecords<Row>().ToArray();
+
+				Assert.Equal(2, records.Length);
+
+				Assert.Equal(1, records[0].Field1);
+				Assert.Equal(2, records[0].Field2);
+				Assert.Equal("test", records[0].Field3);
+
+				Assert.Equal(3, records[1].Field1);
+				Assert.Equal(4, records[1].Field2);
+				Assert.Equal("TEST", records[1].Field3);
+			}
+		}
+
+		[Fact]
+		public void Test3()
+		{
+			var data = @"field1, field2, field3
+1, 2, ""test""
+3, 4,    ""TEST""";
+
+			var opts = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ",",
+				TrimOptions = TrimOptions.Trim,
+				BufferSize = 44
+			};
+
+			using (var sr = new StringReader(data))
+			using (var csv = new CsvReader(sr, opts))
+			{
+				var records = csv.GetRecords<Row>().ToArray();
+
+				Assert.Equal(2, records.Length);
+
+				Assert.Equal(1, records[0].Field1);
+				Assert.Equal(2, records[0].Field2);
+				Assert.Equal("test", records[0].Field3);
+
+				Assert.Equal(3, records[1].Field1);
+				Assert.Equal(4, records[1].Field2);
+				Assert.Equal("TEST", records[1].Field3);
+			}
+		}
+
+		[Fact]
+		public void Test4()
+		{
+			var data = @"field1, field2, field3
+1, 2, ""test""
+3, 4,""TEST""";
+
+			var opts = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ",",
+				TrimOptions = TrimOptions.Trim,
+				BufferSize = 44
+			};
+
+			using (var sr = new StringReader(data))
+			using (var csv = new CsvReader(sr, opts))
+			{
+				var records = csv.GetRecords<Row>().ToArray();
+
+				Assert.Equal(2, records.Length);
+
+				Assert.Equal(1, records[0].Field1);
+				Assert.Equal(2, records[0].Field2);
+				Assert.Equal("test", records[0].Field3);
+
+				Assert.Equal(3, records[1].Field1);
+				Assert.Equal(4, records[1].Field2);
+				Assert.Equal("TEST", records[1].Field3);
+			}
+		}
+
+		[Fact]
+		public void Test5()
+		{
+			var data = @"field1, field2, field3
+1, 2, ""test""
+3, 4, TEST";
+
+			var opts = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ",",
+				TrimOptions = TrimOptions.Trim,
+				BufferSize = 44
+			};
+
+			using (var sr = new StringReader(data))
+			using (var csv = new CsvReader(sr, opts))
+			{
+				var records = csv.GetRecords<Row>().ToArray();
+
+				Assert.Equal(2, records.Length);
+
+				Assert.Equal(1, records[0].Field1);
+				Assert.Equal(2, records[0].Field2);
+				Assert.Equal("test", records[0].Field3);
+
+				Assert.Equal(3, records[1].Field1);
+				Assert.Equal(4, records[1].Field2);
+				Assert.Equal("TEST", records[1].Field3);
+			}
+		}
+
+		private class Row
+		{
+			[Name("field1")] public int Field1 { get; set; }
+			[Name("field2")] public int Field2 { get; set; }
+			[Name("field3")] public string Field3 { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Issues/Issue920.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Issues/Issue920.cs
new file mode 100644
index 0000000..1ae38db
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Issues/Issue920.cs
@@ -0,0 +1,59 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace CsvHelper.Tests.Issues
+{
+	
+	public class Issue920
+	{
+		[Fact]
+		public void Test1()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				GetConstructor = args =>
+					args.ClassType.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)
+					.OrderBy(c => c.GetParameters().Length)
+					.First(),
+				IncludePrivateMembers = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("A,B");
+				writer.WriteLine("1,one");
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<Sample>().ToList();
+
+				Assert.Equal(2, records.Count);
+			}
+		}
+
+		private class Sample
+		{
+			public int A { get; private set; }
+			public string B { get; private set; }
+
+			private Sample() { }
+
+			public Sample(int a, string b)
+			{
+				A = a;
+				B = b;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/LocalCultureTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/LocalCultureTests.cs
new file mode 100644
index 0000000..f99540e
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/LocalCultureTests.cs
@@ -0,0 +1,72 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class LocalCultureTests
+	{
+		// In 'uk-UA' decimal separator is the ','
+		// For 'Invariant' and many other cultures decimal separator is '.'
+
+		[Fact]
+		public void ReadRecordsTest()
+		{
+			const string source = "DateTimeColumn;DecimalColumn\r\n" +
+								  "11.11.2010;12,0\r\n";
+
+			var configuration = new CsvHelper.Configuration.CsvConfiguration(new CultureInfo("uk-UA"))
+			{
+				Delimiter = ";",
+			};
+			var reader = new CsvReader(new CsvParser(new StringReader(source), configuration));
+
+			var records = reader.GetRecords<TestRecordWithDecimal>().ToList();
+
+			Assert.Single(records);
+			var record = records.First();
+			Assert.Equal(12.0m, record.DecimalColumn);
+			Assert.Equal(new DateTime(2010, 11, 11), record.DateTimeColumn);
+		}
+
+		[Fact]
+		public void WriteRecordsTest()
+		{
+			var records = new List<TestRecordWithDecimal>
+			{
+				new TestRecordWithDecimal
+				{
+					DecimalColumn = 12.0m,
+					DateTimeColumn = new DateTime( 2003, 1, 4, 15, 9, 26 )
+				}
+			};
+
+			var writer = new StringWriter();
+			var culture = new CultureInfo("uk-UA");
+			var csv = new CsvWriter(writer, new CsvHelper.Configuration.CsvConfiguration(culture) { Delimiter = ";" });
+
+			csv.WriteRecords(records);
+
+			var csvFile = writer.ToString();
+
+			const string expected = "DecimalColumn;DateTimeColumn\r\n" +
+									"12,0;04.01.2003 15:09:26\r\n";
+
+			Assert.Equal(expected, csvFile);
+		}
+
+		private class TestRecordWithDecimal
+		{
+			public decimal DecimalColumn { get; set; }
+			public DateTime DateTimeColumn { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/MapPropertyMultipleTimesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/MapPropertyMultipleTimesTests.cs
new file mode 100644
index 0000000..b330cd0
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/MapPropertyMultipleTimesTests.cs
@@ -0,0 +1,87 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class MapPropertyMultipleTimesTests
+	{
+		[Fact]
+		public void MapPropertiesToMultipleFieldsWhenWritingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<Test>
+				{
+					new Test { Id = 1, Name = "one" }
+				};
+
+				csv.Context.RegisterClassMap<TestMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id1,Name1,Id2,Name2");
+				expected.AppendLine("1,one,1,one");
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void MapPropertiesToMultipleFieldsWhenReadingTest()
+		{
+			// This is not something that anyone should do, but this
+			// is the expected behavior if they do.
+
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id1,Name1,Id2,Name2");
+				writer.WriteLine("1,one,2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				Assert.Equal(2, records[0].Id);
+				Assert.Equal("two", records[0].Name);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Id).Name("Id1");
+				Map(m => m.Name).Name("Name1");
+				Map(m => m.Id, false).Name("Id2");
+				Map(m => m.Name, false).Name("Name2");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/MappingInheritedClassTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/MappingInheritedClassTests.cs
new file mode 100644
index 0000000..82c5ef5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/MappingInheritedClassTests.cs
@@ -0,0 +1,42 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+
+namespace CsvHelper.Tests
+{
+	
+	public class MappingInheritedClassTests
+	{
+		[Fact]
+		public void Test()
+		{
+			var map = new AMap<A>();
+			Assert.Equal( 2, map.MemberMaps.Count );
+		}
+
+		private interface IA
+		{
+			int Id { get; set; }
+		}
+
+		private class A : IA
+		{
+			public int Id { get; set; }
+
+			public int Name { get; set; }
+		}
+
+		private sealed class AMap<T> : ClassMap<T> where T : IA
+		{
+			public AMap()
+			{
+				AutoMap(CultureInfo.InvariantCulture);
+				Map( m => m.Id );
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/AllowCommentsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/AllowCommentsTests.cs
new file mode 100644
index 0000000..e5fb1eb
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/AllowCommentsTests.cs
@@ -0,0 +1,29 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class AllowCommentsTests
+	{
+		[Fact]
+		public void AllowCommentsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(AllowCommentsTestClass));
+			Assert.True(config.AllowComments);
+		}
+
+		[AllowComments(true)]
+		private class AllowCommentsTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/BooleanValuesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/BooleanValuesTests.cs
new file mode 100644
index 0000000..b2eefde
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/BooleanValuesTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class BooleanValuesTests
+	{
+		[Fact]
+		public void BooleanValuesTest()
+		{
+			using (var reader = new StringReader("IsTrue,IsFalse\r\ntrue,false\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<BooleanValuesTestClass>().ToList();
+				Assert.Equal(true, records[0].IsTrue);
+				Assert.Equal(false, records[0].IsFalse);
+			}
+		}
+
+		private class BooleanValuesTestClass
+		{
+			[BooleanTrueValues("true")]
+			public bool? IsTrue { get; set; }
+
+			[BooleanFalseValues("false")]
+			public bool? IsFalse { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/BufferSizeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/BufferSizeTests.cs
new file mode 100644
index 0000000..dd35498
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/BufferSizeTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class BufferSizeTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(2, config.BufferSize);
+		}
+
+		[BufferSize(2)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CacheFieldsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CacheFieldsTests.cs
new file mode 100644
index 0000000..bfc1c52
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CacheFieldsTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class CacheFieldsTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.True(config.CacheFields);
+		}
+
+		[CacheFields(true)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CommentTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CommentTests.cs
new file mode 100644
index 0000000..64baf14
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CommentTests.cs
@@ -0,0 +1,28 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+    public class CommentTests
+    {
+        [Fact]
+        public void CommentTest()
+        {
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(CommentTestClass));
+            Assert.Equal('x', config.Comment);
+        }
+
+        [Comment('x')]
+        private class CommentTestClass
+        {
+        }
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ConstantTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ConstantTests.cs
new file mode 100644
index 0000000..5ab6381
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ConstantTests.cs
@@ -0,0 +1,50 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class ConstantTests
+	{
+		[Fact]
+		public void ConstantTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<ConstantTestClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("two", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void ConstantOnMissingFieldTest()
+		{
+			using (var reader = new StringReader("Id\r\n1\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<ConstantTestClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("two", records[0].Name);
+			}
+		}
+
+		private class ConstantTestClass
+		{
+			public int Id { get; set; }
+
+			[Constant("two")]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CountBytesTest.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CountBytesTest.cs
new file mode 100644
index 0000000..c4847cd
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/CountBytesTest.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class CountBytesTest
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.True(config.CountBytes);
+		}
+
+		[CountBytes(true)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DateTimeStylesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DateTimeStylesTests.cs
new file mode 100644
index 0000000..3e5a25d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DateTimeStylesTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class DateTimeStylesTests
+	{
+		[Fact]
+		public void DateTimeStylesTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<DateTimeStylesTestClass>().ToList();
+				var actual = csv.Context.Maps.Find<DateTimeStylesTestClass>().MemberMaps[1].Data.TypeConverterOptions.DateTimeStyle;
+
+				Assert.Equal(DateTimeStyles.AdjustToUniversal, actual);
+			}
+		}
+
+		private class DateTimeStylesTestClass
+		{
+			public int Id { get; set; }
+
+			[DateTimeStyles(DateTimeStyles.AdjustToUniversal)]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DefaultTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DefaultTests.cs
new file mode 100644
index 0000000..4718c66
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DefaultTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class DefaultTests
+	{
+		[Fact]
+		public void DefaultTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<DefaultTestClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		private class DefaultTestClass
+		{
+			public int Id { get; set; }
+
+			[Default("one")]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DelimiterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DelimiterTests.cs
new file mode 100644
index 0000000..3315126
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DelimiterTests.cs
@@ -0,0 +1,32 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class DelimiterTests
+	{
+		[Fact]
+		public void DelimiterReaderTest()
+		{
+			var configuration = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(DelimiterTestClass));
+
+			Assert.Equal("§", configuration.Delimiter);
+		}
+
+		[Delimiter("§")]
+		private class DelimiterTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectColumnCountChangesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectColumnCountChangesTests.cs
new file mode 100644
index 0000000..4fad816
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectColumnCountChangesTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class DetectColumnCountChangesTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.True(config.DetectColumnCountChanges);
+		}
+
+		[DetectColumnCountChanges(true)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterTests.cs
new file mode 100644
index 0000000..1ccc0fb
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class DetectDelimiterTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.True(config.DetectDelimiter);
+		}
+
+		[DetectDelimiter(true)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterValuesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterValuesTests.cs
new file mode 100644
index 0000000..a160001
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/DetectDelimiterValuesTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class DetectDelimiterValuesTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(new[] { "a", "b" }, config.DetectDelimiterValues);
+		}
+
+		[DetectDelimiterValues("a b")]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EncodingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EncodingTests.cs
new file mode 100644
index 0000000..557775b
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EncodingTests.cs
@@ -0,0 +1,33 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class EncodingTests
+	{
+		[Fact]
+		public void EncodingTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(EncodingTestClass));
+
+			Assert.Equal(Encoding.ASCII, config.Encoding);
+		}
+
+		[Encoding("ASCII")]
+		private class EncodingTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EnumIgnoreCaseTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EnumIgnoreCaseTests.cs
new file mode 100644
index 0000000..e12f3cd
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EnumIgnoreCaseTests.cs
@@ -0,0 +1,91 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+    public class EnumIgnoreCaseTests
+    {
+		[Fact]
+		public void GetRecords_UsingEnumIgnoreCaseFromClassMap_ReadsEnumValueWithDifferentCasing()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Enum\r\n");
+			s.Append("1,one");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+			}
+		}
+
+		[Fact]
+		public void GetRecords_UsingEnumIgnoreCaseFromAttribute_ReadsEnumValueWithDifferentCasing()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Enum\r\n");
+			s.Append("1,one");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<Bar>().ToList();
+			}
+		}
+
+		[Fact]
+		public void GetRecords_UsingEnumIgnoreCaseFromGlobal_ReadsEnumValueWithDifferentCasing()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Enum\r\n");
+			s.Append("1,one");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				csv.Context.TypeConverterOptionsCache.AddOptions<TestEnum>(new TypeConverterOptions { EnumIgnoreCase = true });
+				var records = csv.GetRecords<Foo>().ToList();
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+			public TestEnum Enum { get; set; }
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Enum).TypeConverterOption.EnumIgnoreCase();
+			}
+		}
+
+		private class Bar
+		{
+			public int Id { get; set; }
+			[EnumIgnoreCase]
+			public TestEnum Enum { get; set; }
+		}
+
+		private enum TestEnum
+		{
+			None = 0,
+			One = 1
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EscapeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EscapeTests.cs
new file mode 100644
index 0000000..b3c3e7f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/EscapeTests.cs
@@ -0,0 +1,32 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class EscapeTests
+	{
+		[Fact]
+		public void EscapeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(EscapeTestClass));
+
+			Assert.Equal('x', config.Escape);
+		}
+
+		[Escape('x')]
+		private class EscapeTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ExceptionMessagesContainRawDataTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ExceptionMessagesContainRawDataTests.cs
new file mode 100644
index 0000000..ce3688e
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ExceptionMessagesContainRawDataTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class ExceptionMessagesContainRawDataTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.False(config.ExceptionMessagesContainRawData);
+		}
+
+		[ExceptionMessagesContainRawData(false)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/FormatTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/FormatTests.cs
new file mode 100644
index 0000000..c2e2b5f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/FormatTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class FormatTests
+	{
+		[Fact]
+		public void FormatTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<FormatTestClass>().ToList();
+				var actual = csv.Context.Maps.Find<FormatTestClass>().MemberMaps[1].Data.TypeConverterOptions.Formats[0];
+
+				Assert.Equal("abc", actual);
+			}
+		}
+
+		private class FormatTestClass
+		{
+			public int Id { get; set; }
+
+			[Format("abc")]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/HasHeaderRecordTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/HasHeaderRecordTests.cs
new file mode 100644
index 0000000..9fae872
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/HasHeaderRecordTests.cs
@@ -0,0 +1,30 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class HasHeaderRecordTests
+	{
+		[Fact]
+		public void HasHeaderRecordTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(HasHeaderRecordTestClass));
+
+			Assert.False(config.HasHeaderRecord);
+		}
+
+		[HasHeaderRecord(false)]
+		private class HasHeaderRecordTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/HeaderPrefixTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/HeaderPrefixTests.cs
new file mode 100644
index 0000000..fe5cb61
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/HeaderPrefixTests.cs
@@ -0,0 +1,205 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class HeaderPrefixTests
+	{
+		[Fact]
+		public void WriteHeader_PrefixCustom_WritesCustomPrefixesOwnLevelOnly()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteHeader<ACustom>();
+				csv.Flush();
+
+				Assert.Equal("AId,b_BId,c_CId", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteHeader_PrefixInherit_WritesPrefixesForEachLevel()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteHeader<AInherit>();
+				csv.Flush();
+
+				Assert.Equal("AId,B.BId,B.C.CId", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteHeader_PrefixNoInherit_WritesPrefixesOwnLevelOnly()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteHeader<ANoInherit>();
+				csv.Flush();
+
+				Assert.Equal("AId,B.BId,C.CId", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteHeader_PrefixDefaultInherit_WritesPrefixesOwnLevelOnly()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteHeader<ADefaultInherit>();
+				csv.Flush();
+
+				Assert.Equal("AId,B.BId,C.CId", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void GetRecords_PrefixCustom_ReadsCustomHeader()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var s = new TestStringBuilder(config.NewLine);
+			s.AppendLine("AId,b_BId,c_CId");
+			s.AppendLine("aid,bid,cid");
+			using (var reader = new StringReader(s))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var records = csv.GetRecords<ACustom>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal("aid", records[0].AId);
+				Assert.Equal("bid", records[0].B.BId);
+				Assert.Equal("cid", records[0].B.C.CId);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_PrefixInherit_ReadsInheritedHeader()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var s = new TestStringBuilder(config.NewLine);
+			s.AppendLine("AId,B.BId,B.C.CId");
+			s.AppendLine("aid,bid,cid");
+			using (var reader = new StringReader(s))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var records = csv.GetRecords<AInherit>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal("aid", records[0].AId);
+				Assert.Equal("bid", records[0].B.BId);
+				Assert.Equal("cid", records[0].B.C.CId);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_PrefixNoInherit_ReadsNonInheritedHeader()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var s = new TestStringBuilder(config.NewLine);
+			s.AppendLine("AId,B.BId,C.CId");
+			s.AppendLine("aid,bid,cid");
+			using (var reader = new StringReader(s))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var records = csv.GetRecords<ANoInherit>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal("bid", records[0].B.BId);
+				Assert.Equal("aid", records[0].AId);
+				Assert.Equal("cid", records[0].B.C.CId);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_PrefixDefaultInherit_ReadsNonInheritedHeader()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var s = new TestStringBuilder(config.NewLine);
+			s.AppendLine("AId,B.BId,C.CId");
+			s.AppendLine("aid,bid,cid");
+			using (var reader = new StringReader(s))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var records = csv.GetRecords<ADefaultInherit>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal("aid", records[0].AId);
+				Assert.Equal("bid", records[0].B.BId);
+				Assert.Equal("cid", records[0].B.C.CId);
+			}
+		}
+
+		private class ACustom
+		{
+			public string AId { get; set; }
+			[HeaderPrefix("b_")]
+			public BCustom B { get; set; }
+		}
+
+		private class BCustom
+		{
+			public string BId { get; set; }
+			[HeaderPrefix("c_")]
+			public C C { get; set; }
+		}
+
+		private class AInherit
+		{
+			public string AId { get; set; }
+			[HeaderPrefix(true)]
+			public BInherit B { get; set; }
+		}
+
+		private class BInherit
+		{
+			public string BId { get; set; }
+			[HeaderPrefix(true)]
+			public C C { get; set; }
+		}
+
+		private class ANoInherit
+		{
+			public string AId { get; set; }
+			[HeaderPrefix(false)]
+			public BInherit B { get; set; }
+		}
+
+		private class BNoInherit
+		{
+			public string BId { get; set; }
+			[HeaderPrefix(false)]
+			public C C { get; set; }
+		}
+
+		private class ADefaultInherit
+		{
+			public string AId { get; set; }
+			[HeaderPrefix]
+			public BInherit B { get; set; }
+		}
+
+		private class BDefaultInherit
+		{
+			public string BId { get; set; }
+			[HeaderPrefix]
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string CId { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreBaseTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreBaseTests.cs
new file mode 100644
index 0000000..9f49082
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreBaseTests.cs
@@ -0,0 +1,71 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+    public class IgnoreBaseTests
+    {
+		[Fact]
+        public void GetRecordsWithProperties_IgnoreBaseAttribute_DoesNotMapBaseClass()
+		{
+			var map = new DefaultClassMap<ChildProperties>();
+			map.AutoMap(CultureInfo.InvariantCulture);
+
+			Assert.Single(map.MemberMaps);
+			Assert.Null(map.MemberMaps.Find<ChildProperties>(m => m.Id));
+			Assert.NotNull(map.MemberMaps.Find<ChildProperties>(m => m.Name));
+		}
+
+		[Fact]
+		public void GetRecordsWithFields_IgnoreBaseAttribute_DoesNotMapBaseClass()
+		{
+			var map = new DefaultClassMap<ChildFields>();
+			map.AutoMap(new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MemberTypes = MemberTypes.Fields,
+			});
+
+			Assert.Single(map.MemberMaps);
+			Assert.Null(map.MemberMaps.Find<ChildFields>(m => m.Id));
+			Assert.NotNull(map.MemberMaps.Find<ChildFields>(m => m.Name));
+		}
+
+		private class ParentProperties
+		{
+			public int Id { get; set; }
+		}
+
+		[IgnoreBase]
+		private class ChildProperties : ParentProperties
+		{
+			public string Name { get; set; }
+		}
+
+		private class ParentFields
+		{
+#pragma warning disable CS0649
+			public int Id;
+#pragma warning restore CS0649
+		}
+
+		[IgnoreBase]
+		private class ChildFields: ParentFields
+		{
+#pragma warning disable CS0649
+			public string Name;
+#pragma warning restore CS0649
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreBlankLinesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreBlankLinesTests.cs
new file mode 100644
index 0000000..b2ec8e0
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreBlankLinesTests.cs
@@ -0,0 +1,36 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class IgnoreBlankLinesTests
+	{
+		[Fact]
+		public void IgnoreBlankLinesTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<IgnoreBlankLinesTestClass>().ToList();
+				var actual = csv.Configuration.IgnoreBlankLines;
+
+				Assert.True(actual);
+			}
+		}
+
+		[IgnoreBlankLines(true)]
+		private class IgnoreBlankLinesTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreReferencesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreReferencesTests.cs
new file mode 100644
index 0000000..f2839b6
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreReferencesTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class IgnoreReferencesTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.True(config.IgnoreReferences);
+		}
+
+		[IgnoreReferences(true)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreTests.cs
new file mode 100644
index 0000000..4849ad1
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IgnoreTests.cs
@@ -0,0 +1,93 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class IgnoreTests
+	{
+		[Fact]
+		public void IgnoreTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void IgnoreReferenceTest()
+		{
+			var records = new List<Parent>
+			{
+				new Parent
+				{
+					Id = 1,
+					Child = new Child
+					{
+						Name = "one",
+						GrandChild = new GrandChild
+						{
+							Date = DateTimeOffset.Now
+						}
+					}
+				}
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id");
+				expected.AppendLine("1");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+
+			[CsvHelper.Configuration.Attributes.Ignore]
+			public DateTime Date { get; set; }
+		}
+
+		private class Parent
+		{
+			public int Id { get; set; }
+
+			[CsvHelper.Configuration.Attributes.Ignore]
+			public Child Child { get; set; }
+		}
+
+		private class Child
+		{
+			public string Name { get; set; }
+
+			public GrandChild GrandChild { get; set; }
+		}
+
+		private class GrandChild
+		{
+			public DateTimeOffset Date { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IncludePrivateMembersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IncludePrivateMembersTests.cs
new file mode 100644
index 0000000..2b219dc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IncludePrivateMembersTests.cs
@@ -0,0 +1,29 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class IncludePrivateMembersTests
+	{
+		[Fact]
+		public void TrimOptionsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(IncludePrivateMembersTestClass));
+			Assert.True(config.IncludePrivateMembers);
+		}
+
+		[IncludePrivateMembers(true)]
+		private class IncludePrivateMembersTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IndexTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IndexTests.cs
new file mode 100644
index 0000000..1dc9112
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/IndexTests.cs
@@ -0,0 +1,42 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class IndexTests
+	{
+		[Fact]
+		public void IndexTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var reader = new StringReader("a,1,b,one,c\r\n"))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var records = csv.GetRecords<IndexTestClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		private class IndexTestClass
+		{
+			[Index(1)]
+			public int Id { get; set; }
+
+			[Index(3)]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionCharactersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionCharactersTests.cs
new file mode 100644
index 0000000..b4fc82c
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionCharactersTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class InjectionCharactersTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(new[] { 'a', 'b' }, config.InjectionCharacters);
+		}
+
+		[InjectionCharacters("a b")]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionEscapeCharacterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionEscapeCharacterTests.cs
new file mode 100644
index 0000000..e118ea2
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionEscapeCharacterTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class InjectionEscapeCharacterTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal('a', config.InjectionEscapeCharacter);
+		}
+
+		[InjectionEscapeCharacter('a')]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionOptionsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionOptionsTests.cs
new file mode 100644
index 0000000..7a03003
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/InjectionOptionsTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class InjectionOptionsTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(InjectionOptions.Escape, config.InjectionOptions);
+		}
+
+		[InjectionOptions(InjectionOptions.Escape)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/LineBreakInQuotedFieldIsBadDataTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/LineBreakInQuotedFieldIsBadDataTests.cs
new file mode 100644
index 0000000..b939780
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/LineBreakInQuotedFieldIsBadDataTests.cs
@@ -0,0 +1,25 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class LineBreakInQuotedFieldIsBadDataTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.True(config.LineBreakInQuotedFieldIsBadData);
+		}
+
+		[LineBreakInQuotedFieldIsBadData(true)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/MaxFieldSizeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/MaxFieldSizeTests.cs
new file mode 100644
index 0000000..b0a9231
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/MaxFieldSizeTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class MaxFieldSizeTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(2, config.MaxFieldSize);
+		}
+
+		[MaxFieldSize(2)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/MemberTypesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/MemberTypesTests.cs
new file mode 100644
index 0000000..be21b32
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/MemberTypesTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class MemberTypesTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(MemberTypes.Fields, config.MemberTypes);
+		}
+
+		[MemberTypes(MemberTypes.Fields)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ModeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ModeTests.cs
new file mode 100644
index 0000000..ca35863
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ModeTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class ModeTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(CsvMode.Escape, config.Mode);
+		}
+
+		[Mode(CsvMode.Escape)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NameIndexTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NameIndexTests.cs
new file mode 100644
index 0000000..07cda20
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NameIndexTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class NameIndexTests
+	{
+		[Fact]
+		public void NameIndexTest()
+		{
+			using (var reader = new StringReader("Id,Name,Name\r\n1,one,two\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<NameIndexClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("two", records[0].Name);
+			}
+		}
+
+		private class NameIndexClass
+		{
+			public int Id { get; set; }
+
+			[NameIndex(1)]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NameTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NameTests.cs
new file mode 100644
index 0000000..3957442
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NameTests.cs
@@ -0,0 +1,38 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class NameTests
+	{
+		[Fact]
+		public void NameTest()
+		{
+			using (var reader = new StringReader("id,name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<NameTestClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		private class NameTestClass
+		{
+			[Name("id")]
+			public int Id { get; set; }
+
+			[Name("name")]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NewLineTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NewLineTests.cs
new file mode 100644
index 0000000..5d9ba80
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NewLineTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class NewLineTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal("a", config.NewLine);
+		}
+
+		[NewLine("a")]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NullValuesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NullValuesTests.cs
new file mode 100644
index 0000000..8694172
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NullValuesTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class NullValuesTests
+	{
+		[Fact]
+		public void NullValuesTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\nNULL,null\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<NullValuesTestClass>().ToList();
+				Assert.Null(records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		private class NullValuesTestClass
+		{
+			[NullValues("NULL")]
+			public int? Id { get; set; }
+
+			[NullValues("null")]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NumberStylesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NumberStylesTests.cs
new file mode 100644
index 0000000..3740f54
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/NumberStylesTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class NumberStylesTests
+	{
+		[Fact]
+		public void DateTimeStylesTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<NumberStylesTestClass>().ToList();
+				var actual = csv.Context.Maps.Find<NumberStylesTestClass>().MemberMaps[1].Data.TypeConverterOptions.NumberStyles;
+
+				Assert.Equal(NumberStyles.AllowCurrencySymbol, actual);
+			}
+		}
+
+		private class NumberStylesTestClass
+		{
+			public int Id { get; set; }
+
+			[NumberStyles(NumberStyles.AllowCurrencySymbol)]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/OptionalTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/OptionalTests.cs
new file mode 100644
index 0000000..466e6b5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/OptionalTests.cs
@@ -0,0 +1,41 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class OptionalTests
+	{
+		[Fact]
+		public void OptionalTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id" },
+				{ "1" },
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<OptionalTestClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		private class OptionalTestClass
+		{
+			public int Id { get; set; }
+
+			[Optional]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ProcessFieldBufferSizeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ProcessFieldBufferSizeTests.cs
new file mode 100644
index 0000000..63ea433
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ProcessFieldBufferSizeTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class ProcessFieldBufferSizeTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(2, config.ProcessFieldBufferSize);
+		}
+
+		[ProcessFieldBufferSize(2)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/QuoteTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/QuoteTests.cs
new file mode 100644
index 0000000..3b6fb41
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/QuoteTests.cs
@@ -0,0 +1,29 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class QuoteTests
+	{
+		[Fact]
+		public void QuoteTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(QuoteTestClass));
+			Assert.Equal('x', config.Quote);
+		}
+
+		[Quote('x')]
+		private class QuoteTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ReferenceTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ReferenceTests.cs
new file mode 100644
index 0000000..97c64a0
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/ReferenceTests.cs
@@ -0,0 +1,43 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration.Attributes;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class ReferenceTests
+	{
+		[Fact]
+		public void ReferenceTest()
+		{
+			using (var reader = new StringReader("id,name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<ReferenceTestClassA>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].B.Name);
+			}
+		}
+
+		private class ReferenceTestClassA
+		{
+			[Name("id")]
+			public int Id { get; set; }
+
+			public ReferenceTestClassB B { get; set; }
+		}
+
+		private class ReferenceTestClassB
+		{
+			[Name("name")]
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/TrimOptionsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/TrimOptionsTests.cs
new file mode 100644
index 0000000..6e7595f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/TrimOptionsTests.cs
@@ -0,0 +1,31 @@
+// Copyright 2009-2015 Josh Close and Contributors
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// http://csvhelper.com
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.AttributeMapping
+{
+	public class TrimOptionsTests
+	{
+		[Fact]
+		public void TrimOptionsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(TrimOptionsTestClass));
+			Assert.Equal(TrimOptions.InsideQuotes, config.TrimOptions);
+		}
+
+		[TrimOptions(TrimOptions.InsideQuotes)]
+		private class TrimOptionsTestClass
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/TypeConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/TypeConverterTests.cs
new file mode 100644
index 0000000..afa2cd9
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/TypeConverterTests.cs
@@ -0,0 +1,125 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	
+	public class TypeConverterTests
+	{
+		[Fact]
+		public void TypeConverterTest()
+		{
+			using (var reader = new StringReader("Id,Name\r\n1,one\r\n"))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				var records = csv.GetRecords<TypeConverterClass>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("two", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void TypeConverterOnClassReferenceTest()
+		{
+			var records = new List<AClass>
+			{
+				new AClass { Id = 1, Name = new BClass() },
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = "Id,Name\r\n1,two\r\n";
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void TypeConverterOnStructReferenceTest()
+		{
+			var records = new List<AStruct>
+			{
+				new AStruct { Id = 1, Name = new BStruct() },
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = "Id,Name\r\n1,two\r\n";
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void Constructor_TypeConverterWithConstructorArgs_Creates()
+		{
+			var attribute = new TypeConverterAttribute(typeof(TypeConverterWithConstructorArgs), 2);
+			Assert.IsType<TypeConverterWithConstructorArgs>(attribute.TypeConverter);
+			Assert.Equal(2, ((TypeConverterWithConstructorArgs)attribute.TypeConverter).Value);
+		}
+
+		private class TypeConverterClass
+		{
+			public int Id { get; set; }
+
+			[TypeConverter(typeof(StringTypeConverter))]
+			public string Name { get; set; }
+		}
+
+		private class StringTypeConverter : ITypeConverter
+		{
+			public object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
+			{
+				return "two";
+			}
+
+			public string ConvertToString(object value, IWriterRow row, MemberMapData memberMapData)
+			{
+				return "two";
+			}
+		}
+
+		private class AClass
+		{
+			public int Id { get; set; }
+			[TypeConverter(typeof(StringTypeConverter))]
+			public BClass Name { get; set; }
+		}
+
+		private class BClass { }
+
+		private class AStruct
+		{
+			public int Id { get; set; }
+			[TypeConverter(typeof(StringTypeConverter))]
+			public BStruct Name { get; set; }
+		}
+
+		private class BStruct { }
+
+		private class TypeConverterWithConstructorArgs : DefaultTypeConverter
+		{
+			public int Value { get; private set; }
+
+			public TypeConverterWithConstructorArgs(int value)
+			{
+				Value = value;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/UseNewObjectForNullReferenceMembersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/UseNewObjectForNullReferenceMembersTests.cs
new file mode 100644
index 0000000..d560872
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/UseNewObjectForNullReferenceMembersTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class UseNewObjectForNullReferenceMembersTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.False(config.UseNewObjectForNullReferenceMembers);
+		}
+
+		[UseNewObjectForNullReferenceMembers(false)]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/WhiteSpaceCharsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/WhiteSpaceCharsTests.cs
new file mode 100644
index 0000000..3abb027
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Attribute/WhiteSpaceCharsTests.cs
@@ -0,0 +1,20 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings.Attribute
+{
+	public class WhiteSpaceCharsTests
+	{
+		[Fact]
+		public void ConstructorAttributeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture, typeof(Foo));
+			Assert.Equal(new[] { 'a', 'b' }, config.WhiteSpaceChars);
+		}
+
+		[WhiteSpaceChars("a b")]
+		private class Foo { }
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanFalseValuesAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanFalseValuesAttributeTests.cs
new file mode 100644
index 0000000..d05b601
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanFalseValuesAttributeTests.cs
@@ -0,0 +1,110 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class BooleanFalseValuesAttributeTests
+	{
+		[Fact]
+		public void AutoMap_WithBooleanFalseValuesAttribute_CreatesParameterMaps()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Empty(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.TypeConverterOptions.BooleanFalseValues[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "boolean" },
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.False(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.False(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithBooleanFalseValuesAttribute_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, false),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Boolean\r\n");
+				expected.Append("1,False\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public bool Boolean { get; private set; }
+
+			public Foo(int id, [BooleanFalseValues("Bar")] bool boolean)
+			{
+				Id = id;
+				Boolean = boolean;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanFalseValuesMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanFalseValuesMapTests.cs
new file mode 100644
index 0000000..c477a17
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanFalseValuesMapTests.cs
@@ -0,0 +1,125 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class BooleanFalseValuesMapTests
+	{
+		[Fact]
+		public void AutoMap_WithBooleanFalseValuesAttribute_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("boolean").TypeConverterOption.BooleanValues(false, true, "Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Empty(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.TypeConverterOptions.BooleanFalseValues[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "boolean" },
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.False(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.False(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithBooleanFalseValuesAttribute_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, false),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Boolean\r\n");
+				expected.Append("1,False\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public bool Boolean { get; private set; }
+
+			public Foo(int id, bool boolean)
+			{
+				Id = id;
+				Boolean = boolean;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Boolean);
+				Parameter("id");
+				Parameter("boolean").TypeConverterOption.BooleanValues(false, true, "Bar");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanTrueValuesAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanTrueValuesAttributeTests.cs
new file mode 100644
index 0000000..4149e9d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanTrueValuesAttributeTests.cs
@@ -0,0 +1,110 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class BooleanTrueValuesAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithBooleanTrueValuesAttribute_CreatesParameterMaps()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Empty(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanTrueValuesAttribute_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "boolean" },
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.True(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanTrueValuesAttribute_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.True(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithBooleanTrueValuesAttribute_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, true),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Boolean\r\n");
+				expected.Append("1,True\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public bool Boolean { get; private set; }
+
+			public Foo(int id, [BooleanTrueValues("Bar")]bool boolean)
+			{
+				Id = id;
+				Boolean = boolean;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanTrueValuesMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanTrueValuesMapTests.cs
new file mode 100644
index 0000000..318b439
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/BooleanTrueValuesMapTests.cs
@@ -0,0 +1,125 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class BooleanTrueValuesMapTests
+	{
+		[Fact]
+		public void AutoMap_WithBooleanFalseValuesAttribute_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("boolean").TypeConverterOption.BooleanValues(true, true, "Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues);
+			Assert.Empty(map.ParameterMaps[1].Data.TypeConverterOptions.BooleanFalseValues);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "boolean" },
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.True(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "Bar" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.True(records[0].Boolean);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithBooleanFalseValuesAttribute_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, true),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Boolean\r\n");
+				expected.Append("1,True\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public bool Boolean { get; private set; }
+
+			public Foo(int id, bool boolean)
+			{
+				Id = id;
+				Boolean = boolean;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Boolean);
+				Parameter("id");
+				Parameter("boolean").TypeConverterOption.BooleanValues(true, true, "Bar");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/ConstantAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/ConstantAttributeTests.cs
new file mode 100644
index 0000000..bf42bdc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/ConstantAttributeTests.cs
@@ -0,0 +1,109 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class ConstantAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithConstantAttributes_ConfiguresParameterMaps()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsConstantSet);
+			Assert.Null(map.ParameterMaps[0].Data.Constant);
+			Assert.True(map.ParameterMaps[1].Data.IsConstantSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Constant);
+		}
+
+		[Fact]
+		public void GetRecords_WithConstantAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithConstantAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithConstantAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, [Constant("Bar")] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/ConstantMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/ConstantMapTests.cs
new file mode 100644
index 0000000..523f383
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/ConstantMapTests.cs
@@ -0,0 +1,193 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class ConstantMapTests
+	{
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("name").Constant("Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsConstantSet);
+			Assert.True(map.ParameterMaps[1].Data.IsConstantSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Constant);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").Constant("Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsConstantSet);
+			Assert.True(map.ParameterMaps[1].Data.IsConstantSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Constant);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).Constant("Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsConstantSet);
+			Assert.True(map.ParameterMaps[1].Data.IsConstantSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Constant);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_FieldMissing_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id" },
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_FieldMissing_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id");
+				Parameter("name").Constant("Bar");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/CultureInfoAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/CultureInfoAttributeTests.cs
new file mode 100644
index 0000000..a76883d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/CultureInfoAttributeTests.cs
@@ -0,0 +1,119 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Threading;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class CultureInfoAttributeTests
+    {
+		private const decimal AMOUNT = 123_456.789M;
+		private const string CULTURE = "fr-FR";
+		private readonly string amount = AMOUNT.ToString(new CultureInfo(CULTURE));
+
+		[Fact]
+		public void AutoMap_WithCultureInfoAttributes_ConfiguresParameterMaps()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.CultureInfo);
+			Assert.Equal(new CultureInfo(CULTURE), map.ParameterMaps[1].Data.TypeConverterOptions.CultureInfo);
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "amount" },
+				{ "1", amount },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(AMOUNT, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", amount },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(AMOUNT, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithCultureInfoAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, AMOUNT),
+			};
+
+			var prevCulture = Thread.CurrentThread.CurrentCulture;
+			try {
+				Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
+				using (var writer = new StringWriter())
+				using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+				{
+					csv.WriteRecords(records);
+
+					var expected = new StringBuilder();
+					expected.Append("Id,Amount\r\n");
+					expected.Append($"1,{AMOUNT}\r\n");
+
+					Assert.Equal(expected.ToString(), writer.ToString());
+				}
+			} finally {
+				Thread.CurrentThread.CurrentCulture = prevCulture;
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public decimal Amount { get; private set; }
+
+			public Foo(int id, [CultureInfo(CULTURE)] decimal amount)
+			{
+				Id = id;
+				Amount = amount;
+			}
+		}
+
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/CultureInfoMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/CultureInfoMapTests.cs
new file mode 100644
index 0000000..71ae189
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/CultureInfoMapTests.cs
@@ -0,0 +1,160 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Threading;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class CultureInfoMapTests
+    {
+		private const decimal AMOUNT = 123_456.789M;
+		private const string CULTURE = "fr-FR";
+		private readonly string amount = AMOUNT.ToString(new CultureInfo(CULTURE));
+
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("amount").TypeConverterOption.CultureInfo(new CultureInfo(CULTURE));
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.CultureInfo);
+			Assert.Equal(new CultureInfo(CULTURE), map.ParameterMaps[1].Data.TypeConverterOptions.CultureInfo);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "amount").TypeConverterOption.CultureInfo(new CultureInfo(CULTURE));
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.CultureInfo);
+			Assert.Equal(new CultureInfo(CULTURE), map.ParameterMaps[1].Data.TypeConverterOptions.CultureInfo);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).TypeConverterOption.CultureInfo(new CultureInfo(CULTURE));
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.CultureInfo);
+			Assert.Equal(new CultureInfo(CULTURE), map.ParameterMaps[1].Data.TypeConverterOptions.CultureInfo);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "amount" },
+				{ "1", amount },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(AMOUNT, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", amount },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(AMOUNT, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, AMOUNT),
+			};
+
+			var prevCulture = Thread.CurrentThread.CurrentCulture;
+			try {
+				Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
+				using (var writer = new StringWriter())
+				using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+				{
+					csv.Context.RegisterClassMap<FooMap>();
+
+					csv.WriteRecords(records);
+
+					var expected = new StringBuilder();
+					expected.Append("Id,Amount\r\n");
+					expected.Append($"1,{AMOUNT}\r\n");
+
+					Assert.Equal(expected.ToString(), writer.ToString());
+			}
+			} finally {
+				Thread.CurrentThread.CurrentCulture = prevCulture;
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public decimal Amount { get; private set; }
+
+			public Foo(int id, decimal amount)
+			{
+				Id = id;
+				Amount = amount;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Amount);
+				Parameter("id");
+				Parameter("amount").TypeConverterOption.CultureInfo(new CultureInfo(CULTURE));
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DateTimeStylesAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DateTimeStylesAttributeTests.cs
new file mode 100644
index 0000000..7207853
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DateTimeStylesAttributeTests.cs
@@ -0,0 +1,109 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class DateTimeStylesAttributeTests
+	{
+		private const string DATE = "12/25/2020";
+		private readonly DateTimeOffset date = DateTimeOffset.Parse(DATE, CultureInfo.InvariantCulture);
+
+		[Fact]
+		public void AutoMap_WithCultureInfoAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.DateTimeStyle);
+			Assert.Equal(DateTimeStyles.AllowLeadingWhite, map.ParameterMaps[1].Data.TypeConverterOptions.DateTimeStyle);
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "date" },
+				{ "1", $" {DATE}" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", $" {DATE}" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithCultureInfoAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, date),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Date\r\n");
+				expected.Append($"1,{date.ToString(null, CultureInfo.InvariantCulture)}\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public DateTimeOffset Date { get; private set; }
+
+			public Foo(int id, [DateTimeStyles(DateTimeStyles.AllowLeadingWhite)] DateTimeOffset date)
+			{
+				Id = id;
+				Date = date;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DateTimeStylesMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DateTimeStylesMapTests.cs
new file mode 100644
index 0000000..d94b75f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DateTimeStylesMapTests.cs
@@ -0,0 +1,152 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class DateTimeStylesMapTests
+	{
+		private const string DATE = "12/25/2020";
+		private readonly DateTimeOffset date = DateTimeOffset.Parse(DATE, CultureInfo.InvariantCulture);
+
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("date").TypeConverterOption.DateTimeStyles(DateTimeStyles.AllowLeadingWhite);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.DateTimeStyle);
+			Assert.Equal(DateTimeStyles.AllowLeadingWhite, map.ParameterMaps[1].Data.TypeConverterOptions.DateTimeStyle);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "date").TypeConverterOption.DateTimeStyles(DateTimeStyles.AllowLeadingWhite);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.DateTimeStyle);
+			Assert.Equal(DateTimeStyles.AllowLeadingWhite, map.ParameterMaps[1].Data.TypeConverterOptions.DateTimeStyle);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).TypeConverterOption.DateTimeStyles(DateTimeStyles.AllowLeadingWhite);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.DateTimeStyle);
+			Assert.Equal(DateTimeStyles.AllowLeadingWhite, map.ParameterMaps[1].Data.TypeConverterOptions.DateTimeStyle);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "date" },
+				{ "1", DATE },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", DATE },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, date),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Date\r\n");
+				expected.Append($"1,{date.ToString(null, CultureInfo.InvariantCulture)}\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public DateTimeOffset Date { get; private set; }
+
+			public Foo(int id, DateTimeOffset date)
+			{
+				Id = id;
+				Date = date;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Date);
+				Parameter("id");
+				Parameter("date").TypeConverterOption.DateTimeStyles(DateTimeStyles.AllowLeadingWhite);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DefaultAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DefaultAttributeTests.cs
new file mode 100644
index 0000000..226878d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DefaultAttributeTests.cs
@@ -0,0 +1,108 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class DefaultAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithDefaultAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsDefaultSet);
+			Assert.Null(map.ParameterMaps[0].Data.Default);
+			Assert.True(map.ParameterMaps[1].Data.IsDefaultSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Default);
+		}
+
+		[Fact]
+		public void GetRecords_WithDefaultAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "name" },
+				{ "1", "" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithDefaultAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithDefaultAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, [Default("Bar")] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DefaultMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DefaultMapTests.cs
new file mode 100644
index 0000000..3b6f76d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/DefaultMapTests.cs
@@ -0,0 +1,152 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class DefaultMapTests
+    {
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("name").Default("Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsDefaultSet);
+			Assert.True(map.ParameterMaps[1].Data.IsDefaultSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Default);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").Default("Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsDefaultSet);
+			Assert.True(map.ParameterMaps[1].Data.IsDefaultSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Default);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).Default("Bar");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsDefaultSet);
+			Assert.True(map.ParameterMaps[1].Data.IsDefaultSet);
+			Assert.Equal("Bar", map.ParameterMaps[1].Data.Default);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "name" },
+				{ "1", "" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id");
+				Parameter("name").Default("Bar");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/EnumIgnoreCaseTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/EnumIgnoreCaseTests.cs
new file mode 100644
index 0000000..af23233
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/EnumIgnoreCaseTests.cs
@@ -0,0 +1,113 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class EnumIgnoreCaseTests
+    {
+		[Fact]
+		public void AutoMap_WithEnumIgnoreCaseAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal("id", map.ParameterMaps[0].Data.Names.First());
+			Assert.Equal("bar", map.ParameterMaps[1].Data.Names.First());
+			Assert.True(map.ParameterMaps[1].Data.TypeConverterOptions.EnumIgnoreCase.GetValueOrDefault());
+		}
+
+		[Fact]
+		public void GetRecords_WithEnumIgnoreCaseAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "bar" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(Bar.One, records[0].Bar);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithEnumIgnoreCaseAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(Bar.One, records[0].Bar);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithIgnoreAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, Bar.None),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Bar\r\n");
+				expected.Append("1,None\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public Bar Bar { get; private set; }
+
+			public Foo(int id, [EnumIgnoreCase] Bar bar)
+			{
+				Id = id;
+				Bar = bar;
+			}
+		}
+
+		private enum Bar
+		{
+			None = 0,
+			One = 1
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/FormatAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/FormatAttributeTests.cs
new file mode 100644
index 0000000..b3fa1ac
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/FormatAttributeTests.cs
@@ -0,0 +1,111 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class FormatAttributeTests
+    {
+		private const string FORMAT = "MM|dd|yyyy";
+		private const string DATE = "12|25|2020";
+		private readonly DateTimeOffset date = DateTimeOffset.ParseExact(DATE, FORMAT, CultureInfo.InvariantCulture, DateTimeStyles.None);
+
+		[Fact]
+		public void AutoMap_WithCultureInfoAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.Formats);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.Formats);
+			Assert.Equal(FORMAT, map.ParameterMaps[1].Data.TypeConverterOptions.Formats[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "date" },
+				{ "1", DATE },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", DATE },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithCultureInfoAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, date),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Date\r\n");
+				expected.Append($"1,{date.ToString(null, CultureInfo.InvariantCulture)}\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public DateTimeOffset Date { get; private set; }
+
+			public Foo(int id, [Format(FORMAT)] DateTimeOffset date)
+			{
+				Id = id;
+				Date = date;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/FormatMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/FormatMapTests.cs
new file mode 100644
index 0000000..673a1f7
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/FormatMapTests.cs
@@ -0,0 +1,156 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class FormatMapTests
+    {
+		private const string FORMAT = "MM|dd|yyyy";
+		private const string DATE = "12|25|2020";
+		private readonly DateTimeOffset date = DateTimeOffset.ParseExact(DATE, FORMAT, CultureInfo.InvariantCulture, DateTimeStyles.None);
+
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("date").TypeConverterOption.Format(FORMAT);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.Formats);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.Formats);
+			Assert.Equal(FORMAT, map.ParameterMaps[1].Data.TypeConverterOptions.Formats[0]);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "date").TypeConverterOption.Format(FORMAT);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.Formats);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.Formats);
+			Assert.Equal(FORMAT, map.ParameterMaps[1].Data.TypeConverterOptions.Formats[0]);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).TypeConverterOption.Format(FORMAT);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.Formats);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.Formats);
+			Assert.Equal(FORMAT, map.ParameterMaps[1].Data.TypeConverterOptions.Formats[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "date" },
+				{ "1", DATE },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", DATE },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(date, records[0].Date);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, date),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Date\r\n");
+				expected.Append($"1,{date.ToString(null, CultureInfo.InvariantCulture)}\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public DateTimeOffset Date { get; private set; }
+
+			public Foo(int id, DateTimeOffset date)
+			{
+				Id = id;
+				Date = date;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Date);
+				Parameter("id");
+				Parameter("date").TypeConverterOption.Format(FORMAT);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/HeaderPrefixAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/HeaderPrefixAttributeTests.cs
new file mode 100644
index 0000000..051f9f5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/HeaderPrefixAttributeTests.cs
@@ -0,0 +1,111 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class HeaderPrefixAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithCultureInfoAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].ReferenceMap);
+			Assert.Equal("Bar_", map.ParameterMaps[1].ReferenceMap.Data.Prefix);
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "Bar_Name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Bar.Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Bar.Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithCultureInfoAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, new Bar { Name = "one" }),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public Bar Bar { get; private set; }
+
+			public Foo(int id, [HeaderPrefix("Bar_")]Bar bar)
+			{
+				Id = id;
+				Bar = bar;
+			}
+		}
+
+		private class Bar
+		{
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/HeaderPrefixMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/HeaderPrefixMapTests.cs
new file mode 100644
index 0000000..4c5e0be
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/HeaderPrefixMapTests.cs
@@ -0,0 +1,6 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+
+// It doesn't make sense to map a prefix as you would just set the header name you want including the prefix.
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IgnoreAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IgnoreAttributeTests.cs
new file mode 100644
index 0000000..3ee4cd9
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IgnoreAttributeTests.cs
@@ -0,0 +1,106 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class IgnoreAttributeTests
+	{
+		[Fact]
+		public void AutoMap_WithIgnoreAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal("id", map.ParameterMaps[0].Data.Names.First());
+			Assert.Equal("name", map.ParameterMaps[1].Data.Names.First());
+			Assert.True(map.ParameterMaps[1].Data.Ignore);
+		}
+
+		[Fact]
+		public void GetRecords_WithIgnoreAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id" },
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithIgnoreAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithIgnoreAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, [CsvHelper.Configuration.Attributes.Ignore] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IgnoreMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IgnoreMapTests.cs
new file mode 100644
index 0000000..247f4ab
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IgnoreMapTests.cs
@@ -0,0 +1,150 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class IgnoreMapTests
+    {
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("name").Ignore();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.Ignore);
+			Assert.True(map.ParameterMaps[1].Data.Ignore);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").Ignore();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.Ignore);
+			Assert.True(map.ParameterMaps[1].Data.Ignore);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).Ignore();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.Ignore);
+			Assert.True(map.ParameterMaps[1].Data.Ignore);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id" },
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id");
+				Parameter("name").Ignore();
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IndexAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IndexAttributeTests.cs
new file mode 100644
index 0000000..b2a236c
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IndexAttributeTests.cs
@@ -0,0 +1,106 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class IndexAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithIndexAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.Index);
+			Assert.Equal(1, map.ParameterMaps[1].Data.Index);
+		}
+
+		[Fact]
+		public void GetRecords_WithIndexAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithIndexAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithIndexAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo([Index(0)] int id, [Index(1)] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IndexMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IndexMapTests.cs
new file mode 100644
index 0000000..fcb4c6e
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/IndexMapTests.cs
@@ -0,0 +1,149 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class IndexMapTests
+    {
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id").Index(0);
+			map.Parameter("name").Index(1);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.Index);
+			Assert.Equal(1, map.ParameterMaps[1].Data.Index);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id").Index(0);
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").Index(1);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.Index);
+			Assert.Equal(1, map.ParameterMaps[1].Data.Index);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]).Index(0);
+			map.Parameter(constructor, parameters[1]).Index(1);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.Index);
+			Assert.Equal(1, map.ParameterMaps[1].Data.Index);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id").Index(0);
+				Parameter("name").Index(1);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameAttributeTests.cs
new file mode 100644
index 0000000..25c3586
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameAttributeTests.cs
@@ -0,0 +1,85 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class NameAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithNameAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal("Id", map.ParameterMaps[0].Data.Names[0]);
+			Assert.Equal("Name", map.ParameterMaps[1].Data.Names[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithNameAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithNameAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo([Name("Id")] int id, [Name("Name")] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameIndexAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameIndexAttributeTests.cs
new file mode 100644
index 0000000..55f009f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameIndexAttributeTests.cs
@@ -0,0 +1,85 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class NameIndexAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithNameAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.NameIndex);
+			Assert.Equal(1, map.ParameterMaps[1].Data.NameIndex);
+		}
+
+		[Fact]
+		public void GetRecords_WithNameAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name", "Name" },
+				{ "1", "", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithNameAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo([Name("Id")]int id, [Name("Name")][NameIndex(1)] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameIndexMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameIndexMapTests.cs
new file mode 100644
index 0000000..5c8ed87
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameIndexMapTests.cs
@@ -0,0 +1,126 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class NameIndexMapTests
+    {
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id").NameIndex(0);
+			map.Parameter("name").NameIndex(1);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.NameIndex);
+			Assert.Equal(1, map.ParameterMaps[1].Data.NameIndex);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id").NameIndex(0);
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").NameIndex(1);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.NameIndex);
+			Assert.Equal(1, map.ParameterMaps[1].Data.NameIndex);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]).NameIndex(0);
+			map.Parameter(constructor, parameters[1]).NameIndex(1);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal(0, map.ParameterMaps[0].Data.NameIndex);
+			Assert.Equal(1, map.ParameterMaps[1].Data.NameIndex);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name", "Name" },
+				{ "1", "", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id").Name("Id");
+				Parameter("name").Name("Name").NameIndex(1);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameMapTests.cs
new file mode 100644
index 0000000..0413be7
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NameMapTests.cs
@@ -0,0 +1,126 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class NameMapTests
+    {
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id").Name("Id");
+			map.Parameter("name").Name("Name");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal("Id", map.ParameterMaps[0].Data.Names[0]);
+			Assert.Equal("Name", map.ParameterMaps[1].Data.Names[0]);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id").Name("Id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").Name("Name");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal("Id", map.ParameterMaps[0].Data.Names[0]);
+			Assert.Equal("Name", map.ParameterMaps[1].Data.Names[0]);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]).Name("Id");
+			map.Parameter(constructor, parameters[1]).Name("Name");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Equal("Id", map.ParameterMaps[0].Data.Names[0]);
+			Assert.Equal("Name", map.ParameterMaps[1].Data.Names[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id").Name("Id");
+				Parameter("name").Name("Name");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NullValuesAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NullValuesAttributeTests.cs
new file mode 100644
index 0000000..0f9dd76
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NullValuesAttributeTests.cs
@@ -0,0 +1,107 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class NullValuesAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithBooleanFalseValuesAttribute_CreatesParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.NullValues);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.NullValues);
+			Assert.Equal("NULL", map.ParameterMaps[1].Data.TypeConverterOptions.NullValues[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "name" },
+				{ "1", "NULL" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "NULL" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithBooleanFalseValuesAttribute_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, [NullValues("NULL")] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NullValuesMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NullValuesMapTests.cs
new file mode 100644
index 0000000..2362248
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NullValuesMapTests.cs
@@ -0,0 +1,122 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class NullValuesMapTests
+    {
+		[Fact]
+		public void AutoMap_WithBooleanFalseValuesAttribute_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("name").TypeConverterOption.NullValues("NULL");
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.NullValues);
+			Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.NullValues);
+			Assert.Equal("NULL", map.ParameterMaps[1].Data.TypeConverterOptions.NullValues[0]);
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				new [] { "id", "name" },
+				new [] { "1", "NULL" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithBooleanFalseValuesAttribute_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "NULL" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithBooleanFalseValuesAttribute_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id");
+				Parameter("name").TypeConverterOption.NullValues("NULL");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NumberStylesAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NumberStylesAttributeTests.cs
new file mode 100644
index 0000000..c805b41
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NumberStylesAttributeTests.cs
@@ -0,0 +1,108 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class NumberStylesAttributeTests
+    {
+		private const decimal amount = 123;
+
+		[Fact]
+		public void AutoMap_WithCultureInfoAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.NumberStyles);
+			Assert.Equal(NumberStyles.AllowParentheses, map.ParameterMaps[1].Data.TypeConverterOptions.NumberStyles);
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "amount" },
+				{ "1", $"({amount})" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(-amount, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithCultureInfoAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", $"({amount})" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(-amount, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithCultureInfoAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, amount),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Amount\r\n");
+				expected.Append($"1,{amount}\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public decimal Amount { get; private set; }
+
+			public Foo(int id, [NumberStyles(NumberStyles.AllowParentheses)] decimal amount)
+			{
+				Id = id;
+				Amount = amount;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NumberStylesMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NumberStylesMapTests.cs
new file mode 100644
index 0000000..19fdae8
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/NumberStylesMapTests.cs
@@ -0,0 +1,151 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class NumberStylesMapTests
+    {
+		private const decimal amount = 123;
+
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("amount").TypeConverterOption.NumberStyles(NumberStyles.AllowParentheses);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.NumberStyles);
+			Assert.Equal(NumberStyles.AllowParentheses, map.ParameterMaps[1].Data.TypeConverterOptions.NumberStyles);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "amount").TypeConverterOption.NumberStyles(NumberStyles.AllowParentheses);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.NumberStyles);
+			Assert.Equal(NumberStyles.AllowParentheses, map.ParameterMaps[1].Data.TypeConverterOptions.NumberStyles);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).TypeConverterOption.NumberStyles(NumberStyles.AllowParentheses);
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.NumberStyles);
+			Assert.Equal(NumberStyles.AllowParentheses, map.ParameterMaps[1].Data.TypeConverterOptions.NumberStyles);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "amount" },
+				{ "1", $"({amount})" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(-amount, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", $"({amount})" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal(-amount, records[0].Amount);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, amount),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Amount\r\n");
+				expected.Append($"1,{amount}\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public decimal Amount { get; private set; }
+
+			public Foo(int id, decimal amount)
+			{
+				Id = id;
+				Amount = amount;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Amount);
+				Parameter("id");
+				Parameter("amount").TypeConverterOption.NumberStyles(NumberStyles.AllowParentheses);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/OptionalAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/OptionalAttributeTests.cs
new file mode 100644
index 0000000..2e7b8b4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/OptionalAttributeTests.cs
@@ -0,0 +1,106 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class OptionalAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithConstantAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsOptional);
+			Assert.True(map.ParameterMaps[1].Data.IsOptional);
+		}
+
+		[Fact]
+		public void GetRecords_WithConstantAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id" },
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithConstantAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithConstantAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, [Optional] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/OptionalMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/OptionalMapTests.cs
new file mode 100644
index 0000000..bae94d1
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/OptionalMapTests.cs
@@ -0,0 +1,150 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class OptionalMapTests
+    {
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("name").Optional();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsOptional);
+			Assert.True(map.ParameterMaps[1].Data.IsOptional);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").Optional();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsOptional);
+			Assert.True(map.ParameterMaps[1].Data.IsOptional);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).Optional();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.False(map.ParameterMaps[0].Data.IsOptional);
+			Assert.True(map.ParameterMaps[1].Data.IsOptional);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id" },
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id");
+				Parameter("name").Optional();
+			}
+		}
+
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/TypeConverterAttributeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/TypeConverterAttributeTests.cs
new file mode 100644
index 0000000..4d6cd2a
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/TypeConverterAttributeTests.cs
@@ -0,0 +1,115 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+	public class TypeConverterAttributeTests
+    {
+		[Fact]
+		public void AutoMap_WithConstantAttributes_ConfiguresParameterMaps()
+		{
+			var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture));
+			var map = context.AutoMap<Foo>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.IsType<Int32Converter>(map.ParameterMaps[0].Data.TypeConverter);
+			Assert.IsType<CustomConverter>(map.ParameterMaps[1].Data.TypeConverter);
+		}
+
+		[Fact]
+		public void GetRecords_WithConstantAttributes_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithConstantAttributes_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithConstantAttributes_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, null),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, [TypeConverter(typeof(CustomConverter))] string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class CustomConverter : DefaultTypeConverter
+		{
+			public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
+			{
+				return "Bar";
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/TypeConverterMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/TypeConverterMapTests.cs
new file mode 100644
index 0000000..98bc4dd
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ConstructorParameter/TypeConverterMapTests.cs
@@ -0,0 +1,158 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.ConstructorParameter
+{
+	
+    public class TypeConverterMapTests
+    {
+		[Fact]
+		public void Parameter_WithName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter("id");
+			map.Parameter("name").TypeConverter<CustomConverter>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverter);
+			Assert.IsType<CustomConverter>(map.ParameterMaps[1].Data.TypeConverter);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
+		{
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
+			map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").TypeConverter<CustomConverter>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverter);
+			Assert.IsType<CustomConverter>(map.ParameterMaps[1].Data.TypeConverter);
+		}
+
+		[Fact]
+		public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
+		{
+			var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
+			var parameters = constructor.GetParameters();
+
+			var map = new DefaultClassMap<Foo>();
+			map.Parameter(constructor, parameters[0]);
+			map.Parameter(constructor, parameters[1]).TypeConverter<CustomConverter>();
+
+			Assert.Equal(2, map.ParameterMaps.Count);
+			Assert.Null(map.ParameterMaps[0].Data.TypeConverter);
+			Assert.IsType<CustomConverter>(map.ParameterMaps[1].Data.TypeConverter);
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
+		{
+			var parser = new ParserMock
+			{
+				{ "id", "name" },
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var map = csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_WithParameterMap_DoesntUseParameterMaps()
+		{
+			var records = new List<Foo>
+			{
+				new Foo(1, "one"),
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+
+				csv.WriteRecords(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Parameter("id");
+				Parameter("name").TypeConverter<CustomConverter>();
+			}
+		}
+
+		private class CustomConverter : DefaultTypeConverter
+		{
+			public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
+			{
+				return "Bar";
+			}
+		}
+ 	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/CsvClassMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/CsvClassMappingTests.cs
new file mode 100644
index 0000000..dc10243
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/CsvClassMappingTests.cs
@@ -0,0 +1,239 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class CsvClassMappingTests
+	{
+		[Fact]
+		public void MapTest()
+		{
+			var map = new TestMappingDefaultClass();
+			//map.CreateMap();
+
+			Assert.Equal(3, map.MemberMaps.Count);
+
+			Assert.Equal(0, map.MemberMaps[0].Data.Names.Count);
+			Assert.Equal(0, map.MemberMaps[0].Data.Index);
+			Assert.Null(map.MemberMaps[0].Data.TypeConverter);
+
+			Assert.Equal(0, map.MemberMaps[1].Data.Names.Count);
+			Assert.Equal(1, map.MemberMaps[1].Data.Index);
+			Assert.Null(map.MemberMaps[1].Data.TypeConverter);
+
+			Assert.Equal(0, map.MemberMaps[2].Data.Names.Count);
+			Assert.Equal(2, map.MemberMaps[2].Data.Index);
+			Assert.Null(map.MemberMaps[2].Data.TypeConverter);
+		}
+
+		[Fact]
+		public void MapNameTest()
+		{
+			var map = new TestMappingNameClass();
+			//map.CreateMap();
+
+			Assert.Equal(3, map.MemberMaps.Count);
+
+			Assert.Equal("Guid Column", map.MemberMaps[0].Data.Names.FirstOrDefault());
+			Assert.Equal("Int Column", map.MemberMaps[1].Data.Names.FirstOrDefault());
+			Assert.Equal("String Column", map.MemberMaps[2].Data.Names.FirstOrDefault());
+		}
+
+		[Fact]
+		public void MapIndexTest()
+		{
+			var map = new TestMappingIndexClass();
+			//map.CreateMap();
+
+			Assert.Equal(3, map.MemberMaps.Count);
+
+			Assert.Equal(2, map.MemberMaps[0].Data.Index);
+			Assert.Equal(3, map.MemberMaps[1].Data.Index);
+			Assert.Equal(1, map.MemberMaps[2].Data.Index);
+		}
+
+		[Fact]
+		public void MapIgnoreTest()
+		{
+			var map = new TestMappingIgnoreClass();
+			//map.CreateMap();
+
+			Assert.Equal(3, map.MemberMaps.Count);
+
+			Assert.True(map.MemberMaps[0].Data.Ignore);
+			Assert.False(map.MemberMaps[1].Data.Ignore);
+			Assert.True(map.MemberMaps[2].Data.Ignore);
+		}
+
+		[Fact]
+		public void MapTypeConverterTest()
+		{
+			var map = new TestMappingTypeConverterClass();
+			//map.CreateMap();
+
+			Assert.Equal(3, map.MemberMaps.Count);
+
+			Assert.IsType<Int16Converter>(map.MemberMaps[0].Data.TypeConverter);
+			Assert.IsType<StringConverter>(map.MemberMaps[1].Data.TypeConverter);
+			Assert.IsType<Int64Converter>(map.MemberMaps[2].Data.TypeConverter);
+		}
+
+		[Fact]
+		public void MapMultipleNamesTest()
+		{
+			var map = new TestMappingMultipleNamesClass();
+			//map.CreateMap();
+
+			Assert.Equal(3, map.MemberMaps.Count);
+
+			Assert.Equal(3, map.MemberMaps[0].Data.Names.Count);
+			Assert.Equal(3, map.MemberMaps[1].Data.Names.Count);
+			Assert.Equal(3, map.MemberMaps[2].Data.Names.Count);
+
+			Assert.Equal("guid1", map.MemberMaps[0].Data.Names[0]);
+			Assert.Equal("guid2", map.MemberMaps[0].Data.Names[1]);
+			Assert.Equal("guid3", map.MemberMaps[0].Data.Names[2]);
+
+			Assert.Equal("int1", map.MemberMaps[1].Data.Names[0]);
+			Assert.Equal("int2", map.MemberMaps[1].Data.Names[1]);
+			Assert.Equal("int3", map.MemberMaps[1].Data.Names[2]);
+
+			Assert.Equal("string1", map.MemberMaps[2].Data.Names[0]);
+			Assert.Equal("string2", map.MemberMaps[2].Data.Names[1]);
+			Assert.Equal("string3", map.MemberMaps[2].Data.Names[2]);
+		}
+
+		[Fact]
+		public void MapMultipleTypesTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			context.RegisterClassMap<AMap>();
+			context.RegisterClassMap<BMap>();
+
+			Assert.NotNull(context.Maps[typeof(A)]);
+			Assert.NotNull(context.Maps[typeof(B)]);
+		}
+
+		[Fact]
+		public void PropertyMapAccessTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			context.RegisterClassMap<AMap>();
+			context.Maps.Find<A>().Map(m => m.AId).Ignore();
+
+			Assert.True(context.Maps[typeof(A)].MemberMaps[0].Data.Ignore);
+		}
+
+		private class A
+		{
+			public int AId { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				Map(m => m.AId);
+			}
+		}
+
+		private class B
+		{
+			public int BId { get; set; }
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+			public BMap()
+			{
+				Map(m => m.BId);
+			}
+		}
+
+		private class TestClass
+		{
+			public string StringColumn { get; set; }
+			public int IntColumn { get; set; }
+			public Guid GuidColumn { get; set; }
+			public string NotUsedColumn { get; set; }
+
+			public TestClass() { }
+
+			public TestClass(string stringColumn)
+			{
+				StringColumn = stringColumn;
+			}
+		}
+
+		private sealed class TestMappingDefaultClass : ClassMap<TestClass>
+		{
+			public TestMappingDefaultClass()
+			{
+				Map(m => m.GuidColumn);
+				Map(m => m.IntColumn);
+				Map(m => m.StringColumn);
+			}
+		}
+
+		private sealed class TestMappingNameClass : ClassMap<TestClass>
+		{
+			public TestMappingNameClass()
+			{
+				Map(m => m.GuidColumn).Name("Guid Column");
+				Map(m => m.IntColumn).Name("Int Column");
+				Map(m => m.StringColumn).Name("String Column");
+			}
+		}
+
+		private sealed class TestMappingIndexClass : ClassMap<TestClass>
+		{
+			public TestMappingIndexClass()
+			{
+				Map(m => m.GuidColumn).Index(3);
+				Map(m => m.IntColumn).Index(2);
+				Map(m => m.StringColumn).Index(1);
+			}
+		}
+
+		private sealed class TestMappingIgnoreClass : ClassMap<TestClass>
+		{
+			public TestMappingIgnoreClass()
+			{
+				Map(m => m.GuidColumn).Ignore();
+				Map(m => m.IntColumn);
+				Map(m => m.StringColumn).Ignore();
+			}
+		}
+
+		private sealed class TestMappingTypeConverterClass : ClassMap<TestClass>
+		{
+			public TestMappingTypeConverterClass()
+			{
+				Map(m => m.GuidColumn).TypeConverter<Int16Converter>();
+				Map(m => m.IntColumn).TypeConverter<StringConverter>();
+				Map(m => m.StringColumn).TypeConverter(new Int64Converter());
+			}
+		}
+
+		private sealed class TestMappingMultipleNamesClass : ClassMap<TestClass>
+		{
+			public TestMappingMultipleNamesClass()
+			{
+				Map(m => m.GuidColumn).Name("guid1", "guid2", "guid3");
+				Map(m => m.IntColumn).Name("int1", "int2", "int3");
+				Map(m => m.StringColumn).Name("string1", "string2", "string3");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/FieldMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/FieldMappingTests.cs
new file mode 100644
index 0000000..3d52839
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/FieldMappingTests.cs
@@ -0,0 +1,397 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+#pragma warning disable 649
+
+namespace CsvHelper.Tests.Mappings
+{
+	
+	public class FieldMappingTests
+	{
+		[Fact]
+		public void ReadPublicFieldsWithAutoMapTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MemberTypes = MemberTypes.Fields,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("IdField,NameField");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<APublic>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].IdField);
+				Assert.Equal("one", records[0].BField.NameField);
+			}
+		}
+
+		[Fact]
+		public void WritePublicFieldsWithAutoMapTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MemberTypes = MemberTypes.Fields,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<APublic>
+				{
+					new APublic
+					{
+						IdField = 1,
+						BField = new BPublic
+						{
+							NameField = "one"
+						}
+					}
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("IdField,NameField");
+				expected.AppendLine("1,one");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void ReadPublicFieldsWithMappingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("IdField,NameField");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<APublicMap>();
+				var records = csv.GetRecords<APublic>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].IdField);
+				Assert.Equal("one", records[0].BField.NameField);
+			}
+		}
+
+		[Fact]
+		public void WritePublicFieldsWithMappingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<APublic>
+				{
+					new APublic
+					{
+						IdField = 1,
+						BField = new BPublic
+						{
+							NameField = "one"
+						}
+					}
+				};
+				csv.Context.RegisterClassMap<APublicMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("IdField,NameField");
+				expected.AppendLine("1,one");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void ReadPrivateFieldsWithAutoMapTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MemberTypes = MemberTypes.Fields,
+				IncludePrivateMembers = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("idField,nameField");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<APrivate>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].GetId());
+				Assert.Equal("one", records[0].GetB().GetName());
+			}
+		}
+
+		[Fact]
+		public void WritePrivateFieldsWithAutoMapTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MemberTypes = MemberTypes.Fields,
+				IncludePrivateMembers = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<APrivate>
+				{
+					new APrivate( 1, "one" )
+				};
+
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("idField,nameField");
+				expected.AppendLine("1,one");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void ReadPrivateFieldsWithMappingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("idField,nameField");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<APrivateMap>();
+				var records = csv.GetRecords<APrivate>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].GetId());
+				Assert.Equal("one", records[0].GetB().GetName());
+			}
+		}
+
+		[Fact]
+		public void WritePrivateFieldsWithMappingTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<APrivate>
+				{
+					new APrivate( 1, "one" )
+				};
+				csv.Context.RegisterClassMap<APrivateMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("idField,nameField");
+				expected.AppendLine("1,one");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void ReadPublicFieldsAndPropertiesWithAutoMapTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MemberTypes = MemberTypes.Properties | MemberTypes.Fields,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("IdField,NameField,IdProp,NameProp");
+				writer.WriteLine("1,one,2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<APublic>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].IdField);
+				Assert.Equal("one", records[0].BField.NameField);
+			}
+		}
+
+		[Fact]
+		public void WritePublicFieldsAndPropertiesWithAutoMapTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MemberTypes = MemberTypes.Properties | MemberTypes.Fields,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<APublic>
+				{
+					new APublic
+					{
+						IdField = 1,
+						BField = new BPublic
+						{
+							NameField = "one",
+							NameProp = "two"
+						},
+						IdProp = 2
+					}
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("IdProp,IdField,NameProp,NameField");
+				expected.AppendLine("2,1,two,one");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		private class APublic
+		{
+			public int IdField;
+			public BPublic BField;
+
+			public int IdProp { get; set; }
+		}
+
+		private class BPublic
+		{
+			public string NameField;
+
+			public string NameProp { get; set; }
+		}
+
+		private sealed class APublicMap : ClassMap<APublic>
+		{
+			public APublicMap()
+			{
+				Map(m => m.IdField);
+				References<BPublicMap>(m => m.BField);
+			}
+		}
+
+		private sealed class BPublicMap : ClassMap<BPublic>
+		{
+			public BPublicMap()
+			{
+				Map(m => m.NameField);
+			}
+		}
+
+		private class APrivate
+		{
+			private int idField;
+			private BPrivate bField;
+
+			private int IdProp { get; set; }
+			private BPrivate BProp { get; set; }
+
+			public int GetId()
+			{
+				return idField;
+			}
+
+			public BPrivate GetB()
+			{
+				return bField;
+			}
+
+			public APrivate() { }
+
+			public APrivate(int id, string name)
+			{
+				this.idField = id;
+				bField = new BPrivate(name);
+			}
+		}
+
+		private class BPrivate
+		{
+			private string nameField;
+
+			public string GetName()
+			{
+				return nameField;
+			}
+
+			public BPrivate() { }
+
+			public BPrivate(string name)
+			{
+				this.nameField = name;
+			}
+		}
+
+		private sealed class APrivateMap : ClassMap<APrivate>
+		{
+			public APrivateMap()
+			{
+				var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+				{
+					IncludePrivateMembers = true,
+					MemberTypes = MemberTypes.Fields
+				};
+				AutoMap(config);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/HiddenBaseMembersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/HiddenBaseMembersTests.cs
new file mode 100644
index 0000000..518bcd4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/HiddenBaseMembersTests.cs
@@ -0,0 +1,117 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings
+{
+	
+    public class HiddenBaseMembersTests
+    {
+		[Fact]
+		public void ReadWithAutoMapTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id" },
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parserMock))
+			{
+				var records = csv.GetRecords<Bar>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+			}
+		}
+
+		[Fact]
+        public void ReadWithClassMapTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id" },
+				{ "1" },
+			};
+			using (var csv = new CsvReader(parserMock))
+			{
+				csv.Context.RegisterClassMap<BarMap>();
+				var records = csv.GetRecords<Bar>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+			}
+		}
+
+		[Fact]
+		public void WriteWithAutoMapTest()
+		{
+			var records = new List<Bar>
+			{
+				new Bar { Id = 1 },
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id");
+				expected.AppendLine("1");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteWithClassMapTest()
+		{
+			var records = new List<Bar>
+			{
+				new Bar { Id = 1 },
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<BarMap>();
+				csv.WriteRecords(records);
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id");
+				expected.AppendLine("1");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private abstract class Foo
+		{
+			public string Id { get; set; }
+		}
+
+		private class Bar : Foo
+		{
+			public new int Id { get; set; }
+		}
+
+		private class BarMap : ClassMap<Bar>
+		{
+			public BarMap()
+			{
+				Map(m => m.Id);
+			}
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/IgnoreHeaderWhiteSpaceTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/IgnoreHeaderWhiteSpaceTests.cs
new file mode 100644
index 0000000..330ace9
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/IgnoreHeaderWhiteSpaceTests.cs
@@ -0,0 +1,52 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings
+{
+	
+	public class IgnoreHeaderWhiteSpaceTests
+	{
+		[Fact]
+		public void Blah()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("The Id,The Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Id).Name("The Id");
+				Map(m => m.Name).Name("The Name");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/MapConstructorTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/MapConstructorTests.cs
new file mode 100644
index 0000000..4429f1d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/MapConstructorTests.cs
@@ -0,0 +1,42 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings
+{
+	
+	public class MapConstructorTests
+	{
+		[Fact]
+		public void NoConstructor()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				Assert.Throws<MissingMethodException>(() => csv.Context.RegisterClassMap<TestMap>());
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			private TestMap(string test)
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/MappingWithNoHeaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/MappingWithNoHeaderTests.cs
new file mode 100644
index 0000000..0b97af6
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/MappingWithNoHeaderTests.cs
@@ -0,0 +1,243 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings
+{
+	public class MappingWithNoHeaderTests
+	{
+		[Fact]
+		public void Read_NoHeader_HasNameAttribute_Reads()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" }
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<FooAttribute>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void Read_NoHeader_HasNameMap_Reads()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" }
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void Read_NoHeader_HasParameterAttribute_Reads()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" }
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<FooParameterAttribute>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void Read_NoHeader_HasParameterMap_Reads()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "1", "one" }
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.RegisterClassMap<FooParameterMap>();
+				var records = csv.GetRecords<FooParameter>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void Write_HasHeader_HasNameAttribute_Writes()
+		{
+			var records = new List<FooAttribute>
+			{
+				new FooAttribute { Id = 1, Name = "one" },
+			};
+
+			var writer = new StringWriter();
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = "New Id,New Name\r\n1,one\r\n";
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void Write_HasHeader_HasNameMap_Writes()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one" },
+			};
+
+			var writer = new StringWriter();
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				csv.WriteRecords(records);
+
+				var expected = "New Id,New Name\r\n1,one\r\n";
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void Write_HasHeader_HasParameterAttribute_Writes()
+		{
+			var records = new List<FooParameterAttribute>
+			{
+				new FooParameterAttribute(1, "one"),
+			};
+
+			var writer = new StringWriter();
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteRecords(records);
+
+				var expected = "Id,Name\r\n1,one\r\n";
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void Write_HasHeader_HasParameterMap_Writes()
+		{
+			var records = new List<FooParameterAttribute>
+			{
+				new FooParameterAttribute(1, "one"),
+			};
+
+			var writer = new StringWriter();
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooParameterMap>();
+				csv.WriteRecords(records);
+
+				var expected = "Id,Name\r\n1,one\r\n";
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		private class FooAttribute
+		{
+			[Index(0)]
+			[Name("New Id")]
+			public int Id { get; set; }
+
+			[Index(1)]
+			[Name("New Name")]
+			public string Name { get; set; }
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(x => x.Id).Name("New Id").Index(0);
+				Map(x => x.Name).Name("New Name").Index(1);
+			}
+		}
+
+		private class FooParameterAttribute
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public FooParameterAttribute([Name("New Id")]int id, [Name("New Name")]string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooParameter
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public FooParameter(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class FooParameterMap : ClassMap<FooParameter>
+		{
+			public FooParameterMap()
+			{
+				Parameter("id").Name("New Id").Index(0);
+				Parameter("name").Name("New Name").Index(1);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/OptionalTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/OptionalTests.cs
new file mode 100644
index 0000000..66ea742
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/OptionalTests.cs
@@ -0,0 +1,220 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using CsvHelper;
+using CsvHelper.Configuration;
+
+namespace CsvHelper.Tests.Mappings
+{
+	
+	public class OptionalTests
+	{
+		[Fact]
+		public void OptionalWithExistingColumnTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<FooOptionalIntMap>();
+
+			var records = csvReader.GetRecords<Foo>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+			Assert.Equal(1, records[0].Id);
+			Assert.Equal("one", records[0].Name);
+			Assert.Equal(2, records[1].Id);
+			Assert.Equal("two", records[1].Name);
+		}
+
+		[Fact]
+		public void OptionalIntTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Name" },
+				{ "one" },
+				{ "two" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<FooOptionalIntMap>();
+
+			var records = csvReader.GetRecords<Foo>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+
+			Assert.Equal(0, records[0].Id);
+			Assert.Equal("one", records[0].Name);
+
+			Assert.Equal(0, records[1].Id);
+			Assert.Equal("two", records[1].Name);
+		}
+
+		[Fact]
+		public void OptionalIntDefaultTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Name" },
+				{ "one" },
+				{ "two" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<FooOptionalIntDefaultMap>();
+
+			var records = csvReader.GetRecords<Foo>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+
+			Assert.Equal(int.MinValue, records[0].Id);
+			Assert.Equal("one", records[0].Name);
+
+			Assert.Equal(int.MinValue, records[1].Id);
+			Assert.Equal("two", records[1].Name);
+		}
+
+		[Fact]
+		public void OptionalStringIntDefaultTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Name" },
+				{ "one" },
+				{ "two" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<FooOptionalStringIntDefaultMap>();
+
+			var records = csvReader.GetRecords<Foo>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+
+			Assert.Equal(int.MinValue, records[0].Id);
+			Assert.Equal("one", records[0].Name);
+
+			Assert.Equal(int.MinValue, records[1].Id);
+			Assert.Equal("two", records[1].Name);
+		}
+
+		[Fact]
+		public void OptionalStringTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id" },
+				{ "1" },
+				{ "2" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<FooOptionalStringMap>();
+
+			var records = csvReader.GetRecords<Foo>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+
+			Assert.Equal(1, records[0].Id);
+			Assert.Null(records[0].Name);
+
+			Assert.Equal(2, records[1].Id);
+			Assert.Null(records[1].Name);
+		}
+
+		[Fact]
+		public void OptionalStringDefaultTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id" },
+				{ "1" },
+				{ "2" },
+			};
+
+			var csvReader = new CsvReader(parserMock);
+			csvReader.Context.RegisterClassMap<FooOptionalStringDefaultMap>();
+
+			var records = csvReader.GetRecords<Foo>().ToList();
+
+			Assert.NotNull(records);
+			Assert.Equal(2, records.Count);
+
+			Assert.Equal(1, records[0].Id);
+			Assert.Equal("bar", records[0].Name);
+
+			Assert.Equal(2, records[1].Id);
+			Assert.Equal("bar", records[1].Name);
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class FooOptionalIntMap : ClassMap<Foo>
+		{
+			public FooOptionalIntMap()
+			{
+				Map(m => m.Id).Optional();
+				Map(m => m.Name);
+			}
+		}
+
+		private sealed class FooOptionalIntDefaultMap : ClassMap<Foo>
+		{
+			public FooOptionalIntDefaultMap()
+			{
+				Map(m => m.Id).Optional().Default(int.MinValue);
+				Map(m => m.Name);
+			}
+		}
+
+		private sealed class FooOptionalStringIntDefaultMap : ClassMap<Foo>
+		{
+			public FooOptionalStringIntDefaultMap()
+			{
+				Map(m => m.Id).Optional().Default(int.MinValue.ToString());
+				Map(m => m.Name);
+			}
+		}
+
+		private sealed class FooOptionalStringMap : ClassMap<Foo>
+		{
+			public FooOptionalStringMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Optional();
+			}
+		}
+
+		private sealed class FooOptionalStringDefaultMap : ClassMap<Foo>
+		{
+			public FooOptionalStringDefaultMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Optional().Default("bar");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Property/ConstantTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Property/ConstantTests.cs
new file mode 100644
index 0000000..9aab105
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/Property/ConstantTests.cs
@@ -0,0 +1,74 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mappings.Property
+{
+	
+    public class ConstantTests
+    {
+		[Fact]
+		public void GetRecords_ConstantSet_FieldExists_ReturnsRecordsWithConstant()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\r\n");
+			s.Append("1,one\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_ConstantSet_FieldMissing_ReturnsRecordsWithConstant()
+		{
+			var s = new StringBuilder();
+			s.Append("Id\r\n");
+			s.Append("1\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Equal("Bar", records[0].Name);
+			}
+		}
+
+		private class Foo
+		{
+			public string Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id).Index(0);
+				Map(m => m.Name).Index(1).Constant("Bar");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ReferenceConstructorArgsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ReferenceConstructorArgsTests.cs
new file mode 100644
index 0000000..6bd33f7
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/ReferenceConstructorArgsTests.cs
@@ -0,0 +1,50 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings
+{
+	
+	public class ReferenceConstructorArgsTests
+	{
+		[Fact]
+		public void Test()
+		{
+			var map = new AMap( "A Field" );
+			var name = map.ReferenceMaps[0].Data.Mapping.MemberMaps.Find<B>( m => m.Name ).Data.Names[0];
+			Assert.Equal( "B Field", name );
+		}
+
+		private class A
+		{
+			public string Name { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public string Name { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap( string name )
+			{
+				Map( m => m.Name ).Name( name );
+				References<BMap>( m => m.B, "B Field" );
+			}
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+			public BMap( string name )
+			{
+				Map( m => m.Name ).Name( name );
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/RuntimeMapping.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/RuntimeMapping.cs
new file mode 100644
index 0000000..41f0714
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/RuntimeMapping.cs
@@ -0,0 +1,199 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings
+{
+
+	public class RuntimeMapping
+	{
+		[Fact]
+		public void ConstantTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("AId,BId,CId");
+				writer.WriteLine("1,2,3");
+				writer.Flush();
+				stream.Position = 0;
+
+				var map = new DefaultClassMap<A>();
+				var type = typeof(A);
+				var member = type.GetProperty("AId");
+				map.Map(type, member).Constant(4);
+
+				csv.Context.RegisterClassMap(map);
+				var records = csv.GetRecords<A>().ToList();
+
+				Assert.Equal(4, records[0].AId);
+			}
+		}
+
+		[Fact]
+		public void DefaultTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("AId,BId,CId");
+				writer.WriteLine(",2,3");
+				writer.Flush();
+				stream.Position = 0;
+
+				var map = new DefaultClassMap<A>();
+				var type = typeof(A);
+				var member = type.GetProperty("AId");
+				map.Map(type, member).Default(4);
+
+				csv.Context.RegisterClassMap(map);
+				var records = csv.GetRecords<A>().ToList();
+
+				Assert.Equal(4, records[0].AId);
+			}
+		}
+
+		[Fact]
+		public void ConstantNullableTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("AId,BId,CId,NullableNum");
+				writer.WriteLine("1,2,3,1");
+				writer.Flush();
+				stream.Position = 0;
+
+				var map = new DefaultClassMap<A>();
+				var type = typeof(A);
+				var member = type.GetProperty("NullableNum");
+				map.Map(type, member).Constant(4);
+
+				csv.Context.RegisterClassMap(map);
+				var records = csv.GetRecords<A>().ToList();
+
+				Assert.Equal(4, records[0].NullableNum);
+			}
+		}
+
+		[Fact]
+		public void DefaultNullableTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("AId,BId,CId,NullableNum");
+				writer.WriteLine("1,2,3,");
+				writer.Flush();
+				stream.Position = 0;
+
+				var map = new DefaultClassMap<A>();
+				var type = typeof(A);
+				var member = type.GetProperty("NullableNum");
+				map.Map(type, member).Default(4);
+
+				csv.Context.RegisterClassMap(map);
+				var records = csv.GetRecords<A>().ToList();
+
+				Assert.Equal(4, records[0].NullableNum);
+			}
+		}
+
+		[Fact]
+		public void ConstantValueTypeNullTest()
+		{
+			Assert.Throws<ArgumentException>(() => new ConstantValueTypeNullMap());
+		}
+
+		[Fact]
+		public void ConstantTypeMismatchTest()
+		{
+			Assert.Throws<ArgumentException>(() => new ConstantTypeMismatchMap());
+		}
+
+		[Fact]
+		public void DefaultValueTypeNullTest()
+		{
+			Assert.Throws<ArgumentException>(() => new DefaultValueTypeNullMap());
+		}
+
+		[Fact]
+		public void DefaultTypeMismatchTest()
+		{
+			Assert.Throws<ArgumentException>(() => new DefaultTypeMismatchMap());
+		}
+
+		private class A
+		{
+			public int AId { get; set; }
+
+			public int? NullableNum { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public int BId { get; set; }
+
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public int CId { get; set; }
+		}
+
+		private class ObjectProperty
+		{
+			public object O { get; set; }
+		}
+
+		private class ConstantValueTypeNullMap : ClassMap<A>
+		{
+			public ConstantValueTypeNullMap()
+			{
+				Map(m => m.AId).Constant(null);
+			}
+		}
+
+		private class ConstantTypeMismatchMap : ClassMap<A>
+		{
+			public ConstantTypeMismatchMap()
+			{
+				Map(m => m.AId).Constant((uint)1);
+			}
+		}
+
+		private class DefaultValueTypeNullMap : ClassMap<A>
+		{
+			public DefaultValueTypeNullMap()
+			{
+				Map(m => m.AId).Constant(null);
+			}
+		}
+
+		private class DefaultTypeMismatchMap : ClassMap<A>
+		{
+			public DefaultTypeMismatchMap()
+			{
+				Map(m => m.AId).Constant((uint)1);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/SubPropertyMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/SubPropertyMappingTests.cs
new file mode 100644
index 0000000..d1c3f8c
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mappings/SubPropertyMappingTests.cs
@@ -0,0 +1,127 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Mappings
+{
+	
+	public class SubPropertyMappingTests
+	{
+		[Fact]
+		public void ReadTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("P3,P1,P2");
+				writer.WriteLine("p3,p1,p2");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<AMap>();
+				var records = csv.GetRecords<A>().ToList();
+
+				Assert.Equal("p1", records[0].P1);
+				Assert.Equal("p2", records[0].B.P2);
+				Assert.Equal("p3", records[0].B.C.P3);
+			}
+		}
+
+		[Fact]
+		public void WriteTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<A>()
+				{
+					new A
+					{
+						P1 = "p1",
+						B = new B
+						{
+							P2 = "p2",
+							C = new C
+							{
+								P3 = "p3"
+							}
+						}
+					}
+				};
+
+				csv.Context.RegisterClassMap<AMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = "P3,P1,P2\r\n";
+				expected += "p3,p1,p2\r\n";
+				var result = reader.ReadToEnd();
+
+				Assert.Equal(expected, result);
+			}
+		}
+
+		[Fact]
+		public void ChangeMemberMapTest()
+		{
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
+			var context = new CsvContext(config);
+			var map = context.AutoMap<A>();
+			map.Map(m => m.B.C.P3).Index(3);
+		}
+
+		[Fact]
+		public void AutoMapInClassMapTest()
+		{
+			var map = new AAutoMap();
+		}
+
+		private class A
+		{
+			public string P1 { get; set; }
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public string P2 { get; set; }
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string P3 { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				Map(m => m.B.C.P3).Index(0);
+				Map(m => m.P1).Index(1);
+				Map(m => m.B.P2).Index(2);
+			}
+		}
+
+		private sealed class AAutoMap : ClassMap<A>
+		{
+			public AAutoMap()
+			{
+				AutoMap(CultureInfo.InvariantCulture);
+				Map(m => m.B.C.P3).Index(3);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/DynamicObjectMock.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/DynamicObjectMock.cs
new file mode 100644
index 0000000..c54a1f3
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/DynamicObjectMock.cs
@@ -0,0 +1,31 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Dynamic;
+
+namespace CsvHelper.Tests.Mocks
+{
+	public class DynamicObjectMock : DynamicObject
+	{
+		private Dictionary<string, object> dictionary = new Dictionary<string, object>();
+
+		public override bool TryGetMember(GetMemberBinder binder, out object result)
+		{
+			return dictionary.TryGetValue(binder.Name, out result);
+		}
+
+		public override bool TrySetMember(SetMemberBinder binder, object value)
+		{
+			dictionary[binder.Name] = value;
+
+			return true;
+		}
+
+		public override IEnumerable<string> GetDynamicMemberNames()
+		{
+			return dictionary.Keys;
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ParserMock.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ParserMock.cs
new file mode 100644
index 0000000..3dba8b2
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ParserMock.cs
@@ -0,0 +1,96 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using CsvHelper.Configuration;
+using System.Threading.Tasks;
+using System.Globalization;
+using System.Linq;
+
+namespace CsvHelper.Tests.Mocks
+{
+	public class ParserMock : IParser, IEnumerable<string[]>
+	{
+		private readonly Queue<string[]> records = new Queue<string[]>();
+		private string[] record;
+		private int row;
+
+		public CsvContext Context { get; private set; }
+
+		public IParserConfiguration Configuration { get; private set; }
+
+		public int Count => record?.Length ?? 0;
+
+		public string[] Record => record;
+
+		public string RawRecord => string.Empty;
+
+		public int Row => row;
+
+		public int RawRow => row;
+
+		public long ByteCount => 0;
+
+		public long CharCount => 0;
+
+		public string Delimiter => Configuration.Delimiter;
+
+		public string this[int index] => record[index];
+
+		public ParserMock() : this(new CsvConfiguration(CultureInfo.InvariantCulture)) { }
+
+		public ParserMock(CsvConfiguration configuration)
+		{
+			Configuration = configuration;
+			Context = new CsvContext(this);
+		}
+
+		public bool Read()
+		{
+			if (records.Count == 0)
+			{
+				return false;
+			}
+
+			row++;
+			record = records.Dequeue();
+
+			return true;
+		}
+
+		public Task<bool> ReadAsync()
+		{
+			row++;
+			record = records.Dequeue();
+
+			return Task.FromResult(records.Count > 0);
+		}
+
+		public void Dispose()
+		{
+		}
+
+		#region Mock Methods
+
+		public void Add(params string[] record)
+		{
+			records.Enqueue(record);
+		}
+
+		public IEnumerator<string[]> GetEnumerator()
+		{
+			return records.GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return GetEnumerator();
+		}
+
+		#endregion Mock Methods
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ParserMockTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ParserMockTests.cs
new file mode 100644
index 0000000..3b779c9
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ParserMockTests.cs
@@ -0,0 +1,37 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mocks
+{
+	
+    public class ParserMockTests
+    {
+		[Fact]
+        public void Test()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+			};
+			Assert.True(parser.Read());
+			Assert.Equal("Id", parser[0]);
+			Assert.Equal("Name", parser[1]);
+
+			Assert.True(parser.Read());
+			Assert.Equal("1", parser[0]);
+			Assert.Equal("one", parser[1]);
+
+			Assert.False(parser.Read());
+			Assert.False(parser.Read());
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ReaderRowMock.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ReaderRowMock.cs
new file mode 100644
index 0000000..b73c81e
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Mocks/ReaderRowMock.cs
@@ -0,0 +1,226 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Mocks
+{
+	public class ReaderRowMock : IReaderRow
+	{
+		public string this[int index] => throw new NotImplementedException();
+
+		public string this[string name] => throw new NotImplementedException();
+
+		public string this[string name, int index] => throw new NotImplementedException();
+
+		public int ColumnCount => throw new NotImplementedException();
+
+		public int CurrentIndex => throw new NotImplementedException();
+
+		public string[] HeaderRecord => throw new NotImplementedException();
+
+		public IParser Parser => throw new NotImplementedException();
+
+		public CsvContext Context => throw new NotImplementedException();
+
+		public IReaderConfiguration Configuration { get; private set; }
+
+		public ReaderRowMock()
+		{
+			Configuration = new CsvConfiguration(CultureInfo.InvariantCulture);
+		}
+
+		public ReaderRowMock(CsvConfiguration configuration)
+		{
+			Configuration = configuration;
+		}
+
+		public string GetField(int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		public string GetField(string name)
+		{
+			throw new NotImplementedException();
+		}
+
+		public string GetField(string name, int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		public object GetField(Type type, int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		public object GetField(Type type, string name)
+		{
+			throw new NotImplementedException();
+		}
+
+		public object GetField(Type type, string name, int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		public object GetField(Type type, int index, ITypeConverter converter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public object GetField(Type type, string name, ITypeConverter converter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public object GetField(Type type, string name, int index, ITypeConverter converter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T>(int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T>(string name)
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T>(string name, int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T>(int index, ITypeConverter converter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T>(string name, ITypeConverter converter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T>(string name, int index, ITypeConverter converter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T, TConverter>(int index) where TConverter : ITypeConverter
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T, TConverter>(string name) where TConverter : ITypeConverter
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetField<T, TConverter>(string name, int index) where TConverter : ITypeConverter
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetRecord<T>()
+		{
+			throw new NotImplementedException();
+		}
+
+		public T GetRecord<T>(T anonymousTypeDefinition)
+		{
+			throw new NotImplementedException();
+		}
+
+		public object GetRecord(Type type)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField(Type type, int index, out object field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField(Type type, string name, out object field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField(Type type, string name, int index, out object field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField(Type type, int index, ITypeConverter converter, out object field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField(Type type, string name, ITypeConverter converter, out object field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField(Type type, string name, int index, ITypeConverter converter, out object field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T>(int index, out T field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T>(string name, out T field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T>(string name, int index, out T field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T>(int index, ITypeConverter converter, out T field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T>(string name, ITypeConverter converter, out T field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T>(string name, int index, ITypeConverter converter, out T field)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T, TConverter>(int index, out T field) where TConverter : ITypeConverter
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T, TConverter>(string name, out T field) where TConverter : ITypeConverter
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetField<T, TConverter>(string name, int index, out T field) where TConverter : ITypeConverter
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectCreatorTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectCreatorTests.cs
new file mode 100644
index 0000000..add5a72
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectCreatorTests.cs
@@ -0,0 +1,351 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.ObjectCreatorTests
+{
+	
+	public class CreateInstance_ValueType
+	{
+		[Fact]
+		public void CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var value = creator.CreateInstance<int>();
+
+			Assert.Equal(default(int), value);
+		}
+
+		[Fact]
+		public void ParameterSupplied_ThrowsMissingMethodExcepetion()
+		{
+			var creator = new ObjectCreator();
+
+			Assert.Throws<MissingMethodException>(() => creator.CreateInstance<int>(1));
+		}
+	}
+
+	
+	public class CreateInstance_DefaultConstructor
+	{
+		[Fact]
+		public void CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>();
+			creator.CreateInstance<Foo>();
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(default(int), foo.Id);
+		}
+
+		[Fact]
+		public void ParameterSupplied_ThrowsMissingMethodExcepetion()
+		{
+			var creator = new ObjectCreator();
+
+			Assert.Throws<MissingMethodException>(() => creator.CreateInstance<Foo>(1));
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public Foo() { }
+		}
+	}
+
+	
+	public class CreateInstance_OneParameterConstructor
+	{
+		[Fact]
+		public void OneParameter_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>(1);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(1, foo.Id);
+		}
+
+		[Fact]
+		public void NoParameter_ThrowsMissingMethodException()
+		{
+			var creator = new ObjectCreator();
+
+			Assert.Throws<MissingMethodException>(() => creator.CreateInstance<Foo>());
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public Foo(int id)
+			{
+				Id = id;
+			}
+		}
+	}
+
+	
+	public class CreateInstance_DefaultConstructorAndOneParameterConstructor
+	{
+		[Fact]
+		public void NoParameter_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>();
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(default(int), foo.Id);
+		}
+
+		[Fact]
+		public void OneParameter_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>(1);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(1, foo.Id);
+		}
+
+		[Fact]
+		public void OneParameterWrongType_ThrowsMissingMethodException()
+		{
+			var creator = new ObjectCreator();
+
+			Assert.Throws<MissingMethodException>(() => creator.CreateInstance<Foo>(string.Empty));
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public Foo() { }
+
+			public Foo(int id)
+			{
+				Id = id;
+			}
+		}
+	}
+
+	
+	public class CreateInstance_ValueTypeAndReferenceTypeParameters
+	{
+		[Fact]
+		public void FirstSignature_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>(1, "one");
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(1, foo.Id);
+			Assert.Equal("one", foo.Name);
+		}
+
+		[Fact]
+		public void SecondSignature_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>("one", 1);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(1, foo.Id);
+			Assert.Equal("one", foo.Name);
+		}
+
+		[Fact]
+		public void FirstSignature_NullReferenceType_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>(1, null);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(1, foo.Id);
+			Assert.Null(foo.Name);
+		}
+
+		[Fact]
+		public void SecondSignature_NullReferenceType_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>(null, 1);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(1, foo.Id);
+			Assert.Null(foo.Name);
+		}
+
+		[Fact]
+		public void FirstSignature_NullValueType_ThrowsMissingMethodException()
+		{
+			var creator = new ObjectCreator();
+
+			Assert.Throws<MissingMethodException>(() => creator.CreateInstance<Foo>(null, "one"));
+		}
+
+		[Fact]
+		public void SecondSignature_NullValueType_ThrowsMissingMethodException()
+		{
+			var creator = new ObjectCreator();
+
+			Assert.Throws<MissingMethodException>(() => creator.CreateInstance<Foo>("one", null));
+		}
+
+		private class Foo
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public Foo(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+
+			public Foo(string name, int id)
+			{
+				Name = name;
+				Id = id;
+			}
+		}
+	}
+
+	
+	public class CreateInstance_TwoReferenceTypeParameters
+	{
+		[Fact]
+		public void FirstSignature_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var bar = new Bar();
+			var foo = creator.CreateInstance<Foo>("one", bar);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal("one", foo.Name);
+			Assert.Equal(bar, foo.Bar);
+		}
+
+		[Fact]
+		public void SecondSignature_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var bar = new Bar();
+			var foo = creator.CreateInstance<Foo>(bar, "one");
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal("one", foo.Name);
+			Assert.Equal(bar, foo.Bar);
+		}
+
+		[Fact]
+		public void FirstSignature_NullFirstParameter_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var bar = new Bar();
+			var foo = creator.CreateInstance<Foo>(null, bar);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Null(foo.Name);
+			Assert.Equal(bar, foo.Bar);
+		}
+
+		[Fact]
+		public void FirstSignature_NullSecondParameter_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>("one", null);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal("one", foo.Name);
+			Assert.Null(foo.Bar);
+		}
+
+		[Fact]
+		public void SecondSignature_NullFirstParameter_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var foo = creator.CreateInstance<Foo>(null, "one");
+
+			Assert.IsType<Foo>(foo);
+			Assert.Null(foo.Bar);
+			Assert.Equal("one", foo.Name);
+		}
+
+		[Fact]
+		public void SecondSignature_NullSecondParameter_CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+			var bar = new Bar();
+			var foo = creator.CreateInstance<Foo>(bar, null);
+
+			Assert.IsType<Foo>(foo);
+			Assert.Equal(bar, foo.Bar);
+			Assert.Null(foo.Name);
+		}
+
+		[Fact]
+		public void FirstSignature_BothNullParameters_ThrowsAmbiguousMatchException()
+		{
+			var creator = new ObjectCreator();
+
+			Assert.Throws<AmbiguousMatchException>(() => creator.CreateInstance<Foo>(null, null));
+		}
+
+		private class Foo
+		{
+			public string Name { get; set; }
+
+			public Bar Bar { get; set; }
+
+			public Foo(string name, Bar bar)
+			{
+				Name = name;
+				Bar = bar;
+			}
+
+			public Foo(Bar bar, string name)
+			{
+				Bar = bar;
+				Name = name;
+			}
+		}
+
+		private class Bar { }
+	}
+
+	
+	public class CreateInstance_PrivateConstructor
+	{
+		[Fact]
+		public void CreatesInstance()
+		{
+			var creator = new ObjectCreator();
+
+			var foo = creator.CreateInstance<Foo>();
+
+			Assert.IsType<Foo>(foo);
+		}
+
+		private class Foo
+		{
+			private Foo() { }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectResolverTests/Issue1073.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectResolverTests/Issue1073.cs
new file mode 100644
index 0000000..cf4cec4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectResolverTests/Issue1073.cs
@@ -0,0 +1,72 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace CsvHelper.Tests.Issues
+{
+	
+	public class Issue1073
+	{
+		[Fact]
+		public void GetFieldTest()
+		{
+			var originalResolver = ObjectResolver.Current;
+			try
+			{
+				ObjectResolver.Current = new ObjectResolver(type => true, (type, args) =>
+				{
+					throw new XUnitException();
+				});
+
+				var s = new StringBuilder();
+				s.Append("Id,Name\r\n");
+				s.Append("1,one\r\n");
+				using (var reader = new StringReader(s.ToString()))
+				using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+				{
+					csv.Read();
+					csv.ReadHeader();
+					while (csv.Read())
+					{
+						csv.GetField<int>("Id");
+						csv.GetField<string>("Name");
+					}
+				}
+			}
+			finally
+			{
+				ObjectResolver.Current = originalResolver;
+			}
+		}
+
+		[Fact]
+		public void WriteFieldTest()
+		{
+			var originalResolver = ObjectResolver.Current;
+			try
+			{
+				ObjectResolver.Current = new ObjectResolver(type => true, (type, args) =>
+				{
+					throw new XUnitException();
+				});
+
+				using (var writer = new StringWriter())
+				using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+				{
+					csv.WriteField(1);
+					csv.WriteField("one");
+					csv.NextRecord();
+				}
+			}
+			finally
+			{
+				ObjectResolver.Current = originalResolver;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectResolverTests/ResolveSingleTypeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectResolverTests/ResolveSingleTypeTests.cs
new file mode 100644
index 0000000..4413c3f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ObjectResolverTests/ResolveSingleTypeTests.cs
@@ -0,0 +1,59 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Linq;
+
+namespace CsvHelper.Tests.ObjectResolverTests
+{
+	
+	public class ResolverSingleTypeTests
+	{
+		[Fact]
+		public void Test()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+			};
+
+			var originalResolver = ObjectResolver.Current;
+
+			try
+			{
+				using (var csv = new CsvReader(parser))
+				{
+					ObjectResolver.Current = new ObjectResolver(CanResolve, Resolve);
+					var records = csv.GetRecords<A>().ToList();
+
+					Assert.Single(records);
+				}
+			}
+			finally
+			{
+				ObjectResolver.Current = originalResolver;
+			}
+		}
+
+		private bool CanResolve(Type type)
+		{
+			return type == typeof(A);
+		}
+
+		private object Resolve(Type type, object[] args)
+		{
+			return new A();
+		}
+
+		private class A
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BadDataTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BadDataTests.cs
new file mode 100644
index 0000000..8f6ccb4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BadDataTests.cs
@@ -0,0 +1,153 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class BadDataTests
+	{
+		[Fact]
+		public void CallbackTest()
+		{
+			string rawRecord = null;
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BadDataFound = args => rawRecord = args.Context.Parser.RawRecord.ToString(),
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write(" a\"bc\",d\r\n");        //   a"bc",d\r\n
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				var record = parser.Record;
+				Assert.Equal(" a\"bc\",d\r\n", rawRecord);
+
+				rawRecord = null;
+				parser.Read();
+				record = parser.Record;
+				Assert.Null(rawRecord);
+			}
+		}
+
+		[Fact]
+		public void ThrowExceptionTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("1,2");
+				writer.WriteLine(" a\"bc\",d");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				try
+				{
+					parser.Read();
+					var record = parser.Record;
+					throw new XUnitException("Failed to throw exception on bad data.");
+				}
+				catch (BadDataException) { }
+			}
+		}
+
+		[Fact]
+		public void IgnoreQuotesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("one,2\"two,three\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("2\"two", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void LineBreakInQuotedFieldIsBadDataCrTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				LineBreakInQuotedFieldIsBadData = true,
+			};
+			using (var reader = new StringReader("\"a\rb\""))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Throws<BadDataException>(() => parser.Record);
+			}
+		}
+
+		[Fact]
+		public void LineBreakInQuotedFieldIsBadDataLfTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				LineBreakInQuotedFieldIsBadData = true,
+			};
+			using (var reader = new StringReader("\"a\nb\""))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Throws<BadDataException>(() => parser.Record);
+			}
+		}
+
+		[Fact]
+		public void LineBreakInQuotedFieldIsBadDataCrLfTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				LineBreakInQuotedFieldIsBadData = true,
+			};
+			using (var reader = new StringReader("\"a\r\nb\""))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Throws<BadDataException>(() => parser.Record);
+			}
+		}
+
+		[Fact]
+		public void Read_AccessingParserRecordInBadDataFound_ThrowsParserException()
+		{
+			var badstring = new StringReader("Fish,\"DDDD");
+
+			string[] record = new string[0];
+			var cfg = new CsvConfiguration(CultureInfo.CurrentCulture)
+			{
+				BadDataFound = args => record = args.Context.Parser.Record
+			};
+			var parser = new CsvParser(badstring, cfg);
+
+			parser.Read();
+
+			Assert.Throws<ParserException>(() => parser[1]);
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingEscapeAndQuoteTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingEscapeAndQuoteTests.cs
new file mode 100644
index 0000000..007df34
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingEscapeAndQuoteTests.cs
@@ -0,0 +1,38 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class BufferSplittingEscapeAndQuoteTests
+    {
+		[Fact]
+		public void Read_BufferEndsAtEscape_FieldIsNotBadData()
+		{
+			var s = new StringBuilder();
+			s.Append("a,\"bcdefghijklm\"\"nopqrstuvwxyz\"\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("a", parser[0]);
+				Assert.Equal("bcdefghijklm\"nopqrstuvwxyz", parser[1]);
+			}
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingLineEndingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingLineEndingTests.cs
new file mode 100644
index 0000000..c4457f4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingLineEndingTests.cs
@@ -0,0 +1,98 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Text;
+using Xunit;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class BufferSplittingLineEndingTests
+	{
+		[Fact]
+		public void Read_BufferSplitsCrLf_BufferNeedsResize_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("1,0000000000321\r\n");
+			s.Append("3,4\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("0000000000321", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void Read_BufferSplitsCrLf_NoBufferResize_DoesntAddExtraField()
+		{
+			var s = new StringBuilder();
+			s.Append("1,200000\r\n");
+			s.Append("3,400000\r\n");
+			s.Append("5,600\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				parser.Read();
+				parser.Read();
+				Assert.Equal(2, parser.Count);
+			}
+		}
+
+		[Fact]
+		public void Read_BufferSplitsCrLf_NoBufferResize_RawRecordIsCorrect()
+		{
+			var s = new StringBuilder();
+			s.Append("1,200000\r\n");
+			s.Append("3,400000\r\n");
+			s.Append("5,600\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				parser.Read();
+				parser.Read();
+				Assert.Equal("5,600\r\n", parser.RawRecord);
+			}
+		}
+
+		[Fact]
+		public void BufferSplitsCrLfWithLastFieldQuotedTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1,200000\r\n");
+			s.Append("3,4000\r\n");
+			s.Append("5,\"600\"\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				parser.Read();
+				parser.Read();
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("5,\"600\"\r\n", parser.RawRecord);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingNewLineEndingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingNewLineEndingTests.cs
new file mode 100644
index 0000000..a3d40b4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/BufferSplittingNewLineEndingTests.cs
@@ -0,0 +1,102 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Text;
+using Xunit;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class BufferSplittingCrLnTests
+	{
+		[Fact]
+		public void Read_BufferSplitsCrLf_BufferNeedsResize_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("1,0000000000321\r\n");
+			s.Append("3,4\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+				NewLine = "\r\n",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("0000000000321", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void Read_BufferSplitsCrLf_NoBufferResize_DoesntAddExtraField()
+		{
+			var s = new StringBuilder();
+			s.Append("1,200000\r\n");
+			s.Append("3,400000\r\n");
+			s.Append("5,600\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+				NewLine = "\r\n",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				parser.Read();
+				parser.Read();
+				Assert.Equal(2, parser.Count);
+			}
+		}
+
+		[Fact]
+		public void Read_BufferSplitsCrLf_NoBufferResize_RawRecordIsCorrect()
+		{
+			var s = new StringBuilder();
+			s.Append("1,200000\r\n");
+			s.Append("3,400000\r\n");
+			s.Append("5,600\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+				NewLine = "\r\n",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				parser.Read();
+				parser.Read();
+				Assert.Equal("5,600\r\n", parser.RawRecord);
+			}
+		}
+
+		[Fact]
+		public void BufferSplitsCrLfWithLastFieldQuotedTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1,200000\r\n");
+			s.Append("3,4000\r\n");
+			s.Append("5,\"600\"\r\n");
+			var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+				NewLine = "\r\n",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				parser.Read();
+				parser.Read();
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("5,\"600\"\r\n", parser.RawRecord);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/ByteCountTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/ByteCountTests.cs
new file mode 100644
index 0000000..dc3bd8d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/ByteCountTests.cs
@@ -0,0 +1,137 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class ByteCountTests
+	{
+		[Fact]
+		public void Read_CRLF_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Encoding = Encoding.Unicode,
+				CountBytes = true,
+			};
+			var s = new StringBuilder();
+			s.Append("1,2\r\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(config.Encoding.GetByteCount(s.ToString()), parser.ByteCount);
+			}
+		}
+
+		[Fact]
+		public void Read_CR_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Encoding = Encoding.Unicode,
+				CountBytes = true,
+			};
+			var s = new StringBuilder();
+			s.Append("1,2\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(config.Encoding.GetByteCount(s.ToString()), parser.ByteCount);
+			}
+		}
+
+		[Fact]
+		public void Read_LF_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Encoding = Encoding.Unicode,
+				CountBytes = true,
+			};
+			var s = new StringBuilder();
+			s.Append("1,2\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(config.Encoding.GetByteCount(s.ToString()), parser.ByteCount);
+			}
+		}
+
+		[Fact]
+		public void Read_NoLineEnding_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Encoding = Encoding.Unicode,
+				CountBytes = true,
+			};
+			var s = new StringBuilder();
+			s.Append("1,2");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(config.Encoding.GetByteCount(s.ToString()), parser.ByteCount);
+			}
+		}
+
+		[Fact]
+		public void CharCountFirstCharOfDelimiterNextToDelimiterTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Encoding = Encoding.Unicode,
+				CountBytes = true,
+				Delimiter = "!#",
+			};
+			var s = new StringBuilder();
+			s.Append("1!!#2\r\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(config.Encoding.GetByteCount(s.ToString()), parser.ByteCount);
+			}
+		}
+
+		[Fact]
+		public void Read_Trimmed_WhiteSpaceCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Encoding = Encoding.Unicode,
+				CountBytes = true,
+				TrimOptions = TrimOptions.Trim
+			};
+			var s = new StringBuilder();
+			s.Append("1, 2\r\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(config.Encoding.GetByteCount(s.ToString()), parser.ByteCount);
+			}
+		}
+
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CharCountTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CharCountTests.cs
new file mode 100644
index 0000000..06b469e
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CharCountTests.cs
@@ -0,0 +1,124 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class CharCountTests
+    {
+		[Fact]
+		public void Read_CRLF_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			var s = new StringBuilder();
+			s.Append("1,2\r\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(5, parser.CharCount);
+			}
+		}
+
+		[Fact]
+		public void Read_CR_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			var s = new StringBuilder();
+			s.Append("1,2\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(4, parser.CharCount);
+			}
+		}
+
+		[Fact]
+		public void Read_LF_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			var s = new StringBuilder();
+			s.Append("1,2\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(4, parser.CharCount);
+			}
+		}
+
+		[Fact]
+		public void Read_NoLineEnding_CharCountCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			var s = new StringBuilder();
+			s.Append("1,2");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(3, parser.CharCount);
+			}
+		}
+
+		[Fact]
+		public void CharCountFirstCharOfDelimiterNextToDelimiterTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "!#",
+			};
+			var s = new StringBuilder();
+			s.Append("1!!#2\r\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(7, parser.CharCount);
+			}
+		}
+
+		[Fact]
+		public void Read_Trimmed_WhiteSpaceCorrect()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim
+			};
+			var s = new StringBuilder();
+			s.Append("1, 2");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(4, parser.CharCount);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CommentTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CommentTests.cs
new file mode 100644
index 0000000..cd4db53
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CommentTests.cs
@@ -0,0 +1,125 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class CommentTests
+	{
+		[Fact]
+		public void CommentThatCrossesBuffersShouldNotAddToFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+				BufferSize = 16
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1,2\r\n");
+				writer.Write("#abcdefghijklmnop\r\n");
+				writer.Write("3,4");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+				parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("4", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void WriteCommentCharInFieldWithCommentsOffTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField("#no comment");
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal("#no comment\r\n", result);
+			}
+		}
+
+		[Fact]
+		public void WriteCommentCharInFieldWithCommentsOnTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("#no comment");
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal("#no comment\r\n", result);
+			}
+		}
+
+		[Fact]
+		public void WriteCommentWithCommentsOffTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteComment("comment\"has\" quote");
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal("#comment\"has\" quote\r\n", result);
+			}
+		}
+
+		[Fact]
+		public void WriteCommentWithCommentsOnTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				AllowComments = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteComment("comment\"has\" quote");
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal("#comment\"has\" quote\r\n", result);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CrTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CrTests.cs
new file mode 100644
index 0000000..e14d619
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CrTests.cs
@@ -0,0 +1,235 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class CrTests
+	{
+		[Fact]
+		public void SingleFieldAndSingleRowTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void SingleFieldAndSingleRowAndFieldIsQuotedTest()
+		{
+			var s = new StringBuilder();
+			s.Append("\"1\"\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void SingleFieldAndMultipleRowsAndFirstFieldInFirstRowIsQuotedAndNoLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("\"1\"\r");
+			s.Append("2");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+
+				parser.Read();
+				Assert.Equal("2", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void SingleFieldAndMultipleRowsAndFirstFieldInFirstRowIsQuotedAndHasLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("\"1\"\r");
+			s.Append("2\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+
+				parser.Read();
+				Assert.Equal("2", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void SingleFieldAndMultipleRowsTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1\r");
+			s.Append("2\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+
+				parser.Read();
+				Assert.Equal("2", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void SingleFieldAndMultipleRowsAndLastRowHasNoLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1\r");
+			s.Append("2");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+
+				parser.Read();
+				Assert.Equal("2", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void SingleFieldAndSecondRowIsQuotedAndLastRowHasNoLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1\r");
+			s.Append("\"2\"");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+
+				parser.Read();
+				Assert.Equal("2", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void MultipleFieldsAndSingleRowAndLastRowHasNoLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1,2\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void MultipleFieldsAndMultipleRowsAndLastRowHasNoLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1,2\r");
+			s.Append("3,4");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+
+				parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("4", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void MultipleFieldsAndMultipleRowsAndLastRowHasLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1,2\r");
+			s.Append("3,4\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+
+				parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("4", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void MultipleFieldsAndMultipleRowsAndLastFieldInFirstRowIsQuotedAndLastRowHasLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1,\"2\"\r");
+			s.Append("3,4\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+
+				parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("4", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void MultipleFieldsAndMultipleRowsAndSecondRowFirstFieldIsQuotedAndLastRowHasLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("1,2\r");
+			s.Append("\"3\",4\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+
+				parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("4", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void MultipleFieldsAndMultipleRowsAndAllFieldsQuotedAndHasLineEndingTest()
+		{
+			var s = new StringBuilder();
+			s.Append("\"1\",\"2\"\r");
+			s.Append("\"3\",\"4\"\r");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				parser.Read();
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+
+				parser.Read();
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("4", parser[1]);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CsvModeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CsvModeTests.cs
new file mode 100644
index 0000000..f561f68
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/CsvModeTests.cs
@@ -0,0 +1,109 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class CsvModeTests
+    {
+		[Fact]
+		public void Read_HasEscapedDelimiter_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("a\\,b,c\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("a,b", parser[0]);
+				Assert.Equal("c", parser[1]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Read_HasEscapedLineEnding_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("a\\\nb,c\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("a\nb", parser[0]);
+				Assert.Equal("c", parser[1]);
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Read_NoEscapeMode_HasRFC4180Format_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("a,\"b,\"\"c\r\nd\",e");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.NoEscape,
+				Escape = '"',
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("a", parser[0]);
+				Assert.Equal("\"b", parser[1]);
+				Assert.Equal("\"\"c", parser[2]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("d\"", parser[0]);
+				Assert.Equal("e", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void Read_NoEscapeMode_HasEscapeFormat_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("a,\\b\\,c\\\nd,e");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.NoEscape,
+				Escape = '\\',
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("a", parser[0]);
+				Assert.Equal("\\b\\", parser[1]);
+				Assert.Equal("c\\", parser[2]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("d", parser[0]);
+				Assert.Equal("e", parser[1]);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/DelimiterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/DelimiterTests.cs
new file mode 100644
index 0000000..66f599b
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/DelimiterTests.cs
@@ -0,0 +1,81 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class DelimiterTests
+	{
+		[Fact]
+		public void MultipleCharDelimiterWithPartOfDelimiterInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "<|>",
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				writer.Write("1<|>2<3<|>4\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2<3", parser[1]);
+				Assert.Equal("4", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void NullDelimiterTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "\0",
+			};
+			var s = new StringBuilder();
+			s.Append("1\02\03\r\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.Equal("3", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void FirstCharOfDelimiterNextToDelimiterTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "!#",
+			};
+			var s = new StringBuilder();
+			s.AppendLine("1!!#2");
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal("1!", parser[0]);
+				Assert.Equal("2", parser[1]);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/DetectDelimiterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/DetectDelimiterTests.cs
new file mode 100644
index 0000000..facc030
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/DetectDelimiterTests.cs
@@ -0,0 +1,286 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Parsing
+{
+    public class DetectDelimiterTests
+    {
+		[Fact]
+        public void GetDelimiter_TextHasCommas_DetectsComma()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\r\n");
+			s.Append("1,one\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+			};
+			Assert.Equal(",", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_TextHasSemicolons_DetectsSemicolon()
+		{
+			var s = new StringBuilder();
+			s.Append("Id;Name\r\n");
+			s.Append("1;one\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(";", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+			}
+		}
+
+		[Fact]
+		public void GetDelimiter_TextHasPipes_DetectsPipe()
+		{
+			var s = new StringBuilder();
+			s.Append("Id|Name\r\n");
+			s.Append("1|one\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal("|", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+			}
+		}
+
+		[Fact]
+		public void GetDelimiter_TextHasTabs_DetectsTab()
+		{
+			var s = new StringBuilder();
+			s.Append("Id\tName\r\n");
+			s.Append("1\tone\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal("\t", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+			}
+		}
+
+		[Fact]
+		public void GetDelimiter_EqualAmountOfDelimiters_DetectsFirstInDelimiterValuesList()
+		{
+			var s = new StringBuilder();
+			s.Append(";;,,\t\t||\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+				DetectDelimiter = true,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(",", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+			}
+		}
+
+		[Fact]
+		public void GetDelimiter_TextHas2CharDelimiter_DetectsDelimiter()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,,Name\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+				DetectDelimiter = true,
+				DetectDelimiterValues = new[] { ",," },
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(",,", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+			}
+		}
+
+		[Fact]
+		public void GetDelimiter_TextHasRegularCharDelimiter_DetectsDelimiter()
+		{
+			var s = new StringBuilder();
+			s.Append("IdþName\r\n");
+			s.Append("1þone\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+				DetectDelimiterValues = new[] { "þ" }
+			};
+			Assert.Equal("þ", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_MultipleLines_DetectsDelimiterThatIsOnEveryLine()
+		{
+			var s = new StringBuilder();
+			s.Append("Id;Name\r\n");
+			s.Append("1,2,3,4;5,6,7,8\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+				DetectDelimiterValues = new[] { ",", ";" }
+			};
+			Assert.Equal(";", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_NoDelimiter_DoesNotDetect()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\r\n");
+			s.Append("1,one\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+				DetectDelimiterValues = new[] { ";" }
+			};
+			Assert.Equal("`", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_CulturesSeparatorOccursLessButIsOnEveryLine_CulturesSeparatorIsDetected()
+		{
+			var s = new StringBuilder();
+			s.Append("1;2,3;4\r\n");
+			s.Append("5;6,7;8\r\n");
+			s.Append("9;10,11;12\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			Assert.Equal(CultureInfo.InvariantCulture.TextInfo.ListSeparator, ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_CulturesSeparatorOccursLessAndIsOnFirstLine_CulturesSeparatorIsNotDetected()
+		{
+			var s = new StringBuilder();
+			s.Append("1;2,3;4\r\n");
+			s.Append("5;6;7;8\r\n");
+			s.Append("9;10,11;12\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			Assert.NotEqual(CultureInfo.InvariantCulture.TextInfo.ListSeparator, ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_CulturesSeparatorOccursLessAndHasSingleLine_CulturesSeparatorIsNotDetected()
+		{
+			var s = new StringBuilder();
+			s.Append("1;2,3;4\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			Assert.NotEqual(CultureInfo.InvariantCulture.TextInfo.ListSeparator, ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_CulturesSeparatorOccursLessAndHas2LinesAndIsOnEveryLine_CulturesSeparatorIsNotDetected()
+		{
+			var s = new StringBuilder();
+			s.Append("1;2,3;4\r\n");
+			s.Append("5;6,7;8\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			Assert.NotEqual(CultureInfo.InvariantCulture.TextInfo.ListSeparator, ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_CulturesSeparatorOccursLessAndIsOnSecondLine_CulturesSeparatorIsDetected()
+		{
+			var s = new StringBuilder();
+			s.Append("1;2;3;4\r\n");
+			s.Append("5;6,7;8\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			Assert.Equal(";", ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config)));
+		}
+
+		[Fact]
+		public void GetDelimiter_TextHasLF_NewLineIsCRLF_DetectsDelimiter()
+		{
+			var s = new StringBuilder();
+			s.Append("name;num;date\nLily;1,005.25;2021-02-03\nJack;3.5;2021-02-04");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			var delimeter = ConfigurationFunctions.GetDelimiter(new Delegates.GetDelimiterArgs(s.ToString(), config));
+			Assert.Equal(";", delimeter);
+		}
+
+		[Fact]
+		public void CsvParserConstructor_DelimiterValuesEmpty_ThrowsException()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\r\n");
+			s.Append("1,one\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DetectDelimiter = true,
+				DetectDelimiterValues = new string[0],
+			};
+			using (var reader = new StringReader(s.ToString()))
+			{
+				Assert.Throws<ConfigurationException>(() => new CsvParser(reader, config));
+			}
+		}
+
+		[Fact]
+		public void Read_TextHasCommas_ParsesRows()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\r\n");
+			s.Append("1,one\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = "`",
+				DetectDelimiter = true,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var row = parser.Read();
+
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				row = parser.Read();
+
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/EndBufferTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/EndBufferTests.cs
new file mode 100644
index 0000000..9b1e2dd
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/EndBufferTests.cs
@@ -0,0 +1,79 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class EndBufferTests
+    {
+		[Fact]
+		public void Read_BufferEndsInOneCharDelimiter_ParsesFieldCorrectly()
+		{
+			var s = new StringBuilder();
+			s.Append("abcdefghijklmno,pqrs\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("abcdefghijklmno", parser[0]);
+				Assert.Equal("pqrs", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void Read_BufferEndsInFirstCharOfTwoCharDelimiter_ParsesFieldCorrectly()
+		{
+			var s = new StringBuilder();
+			s.Append("abcdefghijklmnop;;qrs\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+				Delimiter = ";;",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("abcdefghijklmnop", parser[0]);
+				Assert.Equal("qrs", parser[1]);
+			}
+		}
+
+		[Fact]
+		public void Read_BufferEndsInSecondCharOfTwoCharDelimiter_ParsesFieldCorrectly()
+		{
+			var s = new StringBuilder();
+			s.Append("abcdefghijklmno;;pqrs\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16,
+				Delimiter = ";;",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal(2, parser.Count);
+				Assert.Equal("abcdefghijklmno", parser[0]);
+				Assert.Equal("pqrs", parser[1]);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/EscapeCharacterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/EscapeCharacterTests.cs
new file mode 100644
index 0000000..bf0b801
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/EscapeCharacterTests.cs
@@ -0,0 +1,110 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class EscapeCharacterTests
+	{
+		[Fact]
+		public void EscapeTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Escape = '|',
+			};
+			using (var reader = new StringReader("\"|\"a|\"\"\r\n"))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("\"a\"", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void EscapeNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Escape = '|',
+			};
+			using (var reader = new StringReader("\"|\"a|\"\""))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("\"a\"", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void EscapeTrimOutsideTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Escape = '|',
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var reader = new StringReader(" \"|\"a|\"\" \r\n")) // ` "|"a|"" \r\n`
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("\"a\"", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void EscapeTrimInsideTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Escape = '|',
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var reader = new StringReader("\" |\"a|\" \"\r\n"))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("\"a\"", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void EscapeTrimBothTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Escape = '|',
+				TrimOptions = TrimOptions.Trim | TrimOptions.InsideQuotes,
+			};
+			using (var reader = new StringReader(" \" |\"a|\" \" \r\n"))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				Assert.Equal("\"a\"", parser[0]);
+			}
+		}
+
+		[Fact]
+		public void EscapeWriteTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Escape = '|',
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("\"a\"");
+				csv.Flush();
+
+				Assert.Equal("\"|\"a|\"\"", writer.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/ExcelCompatibilityTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/ExcelCompatibilityTests.cs
new file mode 100644
index 0000000..801443d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/ExcelCompatibilityTests.cs
@@ -0,0 +1,123 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class ExcelCompatibilityTests
+	{
+		[Fact]
+		public void Parse_EscapedFieldHasSpaceAfterLastQuote_FieldProcessedLeavingSpaceAtEnd()
+		{
+			var s = new StringBuilder();
+			s.Append("one,\"two\" ,three\r\n"); // one,"two" ,three
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BadDataFound = null,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("one", parser[0]);
+				Assert.Equal("two ", parser[1]);
+				Assert.Equal("three", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void Parse_EscapedFieldHasSpaceBeforeFirstQuote_FieldIsNotProcessed()
+		{
+			var s = new StringBuilder();
+			s.Append("one, \"two\",three\r\n"); // one, "two",three
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BadDataFound = null,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("one", parser[0]);
+				Assert.Equal(" \"two\"", parser[1]);
+				Assert.Equal("three", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void Parse_EscapedFieldHasExtraQuoteAfterLastQuote_CharsAfterLastQuoteAreNotProcessed()
+		{
+			var s = new StringBuilder();
+			s.Append("1,\"two\" \"2,3\r\n"); // 1,"two" "2,3
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BadDataFound = null,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("two \"2", parser[1]);
+				Assert.Equal("3", parser[2]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Parse_EscapedFieldHasNoEndingQuote_GoesToEndOfFile()
+		{
+			var s = new StringBuilder();
+			s.Append("a,b,\"c\r\n"); // a,b,"c\r\nd,e,f\r\n
+			s.Append("d,e,f\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BadDataFound = null,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal("b", parser[1]);
+				Assert.Equal("c\r\nd,e,f\r\n", parser[2]);
+			}
+		}
+
+		[Fact]
+		public void Parse_NonEscapedFieldHasQuotesInIt_IgnoresQuotes()
+		{
+			var s = new StringBuilder();
+			s.Append("1,2\"3\"4,5\r\n"); // 1,2"3"4,5
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BadDataFound = null,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal(3, parser.Count);
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2\"3\"4", parser[1]);
+				Assert.Equal("5", parser[2]);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/FieldCacheTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/FieldCacheTests.cs
new file mode 100644
index 0000000..38bea21
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/FieldCacheTests.cs
@@ -0,0 +1,94 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class FieldCacheTests
+    {
+		[Fact]
+		public void Read_WithFieldCacheEnabled_ReturnsSameFieldInstance()
+		{
+			var s = new StringBuilder();
+			s.Append("1,2\r\n");
+			s.Append("2,1\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CacheFields = true,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				var a = parser[0];
+				parser.Read();
+				var b = parser[1];
+
+				Assert.Same(a, b);
+			}
+		}
+
+		[Fact]
+		public void Read_WithFieldCacheDisabled_ReturnsDifferentFieldInstance()
+		{
+			var s = new StringBuilder();
+			s.Append("1,2\r\n");
+			s.Append("2,1\r\n");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				CacheFields = false,
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				var a = parser[0];
+				parser.Read();
+				var b = parser[1];
+
+				Assert.NotSame(a, b);
+			}
+		}
+
+		[Fact]
+		public void Test1()
+		{
+			// "542008", "27721116", "98000820" have hash code 3769566006
+
+			var value1 = "542008";
+			var value2 = "27721116";
+			var value3 = "98000820";
+			var value4 = "542008";
+
+			var cache = new FieldCache(1);
+
+			var field1 = cache.GetField(value1.ToCharArray(), 0, value1.Length);
+			var field2 = cache.GetField(value2.ToCharArray(), 0, value2.Length);
+			var field3 = cache.GetField(value3.ToCharArray(), 0, value3.Length);
+			var field4 = cache.GetField(value4.ToCharArray(), 0, value4.Length);
+
+			Assert.Equal(value1, field1);
+			Assert.Equal(value2, field2);
+			Assert.Equal(value3, field3);
+			Assert.Equal(value4, field4);
+
+			Assert.NotSame(value1, field1);
+			Assert.NotSame(value2, field2);
+			Assert.NotSame(value3, field3);
+			Assert.NotSame(value4, field4);
+
+			Assert.Same(field1, field4);
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/MaxFieldSizeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/MaxFieldSizeTests.cs
new file mode 100644
index 0000000..98567c6
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/MaxFieldSizeTests.cs
@@ -0,0 +1,50 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests.Parsing
+{
+	public class MaxFieldSizeTests
+	{
+		[Fact]
+		public void LargeRecordFieldThrowsMaxFieldSizeExceptionTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MaxFieldSize = 10
+			};
+			var s = new TestStringBuilder(config.NewLine);
+			s.AppendLine("1,2,3");
+			s.AppendLine("ok,1234567890,x");
+			s.AppendLine("nok,12345678901,y");
+			using (var reader = new StringReader(s))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+				parser.Read();
+				Assert.Throws<MaxFieldSizeException>(() => parser.Read());
+			}
+		}
+
+		[Fact]
+		public void LargeHeaderFieldThrowsMaxFieldSizeExceptionTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MaxFieldSize = 10
+			};
+			var s = new TestStringBuilder(config.NewLine);
+			s.AppendLine("1,very long header name");
+			using (var reader = new StringReader(s))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.Throws<MaxFieldSizeException>(() => parser.Read());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/NewLineTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/NewLineTests.cs
new file mode 100644
index 0000000..b943450
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/NewLineTests.cs
@@ -0,0 +1,176 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class NewLineTests
+    {
+		[Fact]
+		public void Read_RfcMode_2CharNewLine_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\a\b");
+			s.Append("1,one\a\b");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.RFC4180,
+				NewLine = "\a\b",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Read_RfcMode_1CharNewLine_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\a");
+			s.Append("1,one\a");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.RFC4180,
+				NewLine = "\a",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Read_RfcMode_2CharNewLine_NoneOnLastLine_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\a\b");
+			s.Append("1,one");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.RFC4180,
+				NewLine = "\a\b",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+        public void Read_EscapeMode_2CharNewLine_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\a\b");
+			s.Append("1,one\a\b");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				NewLine = "\a\b",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Read_EscapeMode_1CharNewLine_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\a");
+			s.Append("1,one\a");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				NewLine = "\a",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				Assert.False(parser.Read());
+			}
+		}
+
+		[Fact]
+		public void Read_EscapeMode_2CharNewLine_NoneOnLastLine_Parses()
+		{
+			var s = new StringBuilder();
+			s.Append("Id,Name\a\b");
+			s.Append("1,one");
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				NewLine = "\a\b",
+			};
+			using (var reader = new StringReader(s.ToString()))
+			using (var parser = new CsvParser(reader, config))
+			{
+				Assert.True(parser.Read());
+				Assert.Equal("Id", parser[0]);
+				Assert.Equal("Name", parser[1]);
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("one", parser[1]);
+
+				Assert.False(parser.Read());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/RefillingTextReaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/RefillingTextReaderTests.cs
new file mode 100644
index 0000000..9ad8c6f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/RefillingTextReaderTests.cs
@@ -0,0 +1,59 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+    public class RefillingTextReaderTests
+    {
+		[Fact]
+        public void RefillTextReaderMultipleTimesTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var parser = new CsvParser(reader, CultureInfo.InvariantCulture))
+			{
+				writer.Write("1,2\r\n");
+				writer.Flush();
+				stream.Position = 0;
+
+				Assert.True(parser.Read());
+				Assert.Equal("1", parser[0]);
+				Assert.Equal("2", parser[1]);
+				Assert.False(parser.Read());
+
+				var position = stream.Position;
+				writer.Write("3,4\r\n");
+				writer.Flush();
+				stream.Position = position;
+
+				Assert.True(parser.Read());
+				Assert.Equal("3", parser[0]);
+				Assert.Equal("4", parser[1]);
+				Assert.False(parser.Read());
+
+				position = stream.Position;
+				writer.Write("5,6\r\n");
+				writer.Flush();
+				stream.Position = position;
+
+				Assert.True(parser.Read());
+				Assert.Equal("5", parser[0]);
+				Assert.Equal("6", parser[1]);
+				Assert.False(parser.Read());
+			}
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/TrimTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/TrimTests.cs
new file mode 100644
index 0000000..a4a4370
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Parsing/TrimTests.cs
@@ -0,0 +1,1206 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Parsing
+{
+	
+	public class TrimTests
+	{
+		[Fact]
+		public void OutsideStartTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a,b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideStartNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a,b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideStartSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a b c,d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideStartSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a b c,d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideEndTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "a  ,b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideEndNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "a  ,b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideEndSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "a b c  ,d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideEndSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "a b c  ,d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideBothTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a  ,b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideBothNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a  ,b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideBothSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a b c  ,d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideBothSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a b c  ,d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesStartTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a\",b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesStartNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a\",b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesStartSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a b c\",d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesStartSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a b c\",d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesEndTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a\"  ,b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesEndNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a\"  ,b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesEndSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a b c\"  ,d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesEndSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a b c\"  ,d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesBothTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a\"  ,b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesBothNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a\"  ,b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesBothSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a b c\"  ,d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesBothSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"a b c\"  ,d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesBothSpacesInFieldMultipleRecordsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a b c  ,  d e f  \r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal("d e f", parser[1]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesBothSpacesInFieldMultipleRecordsNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  a b c  ,  d e f  ";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal("d e f", parser[1]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesStartTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a\",b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesStartNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a\",b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesStartSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a b c\",b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesStartSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a b c\",b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesStartSpacesInFieldDelimiterInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\" a ,b c\",b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a ,b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesStartSpacesInFieldDelimiterInFieldSmallBufferNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+				BufferSize = 1,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\" a ,b c\",b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a ,b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesEndTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a  \",b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesEndNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a  \",b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesEndSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a b c  \",d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesEndSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"a b c  \",d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a  \",b\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a  \",b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothSpacesInFieldTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a b c  \",d\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothSpacesInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a b c  \",d";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothSpacesInFieldMultipleRecordsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a b c  \",\"  d e f  \"\r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal("d e f", parser[1]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothSpacesInFieldMultipleRecordsNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "\"  a b c  \",\"  d e f  \"";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal("d e f", parser[1]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideAndInsideQuotesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim | TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"  a b c  \"  ,  \"  d e f  \"  \r\n";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal("d e f", parser[1]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideAndInsideQuotesNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim | TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "  \"  a b c  \"  ,  \"  d e f  \"  ";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b c", parser[0]);
+				Assert.Equal("d e f", parser[1]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesNoSpacesNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "abc";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("abc", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void OutsideQuotesNoSpacesHasSpaceInFieldNoNewlineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var parser = new CsvParser(reader, config))
+			{
+				var line = "a b";
+				writer.Write(line);
+				writer.Flush();
+				stream.Position = 0;
+
+				parser.Read();
+
+				Assert.Equal("a b", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideNoSpacesQuotesFieldHasEscapedQuotesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			var line = "\"a \"\"b\"\" c\"";
+			using (var reader = new StringReader(line))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal("a \"b\" c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothSpacesFieldHasEscapedQuotesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			var line = "\" a \"\"b\"\" c \"\r\n";
+			using (var reader = new StringReader(line))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal("a \"b\" c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void InsideQuotesBothSpacesFieldHasEscapedQuotesNoNewLineTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.InsideQuotes,
+			};
+			var line = "\" a \"\"b\"\" c \"";
+			using (var reader = new StringReader(line))
+			using (var parser = new CsvParser(reader, config))
+			{
+				parser.Read();
+
+				Assert.Equal("a \"b\" c", parser[0]);
+				Assert.Equal(line, parser.RawRecord.ToString());
+			}
+		}
+
+		[Fact]
+		public void ReadingTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim | TrimOptions.InsideQuotes,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("A,B");
+				writer.WriteLine("  \"  a b c  \"  ,  \"  d e f  \"  ");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<dynamic>().ToList();
+
+				var record = records[0];
+				Assert.Equal("a b c", record.A);
+				Assert.Equal("d e f", record.B);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/AnonymousTypesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/AnonymousTypesTests.cs
new file mode 100644
index 0000000..79e537c
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/AnonymousTypesTests.cs
@@ -0,0 +1,707 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class AnonymousTypesTests
+	{
+		[Fact]
+		public void ValueTypeSingleRecordTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				Name = string.Empty
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+				var record = csv.GetRecord(definition);
+
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+			}
+		}
+
+		[Fact]
+		public void ValueTypeAllRecordsTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				Name = string.Empty
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+			}
+		}
+
+		[Fact]
+		public void ValueTypeAllRecordsNoHeaderTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				Name = string.Empty
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+			}
+
+		}
+
+		[Fact]
+		public void ReferenceTypeSingleRecordTest()
+		{
+			var definition = new
+			{
+				Reference = new Test()
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+				var record = csv.GetRecord(definition);
+
+				Assert.Equal(1, record.Reference.Id);
+				Assert.Equal("one", record.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void ReferenceTypeAllRecordsTest()
+		{
+			var definition = new
+			{
+				Reference = new Test()
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Reference.Id);
+				Assert.Equal("one", record.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void ReferenceTypeAllRecordsNoHeaderTest()
+		{
+			var definition = new
+			{
+				Reference = new Test()
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Reference.Id);
+				Assert.Equal("one", record.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void ValueAndReferenceTypeSingleRecordTest()
+		{
+			var definition = new
+			{
+				A = 0,
+				B = string.Empty,
+				Reference = new Test()
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("A,Id,Name,B");
+				writer.WriteLine("-1,1,one,b");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+				var record = csv.GetRecord(definition);
+
+				Assert.Equal(-1, record.A);
+				Assert.Equal("b", record.B);
+				Assert.Equal(1, record.Reference.Id);
+				Assert.Equal("one", record.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void ValueAndReferenceTypeAllRecordsTest()
+		{
+			var definition = new
+			{
+				A = 0,
+				B = string.Empty,
+				Reference = new Test()
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("A,Id,Name,B");
+				writer.WriteLine("-1,1,one,b");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(-1, record.A);
+				Assert.Equal("b", record.B);
+				Assert.Equal(1, record.Reference.Id);
+				Assert.Equal("one", record.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void ValueAndReferenceTypeAllRecordsNoHeaderTest()
+		{
+			var definition = new
+			{
+				A = 0,
+				B = string.Empty,
+				Reference = new Test()
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("-1,b,1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(-1, record.A);
+				Assert.Equal("b", record.B);
+				Assert.Equal(1, record.Reference.Id);
+				Assert.Equal("one", record.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceSingleRecordTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				AnonymousReference = new
+				{
+					Name = string.Empty
+				}
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+				var record = csv.GetRecord(definition);
+
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.AnonymousReference.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceAllRecordsTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				AnonymousReference = new
+				{
+					Name = string.Empty
+				}
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.AnonymousReference.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceAllRecordsNoHeaderTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				AnonymousReference = new
+				{
+					Name = string.Empty
+				}
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.AnonymousReference.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceHasAnonymousReferenceSingleRecordTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				AnonymousReference = new
+				{
+					AnonymousReference2 = new
+					{
+						Name = string.Empty
+					}
+				}
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+				var record = csv.GetRecord(definition);
+
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.AnonymousReference.AnonymousReference2.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceHasAnonymousReferenceAllRecordsTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				AnonymousReference = new
+				{
+					AnonymousReference2 = new
+					{
+						Name = string.Empty
+					}
+				}
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.AnonymousReference.AnonymousReference2.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceHasAnonymousReferenceAllRecordsNoHeaderTest()
+		{
+			var definition = new
+			{
+				Id = 0,
+				AnonymousReference = new
+				{
+					AnonymousReference2 = new
+					{
+						Name = string.Empty
+					}
+				}
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.AnonymousReference.AnonymousReference2.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceHasReferenceSingleRecordTest()
+		{
+			var definition = new
+			{
+				A = 0,
+				AnonymousReference = new
+				{
+					Reference = new Test()
+				}
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name,A");
+				writer.WriteLine("1,one,2");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+				var record = csv.GetRecord(definition);
+
+				Assert.Equal(2, record.A);
+				Assert.Equal(1, record.AnonymousReference.Reference.Id);
+				Assert.Equal("one", record.AnonymousReference.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceHasReferenceAllRecordsTest()
+		{
+			var definition = new
+			{
+				A = 0,
+				AnonymousReference = new
+				{
+					Reference = new Test()
+				}
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name,A");
+				writer.WriteLine("1,one,2");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(2, record.A);
+				Assert.Equal(1, record.AnonymousReference.Reference.Id);
+				Assert.Equal("one", record.AnonymousReference.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void AnonymousReferenceHasReferenceAllRecordsNoHeaderTest()
+		{
+			var definition = new
+			{
+				A = 0,
+				AnonymousReference = new
+				{
+					Reference = new Test()
+				}
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("2,1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(2, record.A);
+				Assert.Equal(1, record.AnonymousReference.Reference.Id);
+				Assert.Equal("one", record.AnonymousReference.Reference.Name);
+			}
+		}
+
+		[Fact]
+		public void ParentChildReferenceSingleRecordTest()
+		{
+			var definition = new
+			{
+				Reference = new Child()
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("ParentId,ChildId,ParentName,ChildName");
+				writer.WriteLine("1,2,one,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+				var record = csv.GetRecord(definition);
+
+				Assert.Equal(1, record.Reference.ParentId);
+				Assert.Equal("one", record.Reference.ParentName);
+				Assert.Equal(2, record.Reference.ChildId);
+				Assert.Equal("two", record.Reference.ChildName);
+			}
+		}
+
+		[Fact]
+		public void ParentChildReferenceAllRecordsTest()
+		{
+			var definition = new
+			{
+				Reference = new Child()
+			};
+
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("ParentId,ChildId,ParentName,ChildName");
+				writer.WriteLine("1,2,one,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Reference.ParentId);
+				Assert.Equal("one", record.Reference.ParentName);
+				Assert.Equal(2, record.Reference.ChildId);
+				Assert.Equal("two", record.Reference.ChildName);
+			}
+		}
+
+		[Fact]
+		public void ParentChildReferenceAllRecordsNoHeaderTest()
+		{
+			var definition = new
+			{
+				Reference = new Child()
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,one,2,two");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords(definition).ToList();
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Reference.ChildId);
+				Assert.Equal("one", record.Reference.ChildName);
+				Assert.Equal(2, record.Reference.ParentId);
+				Assert.Equal("two", record.Reference.ParentName);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private class ContainsReference
+		{
+			public Test Test { get; set; }
+		}
+
+		private class Parent
+		{
+			public int ParentId { get; set; }
+
+			public string ParentName { get; set; }
+		}
+
+		private class Child : Parent
+		{
+			public int ChildId { get; set; }
+
+			public string ChildName { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/BadDataTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/BadDataTests.cs
new file mode 100644
index 0000000..b127478
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/BadDataTests.cs
@@ -0,0 +1,64 @@
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	public class BadDataTests
+	{
+		[Fact]
+		public void GetRecord_BadDataCountNotDuplicted()
+		{
+			var errorCount = 0;
+			var csvConfiguration = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ReadingExceptionOccurred = args => false,
+				BadDataFound = args =>
+				{
+					++errorCount;
+				},
+				Delimiter = ";",
+			};
+			var csv = "SKU;Min quantity;List price;Sale price\r\nTestSku1;2;10.99;9.99\r\nTestSku2;2;10.99;9\r\nXXX;\"9;10.9;9";
+			var stream = new MemoryStream();
+			using (var writer = new StreamWriter(stream, leaveOpen: true))
+			{
+				writer.Write(csv);
+				writer.Flush();
+				stream.Position = 0;
+			}
+			var textReader = new StreamReader(stream, leaveOpen: true);
+
+			var csvReader = new CsvReader(textReader, csvConfiguration);
+
+			while (csvReader.Read())
+			{
+				csvReader.GetRecord<CsvPrice>();
+			}
+
+			Assert.Equal(1, errorCount);
+		}
+
+		public sealed class CsvPrice
+		{
+			[Name("SKU")]
+			public string Sku { get; set; }
+
+			[Name("Min quantity")]
+			public int MinQuantity { get; set; }
+
+			[Name("List price")]
+			public decimal ListPrice { get; set; }
+
+			[Name("Sale price")]
+			public decimal? SalePrice { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstantTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstantTests.cs
new file mode 100644
index 0000000..9a9d3ac
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstantTests.cs
@@ -0,0 +1,114 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System.IO;
+using System.Globalization;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class ConstantTests
+	{
+		[Fact]
+		public void ConstantAlwaysReturnsSameValueTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+
+			var csv = new CsvReader(parser);
+			csv.Context.RegisterClassMap<TestStringMap>();
+			var records = csv.GetRecords<Test>().ToList();
+
+			Assert.Equal(1, records[0].Id);
+			Assert.Equal("constant", records[0].Name);
+			Assert.Equal(2, records[1].Id);
+			Assert.Equal("constant", records[1].Name);
+		}
+
+		[Fact]
+		public void ConstantIsNullTest()
+		{
+			var rows = new Queue<string[]>();
+			rows.Enqueue(new[] { "Id", "Name" });
+			rows.Enqueue(new[] { "1", "one" });
+			rows.Enqueue(new[] { "2", "two" });
+			rows.Enqueue(null);
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "one" },
+				{ "2", "two" },
+			};
+
+			var csv = new CsvReader(parser);
+			csv.Context.RegisterClassMap<TestNullMap>();
+			var records = csv.GetRecords<Test>().ToList();
+
+			Assert.Equal(1, records[0].Id);
+			Assert.Null(records[0].Name);
+			Assert.Equal(2, records[1].Id);
+			Assert.Null(records[1].Name);
+		}
+
+		[Fact]
+		public void IntConstantTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var reader = new StringReader("1,one\r\n"))
+			using (var csv = new CsvReader(reader, config))
+			{
+				csv.Context.RegisterClassMap<TestIntMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				Assert.Equal(-1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		private sealed class TestStringMap : ClassMap<Test>
+		{
+			public TestStringMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Constant("constant");
+			}
+		}
+
+		private sealed class TestNullMap : ClassMap<Test>
+		{
+			public TestNullMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Constant(null);
+			}
+		}
+
+		private sealed class TestIntMap : ClassMap<Test>
+		{
+			public TestIntMap()
+			{
+				Map(m => m.Id).Constant(-1);
+				Map(m => m.Name);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstructorParametersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstructorParametersTests.cs
new file mode 100644
index 0000000..a96df82
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstructorParametersTests.cs
@@ -0,0 +1,220 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class ConstructorParametersTests
+	{
+		[Fact]
+		public void ValueTypesParamsMatchPropsTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<ValueTypesParamsMatchProps>().ToList();
+
+				Assert.Single(records);
+
+				var record = records[0];
+
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+			}
+		}
+
+		[Fact]
+		public void ValueTypesParamsDontMatchPropsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header)
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<ValueTypesParamsDontMatchProps>().ToList();
+
+				Assert.Single(records);
+
+				var record = records[0];
+
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+			}
+		}
+
+		[Fact]
+		public void MultipleConstructorsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header)
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<MultipleConstructors>().ToList();
+
+				Assert.Single(records);
+
+				var record = records[0];
+
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+			}
+		}
+
+		[Fact]
+		public void UseDifferentConstructorTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header),
+				GetConstructor = args => args.ClassType.GetConstructors().First(),
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<MultipleConstructors>().ToList();
+
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Null(record.Name);
+			}
+		}
+
+		[Fact]
+		public void UseDifferentConstructorWhenDefaultIsAvailableTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header),
+				ShouldUseConstructorParameters = args =>
+					!args.ParameterType.IsUserDefinedStruct()
+					&& !args.ParameterType.IsInterface
+					&& Type.GetTypeCode(args.ParameterType) == TypeCode.Object,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<MultipleConstructorsWithDefault>().ToList();
+
+				Assert.Single(records);
+
+				var record = records[0];
+				Assert.Equal(1, record.Id);
+				Assert.Equal("one", record.Name);
+			}
+		}
+
+		private class ValueTypesParamsMatchProps
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public ValueTypesParamsMatchProps(int Id, string Name)
+			{
+				this.Id = Id;
+				this.Name = Name;
+			}
+		}
+
+		private class ValueTypesParamsDontMatchProps
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public ValueTypesParamsDontMatchProps(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class MultipleConstructors
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public MultipleConstructors(int id)
+			{
+				Id = id;
+			}
+
+			public MultipleConstructors(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+
+			public MultipleConstructors(string name)
+			{
+				Name = name;
+			}
+		}
+
+		private class MultipleConstructorsWithDefault
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; private set; }
+
+			public MultipleConstructorsWithDefault() { }
+
+			public MultipleConstructorsWithDefault(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DetectColumnCountChangesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DetectColumnCountChangesTests.cs
new file mode 100644
index 0000000..7139409
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DetectColumnCountChangesTests.cs
@@ -0,0 +1,199 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class DetectColumnCountChangesTests
+	{
+		[Fact]
+		public void ConsistentColumnsWithDetectColumnChangesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DetectColumnCountChanges = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Column 1,Column 2");
+				writer.WriteLine("1,2");
+				writer.Flush();
+				stream.Position = 0;
+
+				while (!csv.Read())
+				{
+				}
+			}
+		}
+
+		[Fact]
+		public void InconsistentColumnsMultipleRowsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DetectColumnCountChanges = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Column 1,Column 2");
+				writer.WriteLine("1,2"); // Valid
+				writer.WriteLine("1,2,3"); // Error - too many fields
+				writer.WriteLine("1,2"); // Valid
+				writer.WriteLine("1"); // Error - not enough fields
+				writer.WriteLine("1,2,3,4"); // Error - too many fields
+				writer.WriteLine("1,2"); // Valid
+				writer.WriteLine("1,2"); // Valid
+				writer.Flush();
+				stream.Position = 0;
+
+				var failCount = 0;
+
+				while (true)
+				{
+					try
+					{
+						if (!csv.Read())
+						{
+							break;
+						}
+					}
+					catch (BadDataException)
+					{
+						failCount++;
+					}
+				}
+
+				// Expect only 3 errors
+				Assert.Equal<int>(3, failCount);
+			}
+		}
+
+		[Fact]
+		public void InconsistentColumnsSmallerTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DetectColumnCountChanges = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,2,3,4");
+				writer.WriteLine("5,6,7");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+
+				try
+				{
+					csv.Read();
+					throw new XUnitException();
+				}
+				catch (BadDataException)
+				{
+				}
+			}
+		}
+
+		[Fact]
+		public void InconsistentColumnsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DetectColumnCountChanges = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Column 1,Column 2");
+				writer.WriteLine("1,2,3");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+
+				try
+				{
+					csv.Read();
+					throw new XUnitException();
+				}
+				catch (BadDataException)
+				{
+				}
+			}
+		}
+
+		[Fact]
+		public void WillThrowOnMissingFieldStillWorksTest()
+		{
+			var missingFieldExceptionCount = 0;
+			var columnCountChangeExceptionCount = 0;
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DetectColumnCountChanges = true,
+				HeaderValidated = null,
+				ReadingExceptionOccurred = (args) =>
+				{
+					if (args.Exception is MissingFieldException)
+					{
+						missingFieldExceptionCount++;
+					}
+					else if (args.Exception is BadDataException)
+					{
+						columnCountChangeExceptionCount++;
+					}
+
+					return false;
+				},
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,2,3");
+				writer.WriteLine("4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestMap>();
+				var records = csv.GetRecords<Test>().ToList();
+				Assert.Equal(1, missingFieldExceptionCount);
+				Assert.Equal(1, columnCountChangeExceptionCount);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DynamicTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DynamicTests.cs
new file mode 100644
index 0000000..d843eb0
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DynamicTests.cs
@@ -0,0 +1,126 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class DynamicTests
+	{
+		[Fact]
+		public void PrepareHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args => args.Header.Replace(" ", string.Empty),
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("O ne,Tw o,Thr ee");
+				writer.WriteLine("1,2,3");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<dynamic>().ToList();
+				Assert.Equal("1", records[0].One);
+				Assert.Equal("2", records[0].Two);
+				Assert.Equal("3", records[0].Three);
+			}
+		}
+
+		[Fact]
+		public void BlankHeadersTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				PrepareHeaderForMatch = args =>
+				{
+					if (string.IsNullOrWhiteSpace(args.Header))
+					{
+						return $"Blank{args.FieldIndex}";
+					}
+
+					return args.Header;
+				},
+			};
+			var s = new StringBuilder();
+			s.AppendLine("Id,,");
+			s.AppendLine("1,2");
+			s.AppendLine("3");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, config))
+			{
+				var records = csv.GetRecords<dynamic>().ToList();
+
+				var record = records[0];
+				Assert.Equal("1", record.Id);
+				Assert.Equal("2", record.Blank1);
+				Assert.Equal(null, record.Blank2);
+
+				record = records[1];
+				Assert.Equal("3", record.Id);
+				Assert.Equal(null, record.Blank1);
+				Assert.Equal(null, record.Blank2);
+			}
+		}
+
+		[Fact]
+		public void DuplicateFieldNamesTest()
+		{
+			var headerNameCounts = new Dictionary<string, int>();
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				GetDynamicPropertyName = args =>
+				{
+					var header = args.Context.Reader.HeaderRecord[args.FieldIndex];
+					var prepareHeaderForMatchArgs = new PrepareHeaderForMatchArgs(header, args.FieldIndex);
+					header = args.Context.Reader.Configuration.PrepareHeaderForMatch(prepareHeaderForMatchArgs);
+					var name = headerNameCounts[header] > 1 ? $"{header}{args.FieldIndex}" : header;
+
+					return name;
+				},
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "Id", "Name", "Name" },
+				{ "1", "foo", "bar" },
+				null
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Read();
+				csv.ReadHeader();
+				var counts =
+					(from header in csv.Context.Reader.HeaderRecord.Select((h, i) => csv.Configuration.PrepareHeaderForMatch(new PrepareHeaderForMatchArgs(h, i)))
+					 group header by header into g
+					 select new
+					 {
+						 Header = g.Key,
+						 Count = g.Count()
+					 }).ToDictionary(x => x.Header, x => x.Count);
+				foreach (var count in counts)
+				{
+					headerNameCounts.Add(count.Key, count.Value);
+				}
+
+				var records = csv.GetRecords<dynamic>().ToList();
+				var record = records[0];
+				Assert.Equal("1", record.Id);
+				Assert.Equal("foo", record.Name1);
+				Assert.Equal("bar", record.Name2);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/EmptyTextReaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/EmptyTextReaderTests.cs
new file mode 100644
index 0000000..0400092
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/EmptyTextReaderTests.cs
@@ -0,0 +1,25 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class EmptyTextReaderTests
+	{
+		[Fact]
+		public void EmptyStreamDoesntFailTest()
+		{
+			using( var stream = new MemoryStream() )
+			using( var reader = new StreamReader( stream ) )
+			using( var csv = new CsvReader(reader, CultureInfo.InvariantCulture) )
+			{
+				Assert.False( csv.Read() );
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleGetRecordsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleGetRecordsTests.cs
new file mode 100644
index 0000000..5aeed79
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleGetRecordsTests.cs
@@ -0,0 +1,60 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class MultipleGetRecordsTests
+	{
+		[Fact]
+		public void GetRecordsAfterRefillingReaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<Test>().ToList();
+
+				var position = stream.Position;
+				writer.WriteLine("2,two");
+				writer.Flush();
+				stream.Position = position;
+
+				records = csv.GetRecords<Test>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(2, records[0].Id);
+				Assert.Equal("two", records[0].Name);
+
+				position = stream.Position;
+				writer.WriteLine("3,three");
+				writer.Flush();
+				stream.Position = position;
+
+				records = csv.GetRecords<Test>().ToList();
+
+				Assert.Single(records);
+				Assert.Equal(3, records[0].Id);
+				Assert.Equal("three", records[0].Name);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleHeadersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleHeadersTests.cs
new file mode 100644
index 0000000..49a0b22
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleHeadersTests.cs
@@ -0,0 +1,114 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class MultipleHeadersTests
+	{
+		[Fact]
+		public void ReadWithoutMapTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("A,B");
+				writer.WriteLine("1,one");
+				writer.WriteLine("Y,Z");
+				writer.WriteLine("two,2");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+
+				Assert.Equal(1, csv.GetField<int>("A"));
+				Assert.Equal("one", csv.GetField("B"));
+
+				csv.Read();
+				csv.ReadHeader();
+				csv.Read();
+
+				Assert.Equal("two", csv.GetField("Y"));
+				Assert.Equal(2, csv.GetField<int>("Z"));
+			}
+		}
+
+		[Fact]
+		public void ReadWithMapTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("A,B");
+				writer.WriteLine("1,one");
+				writer.WriteLine("Y,Z");
+				writer.WriteLine("two,2");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<AlphaMap>();
+				csv.Context.RegisterClassMap<OmegaMap>();
+
+				csv.Read();
+				csv.ReadHeader();
+
+				csv.Read();
+				var alphaRecord = csv.GetRecord<Alpha>();
+
+				Assert.Equal(1, alphaRecord.A);
+				Assert.Equal("one", alphaRecord.B);
+
+				csv.Read();
+				csv.ReadHeader();
+
+				csv.Read();
+				var omegaRecord = csv.GetRecord<Omega>();
+
+				Assert.Equal("two", omegaRecord.Y);
+				Assert.Equal(2, omegaRecord.Z);
+			}
+		}
+
+		private class Alpha
+		{
+			public int A { get; set; }
+			public string B { get; set; }
+		}
+
+		private class Omega
+		{
+			public string Y { get; set; }
+			public int Z { get; set; }
+		}
+
+		private sealed class AlphaMap : ClassMap<Alpha>
+		{
+			public AlphaMap()
+			{
+				Map(m => m.A);
+				Map(m => m.B);
+			}
+		}
+
+		private sealed class OmegaMap : ClassMap<Omega>
+		{
+			public OmegaMap()
+			{
+				Map(m => m.Y);
+				Map(m => m.Z);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/NullableValuesInEmptyColumnsInputTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/NullableValuesInEmptyColumnsInputTests.cs
new file mode 100644
index 0000000..c5fcdd5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/NullableValuesInEmptyColumnsInputTests.cs
@@ -0,0 +1,224 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System.Globalization;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class NullableValuesInEmptyColumnsInputTests
+	{
+		[Fact]
+		public void SingleColumnCsvWithHeadersAndSingleNullDataRowTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = false,
+				MissingFieldFound = null,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "NullableInt32Field" },
+				{ new string[0] },
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<int?>().NullValues.Add(string.Empty);
+
+				// Read header row, assert header row columns:
+				Assert.True(csv.Read());
+				Assert.True(csv.ReadHeader());
+				Assert.Single(csv.HeaderRecord);
+				Assert.Equal("NullableInt32Field", csv.HeaderRecord[0]);
+
+				// Read single data row, assert single null value:
+				Assert.True(csv.Read());
+
+				var nullableIntValueByIndex = csv.GetField<int?>(index: 0);
+				var nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.False(nullableIntValueByIndex.HasValue);
+				Assert.False(nullableIntValueByName.HasValue);
+
+				// Read to end of file:
+				Assert.False(csv.Read());
+			}
+		}
+
+		[Fact]
+		public void SingleColumnCsvWithHeadersAndPresentAndNullDataRowTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = false,
+				MissingFieldFound = null,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "NullableInt32Field" },
+				{ "1" },
+				{ new string[0] },
+				{ "3" },
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<int?>().NullValues.Add(string.Empty);
+
+				// Read header row, assert header row columns:
+				Assert.True(csv.Read());
+				Assert.True(csv.ReadHeader());
+				Assert.Single(csv.HeaderRecord);
+				Assert.Equal("NullableInt32Field", csv.HeaderRecord[0]);
+
+				// Read first data row, assert "1" value:
+				Assert.True(csv.Read());
+
+				var nullableIntValueByIndex = csv.GetField<int?>(0);
+				var nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.True(nullableIntValueByIndex.HasValue);
+				Assert.True(nullableIntValueByName.HasValue);
+
+				Assert.Equal(1, nullableIntValueByIndex);
+				Assert.Equal(1, nullableIntValueByName);
+
+				// Read second data row, assert null value:
+				Assert.True(csv.Read());
+
+				nullableIntValueByIndex = csv.GetField<int?>(0);
+				nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.False(nullableIntValueByIndex.HasValue);
+				Assert.False(nullableIntValueByName.HasValue);
+
+				// Read third data row, assert "3" value:
+				Assert.True(csv.Read());
+
+				nullableIntValueByIndex = csv.GetField<int?>(0);
+				nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.True(nullableIntValueByIndex.HasValue);
+				Assert.True(nullableIntValueByName.HasValue);
+
+				Assert.Equal(3, nullableIntValueByIndex);
+				Assert.Equal(3, nullableIntValueByName);
+
+				// Read to end of file:
+				Assert.False(csv.Read());
+			}
+		}
+
+		[Fact]
+		public void TwoColumnCsvWithHeadersAndPresentAndNullDataRowTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IgnoreBlankLines = false,
+				MissingFieldFound = null,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "NullableInt32Field", "NullableStringField" },
+				{ "1" },
+				{ "", "Foo" },
+				{ "", "" },
+				{ "4", "Bar" },
+			};
+
+			using (var csv = new CsvReader(parser))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add(string.Empty); // Read empty fields as nulls instead of `""`.
+
+				// Read header row, assert header row columns:
+				Assert.True(csv.Read());
+				Assert.True(csv.ReadHeader());
+				Assert.Equal(2, csv.HeaderRecord.Length);
+				Assert.Equal("NullableInt32Field", csv.HeaderRecord[0]);
+				Assert.Equal("NullableStringField", csv.HeaderRecord[1]);
+
+				// Read first data row:
+				Assert.True(csv.Read());
+
+				// Read `Int32?`, assert "1" value:
+				var nullableIntValueByIndex = csv.GetField<int?>(0);
+				var nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.True(nullableIntValueByIndex.HasValue);
+				Assert.True(nullableIntValueByName.HasValue);
+
+				Assert.Equal(1, nullableIntValueByIndex);
+				Assert.Equal(1, nullableIntValueByName);
+
+				// Read nullable String, assert null value:
+				var strByIndex = csv.GetField<string>(1);
+				var strByName = csv.GetField<string>("NullableStringField");
+
+				Assert.Null(strByIndex);
+				Assert.Null(strByName);
+
+				// Read second data row:
+				Assert.True(csv.Read());
+
+				// Read `Int32?`, assert NULL value:
+				nullableIntValueByIndex = csv.GetField<int?>(0);
+				nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.False(nullableIntValueByIndex.HasValue);
+				Assert.False(nullableIntValueByName.HasValue);
+
+				// Read nullable String, assert "Foo" value:
+				strByIndex = csv.GetField<string>(1);
+				strByName = csv.GetField<string>("NullableStringField");
+
+				Assert.Equal("Foo", strByIndex);
+				Assert.Equal("Foo", strByName);
+
+				// Read third data row:
+				Assert.True(csv.Read());
+
+				// Read `Int32?`, assert NULL value:
+				nullableIntValueByIndex = csv.GetField<int?>(0);
+				nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.False(nullableIntValueByIndex.HasValue);
+				Assert.False(nullableIntValueByName.HasValue);
+
+				// Read nullable String, assert "Foo" value:
+				strByIndex = csv.GetField<string>(1);
+				strByName = csv.GetField<string>("NullableStringField");
+
+				Assert.Null(strByIndex);
+				Assert.Null(strByName);
+
+				// Read fourth data row:
+				Assert.True(csv.Read());
+
+				// Read `Int32?`, assert "3" value:
+				nullableIntValueByIndex = csv.GetField<int?>(0);
+				nullableIntValueByName = csv.GetField<int?>("NullableInt32Field");
+
+				Assert.True(nullableIntValueByIndex.HasValue);
+				Assert.True(nullableIntValueByName.HasValue);
+
+				Assert.Equal(4, nullableIntValueByIndex);
+				Assert.Equal(4, nullableIntValueByName);
+
+				// Read nullable String, assert "Bar" value:
+				strByIndex = csv.GetField<string>(1);
+				strByName = csv.GetField<string>("NullableStringField");
+
+				Assert.Equal("Bar", strByIndex);
+				Assert.Equal("Bar", strByName);
+
+				// Read to end of file:
+				Assert.False(csv.Read());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/PrivateSettersInParentTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/PrivateSettersInParentTests.cs
new file mode 100644
index 0000000..af192f0
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/PrivateSettersInParentTests.cs
@@ -0,0 +1,90 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class PrivateSettersInParentTests
+	{
+		[Fact]
+		public void AutoMappingTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IncludePrivateMembers = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				var records = csv.GetRecords<Child>().ToList();
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void ClassMappingTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				IncludePrivateMembers = true,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<ChildMap>();
+
+				var records = csv.GetRecords<Child>().ToList();
+				Assert.Equal(1, records[0].Id);
+				Assert.Equal("one", records[0].Name);
+			}
+		}
+
+		private class Parent
+		{
+			public int Id { get; private set; }
+
+			public string Name { get; set; }
+
+			public Parent() { }
+
+			public Parent(int id, string name)
+			{
+				Id = id;
+				Name = name;
+			}
+		}
+
+		private class Child : Parent { }
+
+		private sealed class ChildMap : ClassMap<Child>
+		{
+			public ChildMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ReadHeaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ReadHeaderTests.cs
new file mode 100644
index 0000000..a502db4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ReadHeaderTests.cs
@@ -0,0 +1,166 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class ReadHeaderTests
+	{
+		[Fact]
+		public void ReadHeaderReadsHeaderTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "One" },
+				{ "2", "two" },
+				null
+			};
+
+			var csv = new CsvReader(parser);
+			csv.Read();
+			csv.ReadHeader();
+
+			Assert.NotNull(csv.HeaderRecord);
+			Assert.Equal("Id", csv.HeaderRecord[0]);
+			Assert.Equal("Name", csv.HeaderRecord[1]);
+		}
+
+		[Fact]
+		public void ReadHeaderDoesNotAffectCurrentRecordTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "One" },
+				{ "2", "two" },
+				null,
+			};
+
+			var csv = new CsvReader(parser);
+			csv.Read();
+			csv.ReadHeader();
+
+			Assert.Equal("Id", csv.Parser[0]);
+			Assert.Equal("Name", csv.Parser[1]);
+		}
+
+		[Fact]
+		public void ReadingHeaderFailsWhenReaderIsDoneTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "Id", "Name" },
+				{ "1", "One" },
+				{ "2", "two" },
+				null,
+			};
+
+			var csv = new CsvReader(parser);
+			while (csv.Read()) { }
+
+			Assert.Throws<ReaderException>(() => csv.ReadHeader());
+		}
+
+		[Fact]
+		public void ReadingHeaderFailsWhenNoHeaderRecordTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "Id", "Name" },
+				{ "1", "One" },
+				{ "2", "two" },
+				null
+			};
+
+			var csv = new CsvReader(parser);
+
+			Assert.Throws<ReaderException>(() => csv.ReadHeader());
+		}
+
+		[Fact]
+		public void ReadingHeaderDoesNotFailWhenHeaderAlreadyReadTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1", "One" },
+				{ "2", "two" },
+				null
+			};
+
+			var csv = new CsvReader(parser);
+			csv.Read();
+			csv.ReadHeader();
+			csv.ReadHeader();
+		}
+
+		[Fact]
+		public void ReadHeaderResetsNamedIndexesTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "Name", "Id" },
+			};
+			var csv = new CsvReader(parser);
+			csv.Read();
+			csv.ReadHeader();
+
+			Assert.Equal(0, csv.GetFieldIndex("Id"));
+			Assert.Equal(1, csv.GetFieldIndex("Name"));
+
+			csv.Read();
+			csv.ReadHeader();
+
+			Assert.Equal(1, csv.GetFieldIndex("Id"));
+			Assert.Equal(0, csv.GetFieldIndex("Name"));
+		}
+
+		[Fact]
+		public void MultipleReadHeaderCallsWorksWithNamedIndexCacheTest()
+		{
+			var parser = new ParserMock
+			{
+				{ "Id", "Name", "Id", "Name" },
+				{ "1", "one", "2", "two" },
+				{ "Name", "Id", "Name", "Id" },
+				{ "three", "3", "four", "4" },
+			};
+			var csv = new CsvReader(parser);
+
+			csv.Read();
+			csv.ReadHeader();
+			csv.Read();
+
+			Assert.Equal(1, csv.GetField<int>("Id"));
+			Assert.Equal("one", csv.GetField("Name"));
+			Assert.Equal(2, csv.GetField<int>("Id", 1));
+			Assert.Equal("two", csv.GetField("Name", 1));
+
+			csv.Read();
+			csv.ReadHeader();
+			csv.Read();
+
+			Assert.Equal(3, csv.GetField<int>("Id"));
+			Assert.Equal("three", csv.GetField("Name"));
+			Assert.Equal(4, csv.GetField<int>("Id", 1));
+			Assert.Equal("four", csv.GetField("Name", 1));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ShouldSkipRecordTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ShouldSkipRecordTests.cs
new file mode 100644
index 0000000..cac1fd8
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ShouldSkipRecordTests.cs
@@ -0,0 +1,87 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class ShouldSkipRecordTests
+	{
+		[Fact]
+		public void SkipEmptyHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldSkipRecord = args => args.Row.Parser.Record.All(string.IsNullOrWhiteSpace),
+			};
+			var parser = new ParserMock(config)
+			{
+				{ " " },
+				{ "First,Second" },
+				{ "1", "2" },
+			};
+
+			var csv = new CsvReader(parser);
+
+			csv.Read();
+			csv.ReadHeader();
+			csv.Read();
+			Assert.Equal("1", csv.GetField(0));
+			Assert.Equal("2", csv.GetField(1));
+		}
+
+		[Fact]
+		public void SkipEmptyRowTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldSkipRecord = args => args.Row.Parser.Record.All(string.IsNullOrWhiteSpace),
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "First,Second" },
+				{ " " },
+				{ "1", "2" },
+			};
+
+			var csv = new CsvReader(parser);
+
+			csv.Read();
+			csv.ReadHeader();
+			csv.Read();
+			Assert.Equal("1", csv.GetField(0));
+			Assert.Equal("2", csv.GetField(1));
+		}
+
+		[Fact]
+		public void ShouldSkipWithEmptyRows()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldSkipRecord = args => args.Row[0].StartsWith("skipme") || args.Row.Parser.Record.All(string.IsNullOrWhiteSpace),
+			};
+
+			var parser = new ParserMock(config)
+			{
+				{ "First,Second" },
+				{ "skipme," },
+				{ "" },
+				{ "1", "2" },
+			};
+
+			var csv = new CsvReader(parser);
+
+			csv.Read();
+			csv.Read();
+			Assert.Equal("1", csv.GetField(0));
+			Assert.Equal("2", csv.GetField(1));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/TryGetTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/TryGetTests.cs
new file mode 100644
index 0000000..2814fb2
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/TryGetTests.cs
@@ -0,0 +1,228 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class TryGetTests
+	{
+		[Fact]
+		public void TryGetFieldInvalidIndexTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "One", "Two" },
+				new[] { "one", "two" },
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			var got = reader.TryGetField(0, out int field);
+			Assert.False(got);
+			Assert.Equal(default(int), field);
+		}
+
+		[Fact]
+		public void TryGetFieldInvalidNameTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "One", "Two" },
+				new[] { "one", "two" },
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+
+			var got = reader.TryGetField("One", out int field);
+			Assert.False(got);
+			Assert.Equal(default(int), field);
+		}
+
+		[Fact]
+		public void TryGetFieldTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "One", "Two" },
+				new[] { "1", "2" },
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			var got = reader.TryGetField(0, out int field);
+			Assert.True(got);
+			Assert.Equal(1, field);
+		}
+
+		[Fact]
+		public void TryGetFieldStrictTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "One", "Two" },
+				new[] { "1", "2" },
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			var got = reader.TryGetField("One", out int field);
+			Assert.True(got);
+			Assert.Equal(1, field);
+		}
+
+		[Fact]
+		public void TryGetFieldEmptyDate()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+
+			// DateTimeConverter.IsValid() doesn't work correctly
+			// so we need to test and make sure that the conversion
+			// fails for an empty string for a date.
+			var parserMock = new ParserMock(config)
+			{
+				new[] { " " },
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			var got = reader.TryGetField(0, out DateTime field);
+
+			Assert.False(got);
+			Assert.Equal(DateTime.MinValue, field);
+		}
+
+		[Fact]
+		public void TryGetNullableFieldEmptyDate()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+
+			// DateTimeConverter.IsValid() doesn't work correctly
+			// so we need to test and make sure that the conversion
+			// fails for an empty string for a date.
+			var parserMock = new ParserMock(config)
+			{
+				new[] { " " },
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+
+			var got = reader.TryGetField(0, out DateTime? field);
+
+			Assert.False(got);
+			Assert.Null(field);
+		}
+
+		[Fact]
+		public void TryGetDoesNotThrowWhenWillThrowOnMissingFieldIsEnabled()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+
+			var parserMock = new ParserMock(config)
+			{
+				new[] { "1" },
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			Assert.False(reader.TryGetField("test", out string field));
+		}
+
+		[Fact]
+		public void TryGetFieldIndexTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "One", "Two", "Two" },
+				{ "1", "2", "3" }
+			};
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			var got = reader.TryGetField("Two", 0, out int field);
+			Assert.True(got);
+			Assert.Equal(2, field);
+
+			got = reader.TryGetField("Two", 1, out field);
+			Assert.True(got);
+			Assert.Equal(3, field);
+		}
+
+		[Fact]
+		public void TryGetMissingDateTimeFieldTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "Name" },
+				{ "1" },
+				null
+			};
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			var got = reader.TryGetField(typeof(DateTime), "Name", out object field);
+
+			Assert.False(got);
+			Assert.Equal(DateTime.MinValue, field);
+		}
+
+		[Fact]
+		public void TryGetMissingDateTimeOffsetFieldTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{ "Id", "DateTime" },
+				{ "1" },
+				null
+			};
+			var reader = new CsvReader(parserMock);
+			reader.Read();
+			reader.ReadHeader();
+			reader.Read();
+
+			var got = reader.TryGetField(typeof(DateTimeOffset), "DateTime", out object field);
+
+			Assert.False(got);
+			Assert.Equal(DateTimeOffset.MinValue, field);
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ValidateTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ValidateTests.cs
new file mode 100644
index 0000000..1b9da38
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ValidateTests.cs
@@ -0,0 +1,197 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace CsvHelper.Tests.Reading
+{
+
+	public class ValidateTests
+	{
+		[Fact]
+		public void GenericValidateTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine(",one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<GenericValidateMap>();
+				Assert.Throws<FieldValidationException>(() => csv.GetRecords<Test>().ToList());
+			}
+		}
+
+		[Fact]
+		public void NonGenericValidateTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine(",one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<NonGenericValidateMap>();
+				Assert.Throws<FieldValidationException>(() => csv.GetRecords<Test>().ToList());
+			}
+		}
+
+		[Fact]
+		public void LogInsteadTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine("1,");
+				writer.Flush();
+				stream.Position = 0;
+
+				var logger = new StringBuilder();
+				csv.Context.RegisterClassMap(new LogInsteadMap(logger));
+				csv.GetRecords<Test>().ToList();
+
+				var expected = new StringBuilder();
+				expected.AppendLine("Field '' is not valid!");
+
+				Assert.Equal(expected.ToString(), logger.ToString());
+			}
+		}
+
+		[Fact]
+		public void CustomExceptionTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				MissingFieldFound = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Id,Name");
+				writer.WriteLine(",one");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<CustomExceptionMap>();
+				Assert.Throws<CustomException>(() => csv.GetRecords<Test>().ToList());
+			}
+		}
+
+		[Fact]
+		public void ValidateMessageTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+			};
+			var s = new TestStringBuilder(config.NewLine);
+			s.AppendLine("Id,Name");
+			s.AppendLine("1,one");
+			using (var reader = new StringReader(s))
+			using (var csv = new CsvReader(reader, config))
+			{
+				csv.Context.RegisterClassMap<ValidationMessageMap>();
+				var exception = Assert.Throws<FieldValidationException>(() => csv.GetRecords<Test>().ToList());
+				Assert.StartsWith("Field 'one' was not foo.", exception.Message);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class GenericValidateMap : ClassMap<Test>
+		{
+			public GenericValidateMap()
+			{
+				Map(m => m.Id).Validate(args => !string.IsNullOrEmpty(args.Field));
+				Map(m => m.Name);
+			}
+		}
+
+		private sealed class NonGenericValidateMap : ClassMap<Test>
+		{
+			public NonGenericValidateMap()
+			{
+				AutoMap(System.Globalization.CultureInfo.InvariantCulture);
+				foreach (var memberMap in MemberMaps)
+				{
+					Map(typeof(Test), memberMap.Data.Member).Validate(args => !string.IsNullOrEmpty(args.Field));
+				}
+			}
+		}
+
+		private sealed class LogInsteadMap : ClassMap<Test>
+		{
+			public LogInsteadMap(StringBuilder logger)
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Validate(args =>
+				{
+					var isValid = !string.IsNullOrEmpty(args.Field);
+					if (!isValid)
+					{
+						logger.AppendLine($"Field '{args.Field}' is not valid!");
+					}
+
+					return true;
+				});
+			}
+		}
+
+		private sealed class CustomExceptionMap : ClassMap<Test>
+		{
+			public CustomExceptionMap()
+			{
+				Map(m => m.Id).Validate(field => throw new CustomException());
+				Map(m => m.Name);
+			}
+		}
+
+		private class CustomException : CsvHelperException
+		{
+		}
+
+		private class ValidationMessageMap : ClassMap<Test>
+		{
+			public ValidationMessageMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Validate(args => args.Field == "foo", args => $"Field '{args.Field}' was not foo.");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/YieldTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/YieldTests.cs
new file mode 100644
index 0000000..a39d899
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/YieldTests.cs
@@ -0,0 +1,142 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Reading
+{
+	
+	public class YieldTests
+	{
+		[Fact]
+		public void GetRecordsGeneric_Disposed_ThrowsObjectDisposedExceptionTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "Id", "Name" },
+				new[] { "1", "one" },
+				null
+			};
+
+			IEnumerable<Foo> records;
+			using (var csv = new CsvReader(parserMock))
+			{
+				records = csv.GetRecords<Foo>();
+			}
+			Assert.Throws<ObjectDisposedException>(() => records.ToList());
+		}
+
+		[Fact]
+		public void GetRecords_Disposed_ThrowsObjectDisposedExceptionTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "Id", "Name" },
+				new[] { "1", "one" },
+				null
+			};
+
+			IEnumerable<object> records;
+			using (var csv = new CsvReader(parserMock))
+			{
+				records = csv.GetRecords(typeof(Foo));
+			}
+
+			Assert.Throws<ObjectDisposedException>(() => records.ToList());
+		}
+
+		[Fact]
+		public void EnumerateRecords_Disposed_ThrowsObjectDisposedExceptionTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "Id", "Name" },
+				new[] { "1", "one" },
+				null
+			};
+
+			Foo record = null;
+			IEnumerable<Foo> records;
+			using (var csv = new CsvReader(parserMock))
+			{
+				records = csv.EnumerateRecords(record);
+			}
+
+			Assert.Throws<ObjectDisposedException>(() => records.ToList());
+		}
+
+#if !NET45
+		[Fact]
+		public async Task GetRecordsAsyncGeneric_Disposed_ThrowsObjectDisposedExceptionTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "Id", "Name" },
+				new[] { "1", "one" },
+				null
+			};
+
+			IAsyncEnumerable<Foo> records;
+			using (var csv = new CsvReader(parserMock))
+			{
+				records = csv.GetRecordsAsync<Foo>();
+			}
+
+			await Assert.ThrowsAsync<ObjectDisposedException>(async () => await records.GetAsyncEnumerator().MoveNextAsync());
+		}
+
+		[Fact]
+		public async Task GetRecordsAsync_Disposed_ThrowsObjectDisposedExceptionTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "Id", "Name" },
+				new[] { "1", "one" },
+				null
+			};
+
+			IAsyncEnumerable<object> records;
+			using (var csv = new CsvReader(parserMock))
+			{
+				records = csv.GetRecordsAsync(typeof(Foo));
+			}
+
+			await Assert.ThrowsAsync<ObjectDisposedException>(async () => await records.GetAsyncEnumerator().MoveNextAsync());
+		}
+
+		[Fact]
+		public async Task EnumerateRecordsAsync_Disposed_ThrowsObjectDisposedExceptionTest()
+		{
+			var parserMock = new ParserMock
+			{
+				new[] { "Id", "Name" },
+				new[] { "1", "one" },
+				null
+			};
+
+			Foo record = null;
+			IAsyncEnumerable<Foo> records;
+			using (var csv = new CsvReader(parserMock))
+			{
+				records = csv.EnumerateRecordsAsync(record);
+			}
+
+			await Assert.ThrowsAsync<ObjectDisposedException>(async () => await records.GetAsyncEnumerator().MoveNextAsync());
+		}
+#endif
+
+		private class Foo
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ReferenceMappingClassMapTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ReferenceMappingClassMapTests.cs
new file mode 100644
index 0000000..bc0b210
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ReferenceMappingClassMapTests.cs
@@ -0,0 +1,169 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class ReferenceMappingClassMapTests
+	{
+		[Fact]
+		public void ReferenceMappingTest()
+		{
+			var parserMock = new ParserMock
+			{
+				{
+					"FirstName",
+					"LastName",
+					"HomeStreet",
+					"HomeCity",
+					"HomeState",
+					"HomeZip",
+					"WorkStreet",
+					"WorkCity",
+					"WorkState",
+					"WorkZip"
+				},
+			};
+			var row = new[]
+			{
+				"John",
+				"Doe",
+				"1234 Home St",
+				"Home Town",
+				"Home State",
+				"12345",
+				"5678 Work Rd",
+				"Work City",
+				"Work State",
+				"67890"
+			};
+			parserMock.Add(row);
+
+			var reader = new CsvReader(parserMock);
+			reader.Context.RegisterClassMap<PersonMap>();
+			reader.Read();
+			var person = reader.GetRecord<Person>();
+
+			Assert.Equal(row[0], person.FirstName);
+			Assert.Equal(row[1], person.LastName);
+			Assert.Equal(row[2], person.HomeAddress.Street);
+			Assert.Equal(row[3], person.HomeAddress.City);
+			Assert.Equal(row[4], person.HomeAddress.State);
+			Assert.Equal(row[5], person.HomeAddress.Zip);
+			Assert.Equal(row[6], person.WorkAddress.Street);
+			Assert.Equal(row[7], person.WorkAddress.City);
+			Assert.Equal(row[8], person.WorkAddress.State);
+			Assert.Equal(row[9], person.WorkAddress.Zip);
+		}
+
+		[Fact]
+		public void OnlyReferencesTest()
+		{
+			var parserMock = new ParserMock()
+			{
+				new[]
+				{
+					"FirstName",
+					"LastName",
+					"HomeStreet",
+					"HomeCity",
+					"HomeState",
+					"HomeZip",
+					"WorkStreet",
+					"WorkCity",
+					"WorkState",
+					"WorkZip"
+				},
+				new[]
+				{
+					"John",
+					"Doe",
+					"1234 Home St",
+					"Home Town",
+					"Home State",
+					"12345",
+					"5678 Work Rd",
+					"Work City",
+					"Work State",
+					"67890"
+				},
+				null
+			};
+
+			var reader = new CsvReader(parserMock);
+			reader.Context.RegisterClassMap<OnlyReferencesMap>();
+			reader.Read();
+			var person = reader.GetRecord<Person>();
+		}
+
+		private class Person
+		{
+			public string FirstName { get; set; }
+
+			public string LastName { get; set; }
+
+			public Address HomeAddress { get; set; }
+
+			public Address WorkAddress { get; set; }
+		}
+
+		private class Address
+		{
+			public string Street { get; set; }
+
+			public string City { get; set; }
+
+			public string State { get; set; }
+
+			public string Zip { get; set; }
+		}
+
+		private sealed class PersonMap : ClassMap<Person>
+		{
+			public PersonMap()
+			{
+				Map(m => m.FirstName);
+				Map(m => m.LastName);
+				References<HomeAddressMap>(m => m.HomeAddress);
+				References<WorkAddressMap>(m => m.WorkAddress);
+			}
+		}
+
+		private sealed class HomeAddressMap : ClassMap<Address>
+		{
+			public HomeAddressMap()
+			{
+				Map(m => m.Street).Name("HomeStreet");
+				Map(m => m.City).Name("HomeCity");
+				Map(m => m.State).Name("HomeState");
+				Map(m => m.Zip).Name("HomeZip");
+			}
+		}
+
+		private sealed class WorkAddressMap : ClassMap<Address>
+		{
+			public WorkAddressMap()
+			{
+				Map(m => m.Street).Name("WorkStreet");
+				Map(m => m.City).Name("WorkCity");
+				Map(m => m.State).Name("WorkState");
+				Map(m => m.Zip).Name("WorkZip");
+			}
+		}
+
+		private sealed class OnlyReferencesMap : ClassMap<Person>
+		{
+			public OnlyReferencesMap()
+			{
+				References<HomeAddressMap>(m => m.HomeAddress);
+				References<WorkAddressMap>(m => m.WorkAddress);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ReferenceMappingIndexTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ReferenceMappingIndexTests.cs
new file mode 100644
index 0000000..e926f79
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/ReferenceMappingIndexTests.cs
@@ -0,0 +1,69 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests
+{
+	
+	public class ReferenceMappingIndexTests
+	{
+		[Fact]
+		public void MapByIndexTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				new[] { "0", "1" },
+				new[] { "2", "3" },
+			};
+
+			var csv = new CsvReader(parserMock);
+			csv.Context.RegisterClassMap<AMap>();
+
+			var records = csv.GetRecords<A>().ToList();
+			Assert.Equal(1, records[0].Id);
+			Assert.Equal(0, records[0].B.Id);
+			Assert.Equal(3, records[1].Id);
+			Assert.Equal(2, records[1].B.Id);
+		}
+
+		private class A
+		{
+			public int Id { get; set; }
+
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public int Id { get; set; }
+		}
+
+		private sealed class AMap : ClassMap<A>
+		{
+			public AMap()
+			{
+				Map(m => m.Id).Index(1);
+				References<BMap>(m => m.B);
+			}
+		}
+
+		private sealed class BMap : ClassMap<B>
+		{
+			public BMap()
+			{
+				Map(m => m.Id).Index(0);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reflection/GetMemberExpressionStackTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reflection/GetMemberExpressionStackTests.cs
new file mode 100644
index 0000000..a779081
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reflection/GetMemberExpressionStackTests.cs
@@ -0,0 +1,56 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+
+namespace CsvHelper.Tests.Reflection
+{
+
+	public class GetPropertiesTests
+	{
+		[Fact]
+		public void FirstLevelTest()
+		{
+			var stack = ReflectionHelper.GetMembers<A, string>(a => a.P1);
+
+			Assert.Single(stack);
+			Assert.Equal("P1", stack.Pop().Name);
+		}
+
+		[Fact]
+		public void LastLevelTest()
+		{
+			var stack = ReflectionHelper.GetMembers<A, string>(a => a.B.C.D.P4);
+
+			Assert.Equal(4, stack.Count);
+			Assert.Equal("B", stack.Pop().Name);
+			Assert.Equal("C", stack.Pop().Name);
+			Assert.Equal("D", stack.Pop().Name);
+			Assert.Equal("P4", stack.Pop().Name);
+		}
+
+		private class A
+		{
+			public string P1 { get; set; }
+			public B B { get; set; }
+		}
+
+		private class B
+		{
+			public string P2 { get; set; }
+			public C C { get; set; }
+		}
+
+		private class C
+		{
+			public string P3 { get; set; }
+			public D D { get; set; }
+		}
+
+		private class D
+		{
+			public string P4 { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TestStringBuilder.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TestStringBuilder.cs
new file mode 100644
index 0000000..43bfc75
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TestStringBuilder.cs
@@ -0,0 +1,34 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Text;
+
+namespace CsvHelper.Tests
+{
+	/// <summary>
+	/// A <see cref="StringBuilder"/> like class with configurable line ending for unit tests.
+	/// </summary>
+	public class TestStringBuilder
+	{
+		private readonly string newLine;
+		private readonly StringBuilder builder;
+
+		public TestStringBuilder(string newLine)
+		{
+			this.newLine = newLine ?? throw new ArgumentNullException(nameof(newLine));
+			builder = new StringBuilder();
+		}
+
+		public TestStringBuilder AppendLine(string value)
+		{
+			builder.Append(value).Append(newLine);
+			return this;
+		}
+
+		public override string ToString() => builder.ToString();
+
+		public static implicit operator string(TestStringBuilder sb) => sb.ToString();
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TestStringWriter.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TestStringWriter.cs
new file mode 100644
index 0000000..7691faa
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TestStringWriter.cs
@@ -0,0 +1,28 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.IO;
+
+namespace CsvHelper.Tests
+{
+	/// <summary>
+	/// A <see cref="StreamWriter"/> class with configurable line ending for unit tests.
+	/// </summary>
+	public class TestStreamWriter : StreamWriter
+	{
+		private readonly string newLine;
+
+		public TestStreamWriter(Stream stream, string newLine = "\r\n") : base(stream)
+		{
+			this.newLine = newLine ?? throw new ArgumentNullException(nameof(newLine));
+		}
+
+		public override void WriteLine(string value)
+		{
+			base.Write(value);
+			base.Write(newLine);
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ArrayConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ArrayConverterTests.cs
new file mode 100644
index 0000000..7f98b0d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ArrayConverterTests.cs
@@ -0,0 +1,211 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using System.Collections.Generic;
+using System.IO;
+using Xunit;
+using System.Reflection;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.Configuration.Attributes;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+
+	public class ArrayConverterTests
+	{
+		[Fact]
+		public void FullReadNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithDefaultHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestDefaultMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithNamedHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderListItemsScattered()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,A,List,B,List,After");
+				writer.WriteLine("1,2,3,4,5,6,7");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(4, list[1]);
+				Assert.Equal(6, list[2]);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_NullValuesAttributeWithIndex_UsesCustomNullValue()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "NULL", "", "2" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<NullValuesAttributeIndexTest>().ToList();
+			}
+		}
+
+		private class NullValuesAttributeIndexTest
+		{
+			[Index(0, 2)]
+			[NullValues("NULL")]
+			public int?[] List { get; set; }
+		}
+
+		private class Test
+		{
+			public string Before { get; set; }
+			public int?[] List { get; set; }
+			public string After { get; set; }
+		}
+
+		private sealed class TestIndexMap : ClassMap<Test>
+		{
+			public TestIndexMap()
+			{
+				Map(m => m.Before).Index(0);
+				Map(m => m.List).Index(1, 3);
+				Map(m => m.After).Index(4);
+			}
+		}
+
+		private sealed class TestNamedMap : ClassMap<Test>
+		{
+			public TestNamedMap()
+			{
+				Map(m => m.Before).Name("Before");
+				Map(m => m.List).Name("List");
+				Map(m => m.After).Name("After");
+			}
+		}
+
+		private sealed class TestDefaultMap : ClassMap<Test>
+		{
+			public TestDefaultMap()
+			{
+				Map(m => m.Before);
+				Map(m => m.List);
+				Map(m => m.After);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/BigIntegerConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/BigIntegerConverterTests.cs
new file mode 100644
index 0000000..6b0c580
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/BigIntegerConverterTests.cs
@@ -0,0 +1,40 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+    
+    public class BigIntegerConverterTests
+    {
+        [Fact]
+        public void RoundTripMaxValueTest()
+        {
+            var converter = new BigIntegerConverter();
+            var s = converter.ConvertToString((BigInteger)long.MaxValue + 1, null, new MemberMapData(null));
+            var bi = converter.ConvertFromString(s, null, new MemberMapData(null));
+
+            Assert.Equal((BigInteger)long.MaxValue + 1, bi);
+        }
+
+        [Fact]
+        public void RoundTripMinValueTest()
+        {
+            var converter = new BigIntegerConverter();
+            var s = converter.ConvertToString((BigInteger)long.MinValue - 1, null, new MemberMapData(null));
+            var bi = converter.ConvertFromString(s, null, new MemberMapData(null));
+
+            Assert.Equal((BigInteger)long.MinValue - 1, bi);
+        }
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/BooleanConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/BooleanConverterTests.cs
new file mode 100644
index 0000000..4cb9769
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/BooleanConverterTests.cs
@@ -0,0 +1,166 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class BooleanConverterTests
+	{
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new BooleanConverter();
+
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			Assert.Equal("True", converter.ConvertToString(true, null, memberMapData));
+
+			Assert.Equal("False", converter.ConvertToString(false, null, memberMapData));
+
+			Assert.Equal("", converter.ConvertToString(null, null, memberMapData));
+			Assert.Equal("1", converter.ConvertToString(1, null, memberMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new BooleanConverter();
+
+			var memberMapData = new MemberMapData(null);
+			memberMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			Assert.True((bool)converter.ConvertFromString("true", null, memberMapData));
+			Assert.True((bool)converter.ConvertFromString("True", null, memberMapData));
+			Assert.True((bool)converter.ConvertFromString("TRUE", null, memberMapData));
+			Assert.True((bool)converter.ConvertFromString("1", null, memberMapData));
+			Assert.True((bool)converter.ConvertFromString(" true ", null, memberMapData));
+
+			Assert.False((bool)converter.ConvertFromString("false", null, memberMapData));
+			Assert.False((bool)converter.ConvertFromString("False", null, memberMapData));
+			Assert.False((bool)converter.ConvertFromString("FALSE", null, memberMapData));
+			Assert.False((bool)converter.ConvertFromString("0", null, memberMapData));
+			Assert.False((bool)converter.ConvertFromString(" false ", null, memberMapData));
+			Assert.False((bool)converter.ConvertFromString(" 0 ", null, memberMapData));
+
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, memberMapData));
+		}
+
+		[Fact]
+		public void ConvertToString_SingleBooleanTrueValue_UsesValue()
+		{
+			var converter = new BooleanConverter();
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions =
+				{
+					BooleanTrueValues = { "Foo" },
+				},
+			};
+
+			var value = converter.ConvertToString(true, null, memberMapData);
+
+			Assert.Equal("Foo", value);
+		}
+
+		[Fact]
+		public void ConvertToString_MultipleBooleanTrueValues_UsesFirstValue()
+		{
+			var converter = new BooleanConverter();
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions =
+				{
+					BooleanTrueValues = { "Foo", "Bar" },
+				},
+			};
+
+			var value = converter.ConvertToString(true, null, memberMapData);
+
+			Assert.Equal("Foo", value);
+		}
+
+		[Fact]
+		public void ConvertToString_SingleBooleanFalseValue_UsesValue()
+		{
+			var converter = new BooleanConverter();
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions =
+				{
+					BooleanFalseValues = { "Foo" },
+				},
+			};
+
+			var value = converter.ConvertToString(false, null, memberMapData);
+
+			Assert.Equal("Foo", value);
+		}
+
+		[Fact]
+		public void ConvertToString_MultipleBooleanFalseValues_UsesFirstValue()
+		{
+			var converter = new BooleanConverter();
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions =
+				{
+					BooleanFalseValues = { "Foo", "Bar" },
+				},
+			};
+
+			var value = converter.ConvertToString(false, null, memberMapData);
+
+			Assert.Equal("Foo", value);
+		}
+
+		[Fact]
+		public void WriteField_TrueValue_UsesValue()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<bool>().BooleanTrueValues.Add("Foo");
+
+				csv.WriteField(true);
+				csv.Flush();
+				writer.Flush();
+
+				Assert.Equal("Foo", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_FalseValue_UsesValue()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<bool>().BooleanFalseValues.Add("Foo");
+
+				csv.WriteField(false);
+				csv.Flush();
+				writer.Flush();
+
+				Assert.Equal("Foo", writer.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ByteArrayConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ByteArrayConverterTests.cs
new file mode 100644
index 0000000..58d1920
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ByteArrayConverterTests.cs
@@ -0,0 +1,139 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Linq;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class ByteArrayConverterTests
+	{
+		[Fact]
+		public void WhenConverting_FromStringToByteArray_ReturnsCorrectValues()
+		{
+			var testCases = new[]
+			{
+				new
+				{
+					Options = ByteArrayConverterOptions.Hexadecimal | ByteArrayConverterOptions.HexInclude0x,
+					FieldStrings = new[] { "0xDEAD", "0xB33FBEEF", "0xEA5EEA5EEA5E", "0xCA75CA75CA75CA75" },
+					Expected = new []
+					{
+						new byte[] { 0xDE, 0xAD },
+						new byte[] { 0xB3, 0x3F, 0xBE, 0xEF },
+						new byte[] { 0xEA, 0x5E, 0xEA, 0x5E, 0xEA, 0x5E },
+						new byte[] { 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 }
+					}
+				},
+				new
+				{
+					Options = ByteArrayConverterOptions.Hexadecimal | ByteArrayConverterOptions.HexDashes,
+					FieldStrings = new[] { "DE-AD", "B3-3F-BE-EF", "EA-5E-EA-5E-EA-5E", "CA-75-CA-75-CA-75-CA-75" },
+					Expected = new []
+					{
+						new byte[] { 0xDE, 0xAD },
+						new byte[] { 0xB3, 0x3F, 0xBE, 0xEF },
+						new byte[] { 0xEA, 0x5E, 0xEA, 0x5E, 0xEA, 0x5E },
+						new byte[] { 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 }
+					}
+				},
+				new
+				{
+					Options = ByteArrayConverterOptions.Base64,
+					FieldStrings = new []
+					{
+						Convert.ToBase64String( new byte[] { 0xDE, 0xAD } ),
+						Convert.ToBase64String( new byte[] { 0xB3, 0x3F, 0xBE, 0xEF } ),
+						Convert.ToBase64String( new byte[] { 0xEA, 0x5E, 0xEA, 0x5E, 0xEA, 0x5E } ),
+						Convert.ToBase64String( new byte[] { 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 } )
+					},
+					Expected = new []
+					{
+						new byte[] { 0xDE, 0xAD },
+						new byte[] { 0xB3, 0x3F, 0xBE, 0xEF },
+						new byte[] { 0xEA, 0x5E, 0xEA, 0x5E, 0xEA, 0x5E },
+						new byte[] { 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 }
+					}
+				}
+			};
+
+			foreach( var t in testCases )
+			{
+				var converter = new ByteArrayConverter( t.Options );
+				foreach( var f in t.FieldStrings.Zip( t.Expected, ( test, expected ) => new { test, expected } ) )
+				{
+					var actual = (byte[])converter.ConvertFromString( f.test, null, null );
+					foreach( var b in actual.Zip( f.expected, ( a, e ) => new { a, e } ) )
+					{
+						Assert.Equal( b.e, b.a );
+					}
+				}
+			}
+		}
+
+		[Fact]
+		public void WhenConverting_FromByteArrayToString_ReturnsCorrectValues()
+		{
+			var testCases = new[]
+			{
+				new
+				{
+					Options = ByteArrayConverterOptions.Hexadecimal | ByteArrayConverterOptions.HexInclude0x,
+					Expected = new[] { "0xDEAD", "0xB33FBEEF", "0xEA5EEA5EEA5E", "0xCA75CA75CA75CA75" },
+					FieldBytes = new []
+					{
+						new byte[] { 0xDE, 0xAD },
+						new byte[] { 0xB3, 0x3F, 0xBE, 0xEF },
+						new byte[] { 0xEA, 0x5E, 0xEA, 0x5E, 0xEA, 0x5E },
+						new byte[] { 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 }
+					}
+				},
+				new
+				{
+					Options = ByteArrayConverterOptions.Hexadecimal | ByteArrayConverterOptions.HexDashes,
+					Expected = new[] { "DE-AD", "B3-3F-BE-EF", "EA-5E-EA-5E-EA-5E", "CA-75-CA-75-CA-75-CA-75" },
+					FieldBytes = new []
+					{
+						new byte[] { 0xDE, 0xAD },
+						new byte[] { 0xB3, 0x3F, 0xBE, 0xEF },
+						new byte[] { 0xEA, 0x5E, 0xEA, 0x5E, 0xEA, 0x5E },
+						new byte[] { 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 }
+					}
+				},
+				new
+				{
+					Options = ByteArrayConverterOptions.Base64,
+					Expected = new []
+					{
+						Convert.ToBase64String( new byte[] { 0xDE, 0xAD } ),
+						Convert.ToBase64String( new byte[] { 0xB3, 0x3F, 0xBE, 0xEF } ),
+						Convert.ToBase64String( new byte[] { 0xEA, 0x5E, 0xEA, 0x5E, 0xEA, 0x5E } ),
+						Convert.ToBase64String( new byte[] { 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 } )
+					},
+					FieldBytes = new []
+					{
+						new byte[] { 0xDE, 0xAD },
+						new byte[] { 0xB3, 0x3F , 0xBE, 0xEF },
+						new byte[] { 0xEA, 0x5E , 0xEA, 0x5E, 0xEA, 0x5E },
+						new byte[] { 0xCA, 0x75 , 0xCA, 0x75, 0xCA, 0x75, 0xCA, 0x75 }
+					}
+				}
+			};
+
+			foreach( var t in testCases )
+			{
+				var converter = new ByteArrayConverter( t.Options );
+				foreach( var f in t.Expected.Zip( t.FieldBytes, ( expected, test ) => new { test, expected } ) )
+				{
+					var actual = converter.ConvertToString( f.test, null, null );
+
+					Assert.Equal( actual, f.expected );
+				}
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ByteConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ByteConverterTests.cs
new file mode 100644
index 0000000..cbeb016
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/ByteConverterTests.cs
@@ -0,0 +1,47 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class ByteConverterTests
+	{
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new ByteConverter();
+			var propertyMapData = new MemberMapData( null )
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			Assert.Equal( "123", converter.ConvertToString( (byte)123, null, propertyMapData ) );
+
+			Assert.Equal( "", converter.ConvertToString( null, null, propertyMapData ) );
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new ByteConverter();
+
+			var propertyMapData = new MemberMapData( null );
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			Assert.Equal( (byte)123, converter.ConvertFromString( "123", null, propertyMapData ) );
+			Assert.Equal( (byte)123, converter.ConvertFromString( " 123 ", null, propertyMapData ) );
+
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/CharConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/CharConverterTests.cs
new file mode 100644
index 0000000..aefa138
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/CharConverterTests.cs
@@ -0,0 +1,50 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class CharConverterTests
+	{
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new CharConverter();
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			Assert.Equal("a", converter.ConvertToString('a', null, propertyMapData));
+
+			Assert.Equal("True", converter.ConvertToString(true, null, propertyMapData));
+
+			Assert.Equal("", converter.ConvertToString(null, null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new CharConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			Assert.Equal('a', converter.ConvertFromString("a", null, propertyMapData));
+			Assert.Equal('a', converter.ConvertFromString(" a ", null, propertyMapData));
+			Assert.Equal(' ', converter.ConvertFromString(" ", null, propertyMapData));
+
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/CollectionGenericConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/CollectionGenericConverterTests.cs
new file mode 100644
index 0000000..c5efd01
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/CollectionGenericConverterTests.cs
@@ -0,0 +1,101 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using System.Collections.Generic;
+using System.IO;
+using Xunit;
+using System.Reflection;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.Configuration.Attributes;
+using System.Linq;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class CollectionGenericConverterTests
+	{
+		[Fact]
+		public void FullWriteTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { List = new List<int?> { 1, 2, 3 } }
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal("1,2,3\r\n", result);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_NullValuesAttributeWithIndex_UsesCustomNullValue()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "NULL", "", "2" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<NullValuesAttributeIndexTest>().ToList();
+			}
+		}
+
+		private class Test
+		{
+			public List<int?> List { get; set; }
+		}
+
+		private sealed class TestIndexMap : ClassMap<Test>
+		{
+			public TestIndexMap()
+			{
+				Map(m => m.List).Index(1, 3);
+			}
+		}
+
+		private sealed class TestNamedMap : ClassMap<Test>
+		{
+			public TestNamedMap()
+			{
+				Map(m => m.List).Name("List");
+			}
+		}
+
+		private sealed class TestDefaultMap : ClassMap<Test>
+		{
+			public TestDefaultMap()
+			{
+				Map(m => m.List);
+			}
+		}
+
+		private class NullValuesAttributeIndexTest
+		{
+			[Index(0, 2)]
+			[NullValues("NULL")]
+			public List<int?> List { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateOnlyConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateOnlyConverterTests.cs
new file mode 100644
index 0000000..4c567ba
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateOnlyConverterTests.cs
@@ -0,0 +1,59 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+#if NET6_0
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using System;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	public class DateOnlyConverterTests
+    {
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new DateOnlyConverter();
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var date = DateOnly.FromDateTime(DateTime.Now);
+
+			// Valid conversions.
+			Assert.Equal(date.ToString(), converter.ConvertToString(date, null, propertyMapData));
+
+			// Invalid conversions.
+			Assert.Equal("1", converter.ConvertToString(1, null, propertyMapData));
+			Assert.Equal("", converter.ConvertToString(null, null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new DateOnlyConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			var date = DateOnly.FromDateTime(DateTime.Now);
+
+			// Valid conversions.
+			Assert.Equal(date.ToString(), converter.ConvertFromString(date.ToString(), null, propertyMapData).ToString());
+			Assert.Equal(date.ToString(), converter.ConvertFromString(date.ToString("o"), null, propertyMapData).ToString());
+			Assert.Equal(date.ToString(), converter.ConvertFromString(" " + date + " ", null, propertyMapData).ToString());
+
+			// Invalid conversions.
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+		}
+	}
+}
+#endif
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateTimeConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateTimeConverterTests.cs
new file mode 100644
index 0000000..8f44627
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateTimeConverterTests.cs
@@ -0,0 +1,76 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class DateTimeConverterTests
+	{
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new DateTimeConverter();
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var dateTime = DateTime.Now;
+
+			// Valid conversions.
+			Assert.Equal(dateTime.ToString(), converter.ConvertToString(dateTime, null, propertyMapData));
+
+			// Invalid conversions.
+			Assert.Equal("1", converter.ConvertToString(1, null, propertyMapData));
+			Assert.Equal("", converter.ConvertToString(null, null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new DateTimeConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			var dateTime = DateTime.Now;
+
+			// Valid conversions.
+			Assert.Equal(dateTime.ToString(), converter.ConvertFromString(dateTime.ToString(), null, propertyMapData).ToString());
+			Assert.Equal(dateTime.ToString(), converter.ConvertFromString(dateTime.ToString("o"), null, propertyMapData).ToString());
+			Assert.Equal(dateTime.ToString(), converter.ConvertFromString(" " + dateTime + " ", null, propertyMapData).ToString());
+
+			// Invalid conversions.
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(" ", row, propertyMapData));
+		}
+
+		[Fact]
+		public void ComponentModelCompatibilityTest()
+		{
+			var converter = new DateTimeConverter();
+			var cmConverter = new System.ComponentModel.DateTimeConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			Assert.Throws<NotSupportedException>(() => cmConverter.ConvertFromString(null));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+			Assert.Throws<FormatException>(() => cmConverter.ConvertFromString("blah"));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString("blah", row, propertyMapData));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateTimeOffsetConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateTimeOffsetConverterTests.cs
new file mode 100644
index 0000000..b829361
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DateTimeOffsetConverterTests.cs
@@ -0,0 +1,75 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class DateTimeOffsetConverterTests
+	{
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new DateTimeOffsetConverter();
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var dateTime = DateTimeOffset.Now;
+
+			// Valid conversions.
+			Assert.Equal(dateTime.ToString(), converter.ConvertToString(dateTime, null, propertyMapData));
+
+			// Invalid conversions.
+			Assert.Equal("1", converter.ConvertToString(1, null, propertyMapData));
+			Assert.Equal("", converter.ConvertToString(null, null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new DateTimeOffsetConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			var dateTime = DateTimeOffset.Now;
+
+			// Valid conversions.
+			Assert.Equal(dateTime.ToString(), converter.ConvertFromString(dateTime.ToString(), null, propertyMapData).ToString());
+			Assert.Equal(dateTime.ToString(), converter.ConvertFromString(dateTime.ToString("o"), null, propertyMapData).ToString());
+			Assert.Equal(dateTime.ToString(), converter.ConvertFromString(" " + dateTime + " ", null, propertyMapData).ToString());
+
+			// Invalid conversions.
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+		}
+
+		[Fact]
+		public void ComponentModelCompatibilityTest()
+		{
+			var converter = new DateTimeOffsetConverter();
+			var cmConverter = new System.ComponentModel.DateTimeOffsetConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			Assert.Throws<NotSupportedException>(() => cmConverter.ConvertFromString(null));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+			Assert.Throws<FormatException>(() => cmConverter.ConvertFromString("blah"));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString("blah", row, propertyMapData));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DefaultConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DefaultConverterTests.cs
new file mode 100644
index 0000000..07818d2
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DefaultConverterTests.cs
@@ -0,0 +1,81 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+    public class DefaultConverterTests
+    {
+		[Fact]
+		public void ConvertToString_ValueIsNull_ReturnsEmptyString()
+		{
+			var converter = new DefaultTypeConverter();
+
+			var memberMapData = new MemberMapData(null)
+			{
+			};
+
+			var value = converter.ConvertToString(null, null, memberMapData);
+
+			Assert.Equal(string.Empty, value);
+		}
+
+		[Fact]
+        public void ConvertToString_SingleNullValue_UsesValue()
+		{
+			var converter = new DefaultTypeConverter();
+
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverterOptions = { NullValues = { "Foo" } },
+			};
+
+			var value = converter.ConvertToString(null, null, memberMapData);
+
+			Assert.Equal("Foo", value);
+		}
+
+		[Fact]
+		public void ConvertToString_MultipleNullValues_UsesFirstValue()
+		{
+			var converter = new DefaultTypeConverter();
+
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverterOptions = { NullValues = { "Foo", "Bar" } },
+			};
+
+			var value = converter.ConvertToString(null, null, memberMapData);
+
+			Assert.Equal("Foo", value);
+		}
+
+		[Fact]
+		public void WriteField_NullValue_UsesValue()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("Foo");
+
+				csv.WriteField<string>(null);
+				csv.Flush();
+				writer.Flush();
+
+				Assert.Equal("Foo", writer.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DefaultValueTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DefaultValueTests.cs
new file mode 100644
index 0000000..8b17420
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DefaultValueTests.cs
@@ -0,0 +1,67 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	public class DefaultValueTests
+	{
+		[Fact]
+		public void BigIntegerConverter_ConvertFromString_InvalidValue_UsesDefault()
+		{
+			var converter = new BigIntegerConverter();
+
+			var data = new MemberMapData(typeof(Foo).GetProperty(nameof(Foo.Property)));
+			data.IsDefaultSet = true;
+			data.Default = (BigInteger)1;
+			data.UseDefaultOnConversionFailure = true;
+
+			var result = converter.ConvertFromString("foo", null, data);
+
+			Assert.Equal(data.Default, result);
+		}
+
+		[Fact]
+		public void GetRecords_EmptyValue_DefaultSet_UsesDefault()
+		{
+			var s = new StringBuilder();
+			s.Append("Property\r\n");
+			s.Append("foo\r\n");
+			using (var reader = new StringReader(s.ToString()))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				var records = csv.GetRecords<Foo>().ToList();
+
+				Assert.Equal(1, records[0].Property);
+			}
+		}
+
+		private class Foo
+		{
+			public BigInteger Property { get; set; }
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Property).Default(1, useOnConversionFailure: true);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DoubleConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DoubleConverterTests.cs
new file mode 100644
index 0000000..12a3cc3
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/DoubleConverterTests.cs
@@ -0,0 +1,39 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+    
+    public class DoubleConverterTests
+    {
+		[Fact]
+		public void RoundTripMaxValueTest()
+        {
+            var converter = new DoubleConverter();
+            var s = converter.ConvertToString(double.MaxValue, null, new MemberMapData(null));
+            var d = converter.ConvertFromString(s, null, new MemberMapData(null));
+
+            Assert.Equal(double.MaxValue, d);
+        }
+
+        [Fact]
+        public void RoundTripMinValueTest()
+        {
+            var converter = new DoubleConverter();
+            var s = converter.ConvertToString(double.MinValue, null, new MemberMapData(null));
+            var d = converter.ConvertFromString(s, null, new MemberMapData(null));
+
+            Assert.Equal(double.MinValue, d);
+        }
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/EnumConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/EnumConverterTests.cs
new file mode 100644
index 0000000..b70d02c
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/EnumConverterTests.cs
@@ -0,0 +1,367 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using CsvHelper.Configuration;
+using Xunit;
+using CsvHelper.TypeConversion;
+using CsvHelper.Configuration.Attributes;
+using CsvHelper.Tests.Mocks;
+using System.Text;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class EnumConverterTests
+	{
+		[Fact]
+		public void ConstructorTest()
+		{
+			try
+			{
+				new EnumConverter(typeof(string));
+				throw new XUnitException();
+			}
+			catch (ArgumentException ex)
+			{
+				Assert.Equal("'System.String' is not an Enum.", ex.Message);
+			}
+		}
+
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new EnumConverter(typeof(TestEnum));
+			var propertyMapData = new MemberMapData(null);
+
+			Assert.Equal("None", converter.ConvertToString((TestEnum)0, null, propertyMapData));
+			Assert.Equal("None", converter.ConvertToString(TestEnum.None, null, propertyMapData));
+			Assert.Equal("One", converter.ConvertToString((TestEnum)1, null, propertyMapData));
+			Assert.Equal("One", converter.ConvertToString(TestEnum.One, null, propertyMapData));
+			Assert.Equal("", converter.ConvertToString(null, null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new EnumConverter(typeof(TestEnum));
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverterOptions = { EnumIgnoreCase = true },
+			};
+
+			var row = new CsvReader(new ParserMock());
+
+			Assert.Equal(TestEnum.One, converter.ConvertFromString("One", null, propertyMapData));
+			Assert.Equal(TestEnum.One, converter.ConvertFromString("one", null, propertyMapData));
+			Assert.Equal(TestEnum.One, converter.ConvertFromString("1", null, propertyMapData));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString("", row, propertyMapData));
+			Assert.Throws<TypeConverterException>(() => Assert.Equal(TestEnum.One, converter.ConvertFromString(null, row, propertyMapData)));
+		}
+
+		[Fact]
+		public void ConvertToString_NameAttribute_ReturnsNameFromNameAttribute()
+		{
+			var converter = new EnumConverter(typeof(NameAttributeEnum));
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var value = converter.ConvertToString(NameAttributeEnum.Foo, null, propertyMapData);
+
+			Assert.Equal("Bar", value);
+		}
+
+		[Fact]
+		public void ConvertFromString_NameAttribute_ReturnsValueFromNameAttribute()
+		{
+			var converter = new EnumConverter(typeof(NameAttributeEnum));
+			var propertyMapData = new MemberMapData(null)
+			{
+			};
+
+			var value = converter.ConvertFromString("Bar", null, propertyMapData);
+
+			Assert.Equal(NameAttributeEnum.Foo, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_Int16Enum_ReturnsEnumValue()
+		{
+			var converter = new EnumConverter(typeof(Int16Enum));
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var value = converter.ConvertFromString("1", null, propertyMapData);
+
+			Assert.Equal(Int16Enum.One, value);
+		}
+
+		[Fact]
+		public void ConvertToString_Int16Enum_ReturnsString()
+		{
+			var converter = new EnumConverter(typeof(Int16Enum));
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var value = converter.ConvertToString(Int16Enum.One, null, propertyMapData);
+
+			Assert.Equal("One", value);
+		}
+
+		[Fact]
+		public void ConvertFromString_Int16EnumWithNameAttribute_ReturnsEnumValue()
+		{
+			var converter = new EnumConverter(typeof(Int16Enum));
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var value = converter.ConvertFromString("Bar", null, propertyMapData);
+
+			Assert.Equal(Int16Enum.Foo, value);
+		}
+
+		[Fact]
+		public void ConvertToString_Int16EnumWithNameAttribute_ReturnsString()
+		{
+			var converter = new EnumConverter(typeof(Int16Enum));
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var value = converter.ConvertToString(Int16Enum.Foo, null, propertyMapData);
+
+			Assert.Equal("Bar", value);
+		}
+
+		[Fact]
+		public void ConvertFromString_DuplicateNames_IgnoreCase_ReturnsNameWithLowestValue()
+		{
+			var converter = new EnumConverter(typeof(DuplicateNames));
+
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverterOptions = { EnumIgnoreCase = true },
+			};
+
+			var value = converter.ConvertFromString("oNe", null, memberMapData);
+
+			Assert.Equal(DuplicateNames.one, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_DuplicateValues_ReturnsNameThatAppearsFirst()
+		{
+			var converter = new EnumConverter(typeof(DuplicateValues));
+
+			var memberMapData = new MemberMapData(null)
+			{
+			};
+
+			var value = converter.ConvertFromString("1", null, memberMapData);
+
+			Assert.Equal(DuplicateValues.One, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_UsingValue_DuplicateNamesAndValues_ReturnsNameThatAppearsFirst()
+		{
+			var converter = new EnumConverter(typeof(DuplicateNamesAndValues));
+
+			var memberMapData = new MemberMapData(null)
+			{
+			};
+
+			var value = converter.ConvertFromString("1", null, memberMapData);
+
+			Assert.Equal(DuplicateNamesAndValues.One, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_UsingName_DuplicateNamesAndValues_ReturnsNameThatAppearsFirst()
+		{
+			var converter = new EnumConverter(typeof(DuplicateNamesAndValues));
+
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverterOptions = { EnumIgnoreCase = true },
+			};
+
+			var value = converter.ConvertFromString("oNe", null, memberMapData);
+
+			Assert.Equal(DuplicateNamesAndValues.One, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_DuplicateAttributeNames_IgnoreCase_ReturnsNameWithLowestValue()
+		{
+			var converter = new EnumConverter(typeof(DuplicateNamesAttributeEnum));
+
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverterOptions = { EnumIgnoreCase = true },
+			};
+
+			var value = converter.ConvertFromString("oNe", null, memberMapData);
+
+			Assert.Equal(DuplicateNamesAttributeEnum.One, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_DuplicateAttributeValues_ReturnsNameThatAppearsFirst()
+		{
+			var converter = new EnumConverter(typeof(DuplicateValuesAttributeEnum));
+
+			var memberMapData = new MemberMapData(null)
+			{
+			};
+
+			var value = converter.ConvertFromString("1", null, memberMapData);
+
+			Assert.Equal(DuplicateValuesAttributeEnum.One, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_UsingValue_DuplicateAttributeNamesAndValues_ReturnsNameThatAppearsFirst()
+		{
+			var converter = new EnumConverter(typeof(DuplicateNamesAndValuesAttributeEnum));
+
+			var memberMapData = new MemberMapData(null)
+			{
+			};
+
+			var value = converter.ConvertFromString("1", null, memberMapData);
+
+			Assert.Equal(DuplicateNamesAndValuesAttributeEnum.One, value);
+		}
+
+		[Fact]
+		public void ConvertFromString_UsingName_DuplicateAttributeNamesAndValues_ReturnsNameThatAppearsFirst()
+		{
+			var converter = new EnumConverter(typeof(DuplicateNamesAndValuesAttributeEnum));
+
+			var memberMapData = new MemberMapData(null)
+			{
+				TypeConverterOptions = { EnumIgnoreCase = true },
+			};
+
+			var value = converter.ConvertFromString("oNe", null, memberMapData);
+
+			Assert.Equal(DuplicateNamesAndValuesAttributeEnum.One, value);
+		}
+
+		private class TestClass
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+			public TestEnum TestEnum { get; set; }
+		}
+
+		private class TestClassMap : ClassMap<TestClass>
+		{
+			public TestClassMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name);
+				Map(m => m.TestEnum).TypeConverterOption.EnumIgnoreCase();
+			}
+		}
+
+		private enum TestEnum
+		{
+			None = 0,
+			One = 1,
+		}
+
+		private enum NameAttributeEnum
+		{
+			None = 0,
+			[Name("Bar")]
+			Foo = 1
+		}
+
+		private enum Int16Enum : short
+		{
+			None = 0,
+			One = 1,
+			[Name("Bar")]
+			Foo = 2
+		}
+
+		private enum DuplicateNames
+		{
+			None = 0,
+			One = 2,
+			one = 1,
+			Three = 3
+		}
+
+		private enum DuplicateValues
+		{
+			None = 0,
+			One = 1,
+			Two = 1,
+			Three = 3
+		}
+
+		private enum DuplicateNamesAndValues
+		{
+			None = 0,
+			One = 1,
+			one = 1,
+			Two = 2
+		}
+
+		private enum DuplicateNamesAttributeEnum
+		{
+			None = 0,
+			[Name("Foo")]
+			One = 2,
+			[Name("foo")]
+			Two = 1,
+			Three = 3
+		}
+
+		private enum DuplicateValuesAttributeEnum
+		{
+			None = 0,
+			[Name("Foo")]
+			One = 1,
+			[Name("Bar")]
+			Two = 1,
+			Three = 3
+		}
+
+		private enum DuplicateNamesAndValuesAttributeEnum
+		{
+			None = 0,
+			[Name("Foo")]
+			One = 1,
+			[Name("foo")]
+			Two = 1,
+			Three = 3
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/EnumerableConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/EnumerableConverterTests.cs
new file mode 100644
index 0000000..3f1d4f5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/EnumerableConverterTests.cs
@@ -0,0 +1,32 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using Xunit;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using CsvHelper.Tests.Mocks;
+using System.IO;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class EnumerableConverterTests
+	{
+		[Fact]
+		public void ConvertTest()
+		{
+			var converter = new EnumerableConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var readerRow = new CsvReader(new ParserMock());
+			var writerRow = new CsvWriter(new StringWriter(), CultureInfo.InvariantCulture);
+
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString("", readerRow, propertyMapData));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertToString(5, writerRow, propertyMapData));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IDictionaryConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IDictionaryConverterTests.cs
new file mode 100644
index 0000000..75915b2
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IDictionaryConverterTests.cs
@@ -0,0 +1,303 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class IDictionaryConverterTests
+	{
+		[Fact]
+		public void FullWriteTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Dictionary = new Dictionary<string, int> { { "Prop1", 1 }, { "Prop2", 2 }, { "Prop3", 3 } } }
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal(",1,2,3,\r\n", result);
+			}
+		}
+
+		[Fact]
+		public void FullReadTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Prop1,Prop2,Prop3,Prop4,Prop5");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var dict = records[0].Dictionary;
+
+				Assert.Equal(3, dict.Count);
+				Assert.Equal("2", dict["Prop2"]);
+				Assert.Equal("3", dict["Prop3"]);
+				Assert.Equal("4", dict["Prop4"]);
+			}
+		}
+
+		[Fact]
+		public void FullReadNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// You can't read into a dictionary without a header.
+					// You need to header value to use as the key.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderIndexDifferentNamesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Before,Dictionary1,Dictionary2,Dictionary3,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].Dictionary;
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal("2", list["Dictionary1"]);
+				Assert.Equal("3", list["Dictionary2"]);
+				Assert.Equal("4", list["Dictionary3"]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderIndexSameNamesTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,Dictionary,Dictionary,Dictionary,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Can't have same name with Dictionary.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithDefaultHeaderDifferentNamesTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Before,Dictionary1,Dictionary2,Dictionary3,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestDefaultMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Indexes must be specified for dictionaries.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithDefaultHeaderSameNamesTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,Dictionary,Dictionary,Dictionary,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestDefaultMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Headers can't have the same name.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithNamedHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,Dictionary,Dictionary,Dictionary,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Header's can't have the same name.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderListItemsScattered()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,Dictionary,A,Dictionary,B,Dictionary,After");
+				writer.WriteLine("1,2,3,4,5,6,7");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Header's can't have the same name.
+				}
+			}
+		}
+
+		private class Test
+		{
+			public string Before { get; set; }
+			public IDictionary Dictionary { get; set; }
+			public string After { get; set; }
+		}
+
+		private sealed class TestIndexMap : ClassMap<Test>
+		{
+			public TestIndexMap()
+			{
+				Map(m => m.Before).Index(0);
+				Map(m => m.Dictionary).Index(1, 3);
+				Map(m => m.After).Index(4);
+			}
+		}
+
+		private sealed class TestNamedMap : ClassMap<Test>
+		{
+			public TestNamedMap()
+			{
+				Map(m => m.Before).Name("Before");
+				Map(m => m.Dictionary).Name("Dictionary");
+				Map(m => m.After).Name("After");
+			}
+		}
+
+		private sealed class TestDefaultMap : ClassMap<Test>
+		{
+			public TestDefaultMap()
+			{
+				Map(m => m.Before);
+				Map(m => m.Dictionary);
+				Map(m => m.After);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IDictionaryGenericConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IDictionaryGenericConverterTests.cs
new file mode 100644
index 0000000..b135632
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IDictionaryGenericConverterTests.cs
@@ -0,0 +1,198 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System.Reflection;
+using CsvHelper.Tests.Mocks;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class IDictionaryGenericConverterTests
+	{
+		[Fact]
+		public void FullReadNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// You can't read into a dictionary without a header.
+					// You need to header value to use as the key.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HeaderValidated = null,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("Before,Dictionary1,Dictionary2,Dictionary3,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].Dictionary;
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list["Dictionary1"]);
+				Assert.Equal(3, list["Dictionary2"]);
+				Assert.Equal(4, list["Dictionary3"]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithDefaultHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,Dictionary,Dictionary,Dictionary,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestDefaultMap>();
+
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Can't have same name with Dictionary.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithNamedHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,Dictionary,Dictionary,Dictionary,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Can't have same name with Dictionary.
+				}
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderListItemsScattered()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,Dictionary,A,Dictionary,B,Dictionary,After");
+				writer.WriteLine("1,2,3,4,5,6,7");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				try
+				{
+					var records = csv.GetRecords<Test>().ToList();
+					throw new XUnitException();
+				}
+				catch (ReaderException)
+				{
+					// Can't have same name with Dictionary.
+				}
+			}
+		}
+
+		private class Test
+		{
+			public string Before { get; set; }
+			public Dictionary<string, int?> Dictionary { get; set; }
+			public string After { get; set; }
+		}
+
+		private sealed class TestIndexMap : ClassMap<Test>
+		{
+			public TestIndexMap()
+			{
+				Map(m => m.Before).Index(0);
+				Map(m => m.Dictionary).Index(1, 3);
+				Map(m => m.After).Index(4);
+			}
+		}
+
+		private sealed class TestNamedMap : ClassMap<Test>
+		{
+			public TestNamedMap()
+			{
+				Map(m => m.Before).Name("Before");
+				Map(m => m.Dictionary).Name("Dictionary");
+				Map(m => m.After).Name("After");
+			}
+		}
+
+		private sealed class TestDefaultMap : ClassMap<Test>
+		{
+			public TestDefaultMap()
+			{
+				Map(m => m.Before);
+				Map(m => m.Dictionary);
+				Map(m => m.After);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IEnumerableConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IEnumerableConverterTests.cs
new file mode 100644
index 0000000..22a7bd5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IEnumerableConverterTests.cs
@@ -0,0 +1,261 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections;
+using System.Linq;
+using CsvHelper.Configuration;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Xunit;
+using System.Globalization;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class IEnumerableConverterTests
+	{
+		[Fact]
+		public void FullReadNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.Cast<string>().ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal("2", list[0]);
+				Assert.Equal("3", list[1]);
+				Assert.Equal("4", list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.Cast<string>().ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal("2", list[0]);
+				Assert.Equal("3", list[1]);
+				Assert.Equal("4", list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithDefaultHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestDefaultMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.Cast<string>().ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal("2", list[0]);
+				Assert.Equal("3", list[1]);
+				Assert.Equal("4", list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithNamedHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.Cast<string>().ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal("2", list[0]);
+				Assert.Equal("3", list[1]);
+				Assert.Equal("4", list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderListItemsScattered()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,A,List,B,List,After");
+				writer.WriteLine("1,2,3,4,5,6,7");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.Cast<string>().ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal("2", list[0]);
+				Assert.Equal("4", list[1]);
+				Assert.Equal("6", list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullWriteNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { List = new List<int> { 1, 2, 3 } }
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal(",1,2,3,\r\n", result);
+			}
+		}
+
+		[Fact]
+		public void FullWriteWithHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<Test>
+				{
+					new Test { List = new List<int> { 1, 2, 3 } }
+				};
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Before,List1,List2,List3,After");
+				expected.AppendLine(",1,2,3,");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void FullWriteWithHeaderAutoMapTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<Test>
+				{
+					new Test { List = new List<int> { 1, 2, 3 } }
+				};
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Before,After");
+				expected.AppendLine(",");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		private class Test
+		{
+			public string Before { get; set; }
+			public IEnumerable List { get; set; }
+			public string After { get; set; }
+		}
+
+		private sealed class TestIndexMap : ClassMap<Test>
+		{
+			public TestIndexMap()
+			{
+				Map(m => m.Before).Index(0);
+				Map(m => m.List).Index(1, 3);
+				Map(m => m.After).Index(4);
+			}
+		}
+
+		private sealed class TestNamedMap : ClassMap<Test>
+		{
+			public TestNamedMap()
+			{
+				Map(m => m.Before).Name("Before");
+				Map(m => m.List).Name("List");
+				Map(m => m.After).Name("After");
+			}
+		}
+
+		private sealed class TestDefaultMap : ClassMap<Test>
+		{
+			public TestDefaultMap()
+			{
+				Map(m => m.Before);
+				Map(m => m.List);
+				Map(m => m.After);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IEnumerableGenericConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IEnumerableGenericConverterTests.cs
new file mode 100644
index 0000000..deebb6d
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/IEnumerableGenericConverterTests.cs
@@ -0,0 +1,265 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Xunit;
+using System.Reflection;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.Configuration.Attributes;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class IEnumerableGenericConverterTests
+	{
+		[Fact]
+		public void FullReadNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithDefaultHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestDefaultMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithNamedHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,List,List,After");
+				writer.WriteLine("1,2,3,4,5");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(3, list[1]);
+				Assert.Equal(4, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullReadWithHeaderListItemsScattered()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("Before,List,A,List,B,List,After");
+				writer.WriteLine("1,2,3,4,5,6,7");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestNamedMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				var list = records[0].List.ToList();
+
+				Assert.Equal(3, list.Count);
+				Assert.Equal(2, list[0]);
+				Assert.Equal(4, list[1]);
+				Assert.Equal(6, list[2]);
+			}
+		}
+
+		[Fact]
+		public void FullWriteNoHeaderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { List = new List<int?> { 1, 2, 3 } }
+				};
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal(",1,2,3,\r\n", result);
+			}
+		}
+
+		[Fact]
+		public void FullWriteWithHeaderTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<Test>
+				{
+					new Test { List = new List<int?> { 1, 2, 3 } }
+				};
+				csv.Context.RegisterClassMap<TestIndexMap>();
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Before,List1,List2,List3,After");
+				expected.AppendLine(",1,2,3,");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void GetRecords_NullValuesAttributeWithIndex_UsesCustomNullValue()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parser = new ParserMock(config)
+			{
+				{ "NULL", "", "2" },
+			};
+			using (var csv = new CsvReader(parser))
+			{
+				var records = csv.GetRecords<NullValuesAttributeIndexTest>().ToList();
+			}
+		}
+
+		private class NullValuesAttributeIndexTest
+		{
+			[Index(0, 2)]
+			[NullValues("NULL")]
+			public List<int?> List { get; set; }
+		}
+
+		private class Test
+		{
+			public string Before { get; set; }
+			public IEnumerable<int?> List { get; set; }
+			public string After { get; set; }
+		}
+
+		private sealed class TestIndexMap : ClassMap<Test>
+		{
+			public TestIndexMap()
+			{
+				Map(m => m.Before).Index(0);
+				Map(m => m.List).Index(1, 3);
+				Map(m => m.After).Index(4);
+			}
+		}
+
+		private sealed class TestNamedMap : ClassMap<Test>
+		{
+			public TestNamedMap()
+			{
+				Map(m => m.Before).Name("Before");
+				Map(m => m.List).Name("List");
+				Map(m => m.After).Name("After");
+			}
+		}
+
+		private sealed class TestDefaultMap : ClassMap<Test>
+		{
+			public TestDefaultMap()
+			{
+				Map(m => m.Before);
+				Map(m => m.List);
+				Map(m => m.After);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/SingleConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/SingleConverterTests.cs
new file mode 100644
index 0000000..38b86ea
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/SingleConverterTests.cs
@@ -0,0 +1,39 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+    
+    public class SingleConverterTests
+    {
+        [Fact]
+        public void RoundTripMaxValueTest()
+        {
+            var converter = new SingleConverter();
+            var s = converter.ConvertToString(float.MaxValue, null, new MemberMapData(null));
+            var f = converter.ConvertFromString(s, null, new MemberMapData(null));
+
+            Assert.Equal(float.MaxValue, f);
+        }
+
+        [Fact]
+        public void RoundTripMinValueTest()
+        {
+            var converter = new SingleConverter();
+            var s = converter.ConvertToString(float.MinValue, null, new MemberMapData(null));
+            var f = converter.ConvertFromString(s, null, new MemberMapData(null));
+
+            Assert.Equal(float.MinValue, f);
+        }
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TimeOnlyConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TimeOnlyConverterTests.cs
new file mode 100644
index 0000000..7792868
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TimeOnlyConverterTests.cs
@@ -0,0 +1,59 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+#if NET6_0
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using System;
+using System.Globalization;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	public class TimeOnlyConverterTests
+    {
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new TimeOnlyConverter();
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var date = DateOnly.FromDateTime(DateTime.Now);
+
+			// Valid conversions.
+			Assert.Equal(date.ToString(), converter.ConvertToString(date, null, propertyMapData));
+
+			// Invalid conversions.
+			Assert.Equal("1", converter.ConvertToString(1, null, propertyMapData));
+			Assert.Equal("", converter.ConvertToString(null, null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new TimeOnlyConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+
+			var row = new CsvReader(new ParserMock());
+
+			var time = TimeOnly.FromDateTime(DateTime.Now);
+
+			// Valid conversions.
+			Assert.Equal(time.ToString(), converter.ConvertFromString(time.ToString(), null, propertyMapData).ToString());
+			Assert.Equal(time.ToString(), converter.ConvertFromString(time.ToString("o"), null, propertyMapData).ToString());
+			Assert.Equal(time.ToString(), converter.ConvertFromString(" " + time + " ", null, propertyMapData).ToString());
+
+			// Invalid conversions.
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+		}
+	}
+}
+#endif
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TimeSpanConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TimeSpanConverterTests.cs
new file mode 100644
index 0000000..21af674
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TimeSpanConverterTests.cs
@@ -0,0 +1,54 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Globalization;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class TimeSpanConverterTests
+	{
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new TimeSpanConverter();
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
+			};
+
+			var dateTime = DateTime.Now;
+			var timeSpan = new TimeSpan(dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond);
+
+			// Valid conversions.
+			Assert.Equal(timeSpan.ToString(), converter.ConvertToString(timeSpan, null, propertyMapData));
+
+			// Invalid conversions.
+			Assert.Equal("1", converter.ConvertToString(1, null, propertyMapData));
+			Assert.Equal("", converter.ConvertToString(null, null, propertyMapData));
+		}
+
+		[Fact]
+		public void ComponentModelCompatibilityTest()
+		{
+			var converter = new TimeSpanConverter();
+			var cmConverter = new System.ComponentModel.TimeSpanConverter();
+
+			var propertyMapData = new MemberMapData(null);
+			propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
+			var row = new CsvReader(new ParserMock());
+
+			Assert.Throws<FormatException>(() => cmConverter.ConvertFromString(""));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString("", row, propertyMapData));
+			Assert.Throws<NotSupportedException>(() => cmConverter.ConvertFromString(null));
+			Assert.Throws<TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterCacheTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterCacheTests.cs
new file mode 100644
index 0000000..499013a
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterCacheTests.cs
@@ -0,0 +1,243 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class TypeConverterCacheTests
+	{
+		[Fact]
+		public void GetConverterForUnknownTypeTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(TestUnknownClass));
+
+			Assert.IsType<DefaultTypeConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForKnownTypeTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter<TestKnownClass>();
+
+			Assert.IsType<DefaultTypeConverter>(converter);
+
+			typeConverterFactory.AddConverter<TestKnownClass>(new TestKnownConverter());
+			converter = typeConverterFactory.GetConverter<TestKnownClass>();
+
+			Assert.IsType<TestKnownConverter>(converter);
+		}
+
+		[Fact]
+		public void RemoveConverterForUnknownTypeTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			typeConverterFactory.RemoveConverter<TestUnknownClass>();
+			typeConverterFactory.RemoveConverter(typeof(TestUnknownClass));
+		}
+
+		[Fact]
+		public void GetConverterForByteTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(byte));
+
+			Assert.IsType<ByteConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForByteArrayTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(byte[]));
+
+			Assert.IsType<ByteArrayConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForCharTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(char));
+
+			Assert.IsType<CharConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForDateTimeTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(DateTime));
+
+			Assert.IsType<DateTimeConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForDecimalTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(decimal));
+
+			Assert.IsType<DecimalConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForDoubleTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(double));
+
+			Assert.IsType<DoubleConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForFloatTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(float));
+
+			Assert.IsType<SingleConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForGuidTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(Guid));
+
+			Assert.IsType<GuidConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForInt16Test()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(short));
+
+			Assert.IsType<Int16Converter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForInt32Test()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(int));
+
+			Assert.IsType<Int32Converter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForInt64Test()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(long));
+
+			Assert.IsType<Int64Converter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForNullableTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(int?));
+
+			Assert.IsType<NullableConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForSByteTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(sbyte));
+
+			Assert.IsType<SByteConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForStringTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(string));
+
+			Assert.IsType<StringConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForUInt16Test()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(ushort));
+
+			Assert.IsType<UInt16Converter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForUInt32Test()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(uint));
+
+			Assert.IsType<UInt32Converter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForUInt64Test()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(ulong));
+
+			Assert.IsType<UInt64Converter>(converter);
+		}
+
+		[Fact]
+		public void GetConverterForEnumTest()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			var converter = typeConverterFactory.GetConverter(typeof(FooEnum));
+
+			Assert.IsType<EnumConverter>(converter);
+		}
+
+		[Fact]
+		public void GetConverter_ConverterRegisteredForEnum_ReturnCustomConverterForAllEnums()
+		{
+			var typeConverterFactory = new TypeConverterCache();
+			typeConverterFactory.AddConverter<Enum>(new TestKnownConverter());
+			var fooConverter = typeConverterFactory.GetConverter(typeof(FooEnum));
+			var barConverter = typeConverterFactory.GetConverter(typeof(BarEnum));
+
+			Assert.IsType<TestKnownConverter>(fooConverter);
+			Assert.IsType<TestKnownConverter>(barConverter);
+		}
+
+		private class TestListConverter : DefaultTypeConverter
+		{
+		}
+
+		private class TestUnknownClass
+		{
+		}
+
+		private class TestKnownClass
+		{
+		}
+
+		private class TestKnownConverter : DefaultTypeConverter
+		{
+		}
+
+		private enum FooEnum
+		{
+		}
+
+		private enum BarEnum
+		{
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterOptionsFactoryTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterOptionsFactoryTests.cs
new file mode 100644
index 0000000..d0beeee
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterOptionsFactoryTests.cs
@@ -0,0 +1,211 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class TypeConverterOptionsFactoryTests
+	{
+		[Fact]
+		public void AddGetRemoveTest()
+		{
+			var customOptions = new TypeConverterOptions
+			{
+				Formats = new string[] { "custom" },
+			};
+			var typeConverterOptionsFactory = new TypeConverterOptionsCache();
+
+			typeConverterOptionsFactory.AddOptions<string>(customOptions);
+			var options = typeConverterOptionsFactory.GetOptions<string>();
+
+			Assert.Equal(customOptions.Formats, options.Formats);
+
+			typeConverterOptionsFactory.RemoveOptions<string>();
+
+			options = typeConverterOptionsFactory.GetOptions<string>();
+
+			Assert.NotEqual(customOptions.Formats, options.Formats);
+		}
+
+		[Fact]
+		public void GetFieldTest()
+		{
+			var options = new TypeConverterOptions { NumberStyles = NumberStyles.AllowThousands };
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("\"1,234\",\"5,678\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				csvReader.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvReader.Read();
+				Assert.Equal(1234, csvReader.GetField<int>(0));
+				Assert.Equal(5678, csvReader.GetField(typeof(int), 1));
+			}
+		}
+
+		[Fact]
+		public void GetRecordsTest()
+		{
+			var options = new TypeConverterOptions { NumberStyles = NumberStyles.AllowThousands };
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("\"1,234\",\"5,678\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				csvReader.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvReader.GetRecords<Test>().ToList();
+			}
+		}
+
+		[Fact]
+		public void GetRecordsAppliedWhenMappedTest()
+		{
+			var options = new TypeConverterOptions { NumberStyles = NumberStyles.AllowThousands };
+
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvReader = new CsvReader(reader, config))
+			{
+				writer.WriteLine("\"1,234\",\"$5,678\"");
+				writer.Flush();
+				stream.Position = 0;
+
+				csvReader.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvReader.Context.RegisterClassMap<TestMap>();
+				csvReader.GetRecords<Test>().ToList();
+			}
+		}
+
+		[Fact]
+		public void WriteFieldTest()
+		{
+			var options = new TypeConverterOptions { Formats = new string[] { "c" } };
+
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				csvWriter.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvWriter.WriteField(1234);
+				csvWriter.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+				var record = reader.ReadToEnd();
+
+				Assert.Equal("\"$1,234.00\"\r\n", record);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordsTest()
+		{
+			var options = new TypeConverterOptions { Formats = new string[] { "c" } };
+
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Number = 1234, NumberOverridenInMap = 5678 },
+				};
+				csvWriter.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvWriter.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+				var record = reader.ReadToEnd();
+
+				Assert.Equal("\"$1,234.00\",\"$5,678.00\"\r\n", record);
+			}
+		}
+
+		[Fact]
+		public void WriteRecordsAppliedWhenMappedTest()
+		{
+			var options = new TypeConverterOptions { Formats = new string[] { "c" } };
+
+			var config = new CsvConfiguration(new CultureInfo("en-US"))
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csvWriter = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Number = 1234, NumberOverridenInMap = 5678 },
+				};
+				csvWriter.Context.TypeConverterOptionsCache.AddOptions<int>(options);
+				csvWriter.Context.RegisterClassMap<TestMap>();
+				csvWriter.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+				var record = reader.ReadToEnd();
+
+				Assert.Equal("\"$1,234.00\",\"5,678.00\"\r\n", record);
+			}
+		}
+
+		private class Test
+		{
+			public int Number { get; set; }
+
+			public int NumberOverridenInMap { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Number);
+				Map(m => m.NumberOverridenInMap)
+					.TypeConverterOption.NumberStyles(NumberStyles.AllowThousands | NumberStyles.AllowCurrencySymbol)
+					.TypeConverterOption.Format("N2");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterOptionsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterOptionsTests.cs
new file mode 100644
index 0000000..90f8f0b
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterOptionsTests.cs
@@ -0,0 +1,110 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class TypeConverterOptionsTests
+	{
+		[Fact]
+		public void GlobalNullValueTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine(",");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add(string.Empty);
+				var records = csv.GetRecords<Test>().ToList();
+
+				Assert.Null(records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void MappingNullValueTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine(",");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				Assert.Null(records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		[Fact]
+		public void GlobalAndMappingNullValueTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var writer = new StreamWriter(stream))
+			using (var reader = new StreamReader(stream))
+			using (var csv = new CsvReader(reader, config))
+			{
+				writer.WriteLine(",");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("null");
+				csv.Context.RegisterClassMap<TestMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				Assert.Null(records[0].Id);
+				Assert.Null(records[0].Name);
+			}
+		}
+
+		private class Test
+		{
+			public int? Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).TypeConverterOption.NullValues(string.Empty);
+			}
+		}
+
+		// auto map options have defaults
+		// map options could be default or custom if set
+		// global has defaults or custom
+		// merge global with map
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterTests.cs
new file mode 100644
index 0000000..da71236
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/TypeConverterTests.cs
@@ -0,0 +1,51 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using CsvHelper.TypeConversion;
+using System.Globalization;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+	public class TypeConverterTests
+	{
+		[Fact]
+		public void ReaderInheritedConverter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			var parserMock = new ParserMock(config)
+			{
+				{ "1" },
+			};
+			var csv = new CsvReader(parserMock);
+			csv.Context.RegisterClassMap<TestMap>();
+			var list = csv.GetRecords<Test>().ToList();
+		}
+
+		private class Test
+		{
+			public int IntColumn { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.IntColumn).Index(0).TypeConverter<Converter>();
+			}
+		}
+
+		private class Converter : Int32Converter
+		{
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/UriConverterTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/UriConverterTests.cs
new file mode 100644
index 0000000..d55baed
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/TypeConversion/UriConverterTests.cs
@@ -0,0 +1,106 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.TypeConversion;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.IO;
+
+namespace CsvHelper.Tests.TypeConversion
+{
+	
+    public class UriConverterTests
+    {
+		[Fact]
+		public void ConvertToStringTest()
+		{
+			var converter = new UriConverter();
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture },
+			};
+
+			Assert.Equal("https://test.com/", converter.ConvertToString(new Uri("https://test.com"), null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringTest()
+		{
+			var converter = new UriConverter();
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture },
+			};
+
+			Assert.Equal(new Uri("https://test.com"), converter.ConvertFromString("https://test.com", null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringUriKindRelativeTest()
+		{
+			var converter = new UriConverter();
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture, UriKind = UriKind.Relative },
+			};
+
+			Assert.Equal(new Uri("/a/b/c", UriKind.Relative), converter.ConvertFromString("/a/b/c", null, propertyMapData));
+		}
+
+		[Fact]
+		public void ConvertFromStringUriKindAbsoluteTest()
+		{
+			var converter = new UriConverter();
+
+			var propertyMapData = new MemberMapData(null)
+			{
+				TypeConverter = converter,
+				TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture, UriKind = UriKind.Absolute },
+			};
+
+			Assert.Equal(new Uri("https://test.com"), converter.ConvertFromString("https://test.com", null, propertyMapData));
+		}
+
+		[Fact]
+		public void TypeConverterCacheTest()
+		{
+			var cache = new TypeConverterCache();
+			var converter = cache.GetConverter<Uri>();
+
+			Assert.IsType<UriConverter>(converter);
+		}
+
+		[Fact]
+		public void AnonymousTypeTest()
+		{
+			var sw = new StringWriter();
+			var entries = new[]
+			{
+				new { Uri = new Uri("http://host/path") }
+			};
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Delimiter = ";",
+			};
+			using (var cw = new CsvWriter(sw, config))
+			{
+				cw.WriteRecords(entries);
+			}
+
+			Assert.Equal("Uri\r\nhttp://host/path\r\n", sw.ToString());
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/AnonymousTypesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/AnonymousTypesTests.cs
new file mode 100644
index 0000000..8ad8682
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/AnonymousTypesTests.cs
@@ -0,0 +1,34 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections;
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests.Writing
+{
+
+	public class AnonymousTypesTests
+	{
+		[Fact]
+		public void AnonymousIEnumerableTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				IEnumerable records = new ArrayList
+				{
+					new
+					{
+						Id = 1,
+						Name = "one",
+					}
+				};
+
+				csv.WriteRecords(records);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/ConstantTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/ConstantTests.cs
new file mode 100644
index 0000000..6bf29e4
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/ConstantTests.cs
@@ -0,0 +1,126 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class ConstantTests
+	{
+		[Fact]
+		public void StringConstantTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var records = new List<Test>
+				{
+					new Test { Id = 1, Name = "one" },
+					new Test { Id = 2, Name = "two" }
+				};
+
+				csv.Context.RegisterClassMap<TestStringMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,constant");
+				expected.AppendLine("2,constant");
+
+				var result = reader.ReadToEnd();
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void NullConstantTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<Test>
+				{
+					new Test { Id = 1, Name = "one" },
+				};
+
+				csv.Context.RegisterClassMap<TestNullMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+
+				Assert.Equal("1,\r\n", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void IntConstantTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var records = new List<Test>
+				{
+					new Test { Id = 1, Name = "one" },
+				};
+
+				csv.Context.RegisterClassMap<TestIntMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+
+				Assert.Equal("-1,one\r\n", writer.ToString());
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		private sealed class TestIntMap : ClassMap<Test>
+		{
+			public TestIntMap()
+			{
+				Map(m => m.Id).Constant(-1);
+				Map(m => m.Name);
+			}
+		}
+
+		private sealed class TestNullMap : ClassMap<Test>
+		{
+			public TestNullMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Constant(null);
+			}
+		}
+
+		private sealed class TestStringMap : ClassMap<Test>
+		{
+			public TestStringMap()
+			{
+				Map(m => m.Id);
+				Map(m => m.Name).Constant("constant");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/CsvModeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/CsvModeTests.cs
new file mode 100644
index 0000000..65e5e49
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/CsvModeTests.cs
@@ -0,0 +1,145 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+    public class CsvModeTests
+    {
+		[Fact]
+		public void WriteField_EscapeMode_ContainsQuote_EscapesWithoutQuotingField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("a\"b", true);
+				csv.Flush();
+
+				Assert.Equal("a\\\"b", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoEscapeMode_ContainsQuote_EscapesWithoutQuotingField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.NoEscape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("a\"b", true);
+				csv.Flush();
+
+				Assert.Equal("a\"b", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_EscapeMode_ContainsDelimiter_EscapesWithoutQuotingField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("a,b", true);
+				csv.Flush();
+
+				Assert.Equal("a\\,b", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoEscapeMode_ContainsDelimiter_EscapesWithoutQuotingField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.NoEscape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("a,b", true);
+				csv.Flush();
+
+				Assert.Equal("a,b", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_EscapeMode_ContainsNewline_EscapesWithoutQuotingField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+				NewLine = "\n",
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("a\nb", true);
+				csv.Flush();
+
+				Assert.Equal("a\\\nb", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_EscapeMode_Contains2CharNewline_EscapesWithoutQuotingField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.Escape,
+				Escape = '\\',
+				NewLine = "\r\n",
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("a\r\nb", true);
+				csv.Flush();
+
+				Assert.Equal("a\\\r\\\nb", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoEscapeMode_ContainsNewline_EscapesWithoutQuotingField()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				Mode = CsvMode.NoEscape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("a\r\nb", true);
+				csv.Flush();
+
+				Assert.Equal("a\r\nb", writer.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/DynamicTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/DynamicTests.cs
new file mode 100644
index 0000000..1cf33dc
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/DynamicTests.cs
@@ -0,0 +1,218 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class DynamicTests
+	{
+		[Fact]
+		public void WriteDynamicExpandoObjectsTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<dynamic>();
+
+				dynamic obj = new ExpandoObject();
+				obj.Id = 1;
+				obj.Name = "one";
+				list.Add(obj);
+
+				obj = new ExpandoObject();
+				obj.Id = 2;
+				obj.Name = "two";
+				list.Add(obj);
+
+				csv.WriteRecords(list);
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = "Id,Name\r\n";
+				expected += "1,one\r\n";
+				expected += "2,two\r\n";
+
+				Assert.Equal(expected, reader.ReadToEnd());
+			}
+		}
+
+		[Fact]
+		public void WriteDynamicExpandoObjectTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				dynamic obj = new ExpandoObject();
+				obj.Id = 1;
+				obj.Name = "one";
+
+				csv.WriteDynamicHeader(obj);
+				csv.NextRecord();
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				obj = new ExpandoObject();
+				obj.Id = 2;
+				obj.Name = "two";
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = "Id,Name\r\n";
+				expected += "1,one\r\n";
+				expected += "2,two\r\n";
+
+				Assert.Equal(expected, reader.ReadToEnd());
+			}
+		}
+
+		[Fact]
+		public void WriteDynamicExpandoObjectHasDifferentPropertyOrderingTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				dynamic obj = new ExpandoObject();
+				obj.Name = "one";
+				obj.Id = 1;
+
+				csv.WriteDynamicHeader(obj);
+				csv.NextRecord();
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				obj = new ExpandoObject();
+				obj.Name = "two";
+				obj.Id = 2;
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				var expected = "Name,Id\r\n";
+				expected += "one,1\r\n";
+				expected += "two,2\r\n";
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteDynamicIDynamicMetaObjectProviderHasDifferentPropertyOrderingTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				dynamic obj = new DynamicObjectMock();
+				obj.Name = "one";
+				obj.Id = 1;
+
+				csv.WriteDynamicHeader(obj);
+				csv.NextRecord();
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				obj = new ExpandoObject();
+				obj.Name = "two";
+				obj.Id = 2;
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				var expected = "Name,Id\r\n";
+				expected += "one,1\r\n";
+				expected += "two,2\r\n";
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteDynamicExpandoObjectHasDifferentPropertyOrderingWithDynamicSortTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DynamicPropertySort = Comparer<string>.Create((x, y) => x.CompareTo(y)),
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				dynamic obj = new ExpandoObject();
+				obj.Name = "one";
+				obj.Id = 1;
+
+				csv.WriteDynamicHeader(obj);
+				csv.NextRecord();
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				obj = new ExpandoObject();
+				obj.Id = 2;
+				obj.Name = "two";
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				var expected = "Id,Name\r\n";
+				expected += "1,one\r\n";
+				expected += "2,two\r\n";
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteDynamicIDynamicMetaObjectProviderHasDifferentPropertyOrderingWithDynamicSortTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				DynamicPropertySort = Comparer<string>.Create((x, y) => x.CompareTo(y)),
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				dynamic obj = new DynamicObjectMock();
+				obj.Name = "one";
+				obj.Id = 1;
+
+				csv.WriteDynamicHeader(obj);
+				csv.NextRecord();
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				obj = new ExpandoObject();
+				obj.Id = 2;
+				obj.Name = "two";
+
+				csv.WriteRecord(obj);
+				csv.NextRecord();
+
+				var expected = "Id,Name\r\n";
+				expected += "1,one\r\n";
+				expected += "2,two\r\n";
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/FieldTypeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/FieldTypeTests.cs
new file mode 100644
index 0000000..507bd44
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/FieldTypeTests.cs
@@ -0,0 +1,87 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+    public class FieldTypeTests
+    {
+		[Fact]
+        public void WriteField_ShouldQuote_HasCorrectFieldType()
+		{
+			Type type = null;
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = args =>
+				{
+					type = args.FieldType;
+					return ConfigurationFunctions.ShouldQuote(args);
+				},
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField(string.Empty);
+				Assert.Equal(typeof(string), type);
+
+				csv.WriteField(1);
+				Assert.Equal(typeof(int), type);
+
+				csv.WriteField(string.Empty);
+				Assert.Equal(typeof(string), type);
+			}
+		}
+
+		[Fact]
+		public void WriteRecords_ShouldQuote_HasCorrectFieldType()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one" },
+			};
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = args =>
+				{
+					if (args.Row.Row > 1)
+					{
+						switch (args.Row.Index)
+						{
+							case 0:
+								Assert.Equal(typeof(int), args.FieldType);
+								break;
+							case 1:
+								Assert.Equal(typeof(string), args.FieldType);
+								break;
+						}
+					}
+
+					return ConfigurationFunctions.ShouldQuote(args);
+				},
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(records);
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/IAsyncEnumerableTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/IAsyncEnumerableTests.cs
new file mode 100644
index 0000000..dc5fd61
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/IAsyncEnumerableTests.cs
@@ -0,0 +1,50 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+#if !NET45
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CsvHelper.Tests.Writing
+{
+    public class IAsyncEnumerableTests
+    {
+		[Fact]
+        public async Task Test()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one" },
+				new Foo { Id = 2, Name = "two" },
+			}.ToAsyncEnumerable();
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				await csv.WriteRecordsAsync(records);
+
+				var expected = new StringBuilder();
+				expected.Append("Id,Name\r\n");
+				expected.Append("1,one\r\n");
+				expected.Append("2,two\r\n");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+    }
+}
+#endif
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/IgnoreTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/IgnoreTests.cs
new file mode 100644
index 0000000..3fbe5e7
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/IgnoreTests.cs
@@ -0,0 +1,51 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+    public class IgnoreTests
+    {
+		[Fact]
+        public void WritingWithAllPropertiesIgnoredTest()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1 },
+			};
+
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<FooMap>();
+				csv.WriteRecords(records);
+
+				Assert.Equal("\r\n\r\n", writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+		}
+
+		private class FooMap : ClassMap<Foo>
+		{
+			public FooMap()
+			{
+				Map(m => m.Id).Ignore();
+			}
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/InterfaceTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/InterfaceTests.cs
new file mode 100644
index 0000000..b3f2cad
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/InterfaceTests.cs
@@ -0,0 +1,90 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class InterfaceTests
+	{
+		[Fact]
+		public void WriteRecordsGenericTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var records = new List<IRecord>();
+				IRecord record = new Record { A = 1, B = 2 };
+				records.Add(record);
+				record = new Record { A = 3, B = 4 };
+				records.Add(record);
+
+				csv.Context.RegisterClassMap<RecordMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = "RenameA\r\n1\r\n3\r\n";
+				Assert.Equal(expected, reader.ReadToEnd());
+			}
+		}
+
+		[Fact]
+		public void WriteRecordTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.Context.RegisterClassMap<RecordMap>();
+
+				csv.WriteHeader<IRecord>();
+				csv.NextRecord();
+
+				IRecord record = new Record { A = 1, B = 2 };
+				csv.WriteRecord(record);
+				csv.NextRecord();
+
+				record = new Record { A = 3, B = 4 };
+				csv.WriteRecord(record);
+				csv.NextRecord();
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = "RenameA\r\n1\r\n3\r\n";
+				Assert.Equal(expected, reader.ReadToEnd());
+			}
+		}
+
+		private interface IRecord
+		{
+			int A { get; set; }
+			int B { get; set; }
+		}
+
+		private class Record : IRecord
+		{
+			public int A { get; set; }
+			public int B { get; set; }
+		}
+
+		private sealed class RecordMap : ClassMap<IRecord>
+		{
+			public RecordMap()
+			{
+				Map(m => m.A).Name("RenameA");
+			}
+		}
+
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/MultipleFieldsFromOnePropertyTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/MultipleFieldsFromOnePropertyTests.cs
new file mode 100644
index 0000000..f33508b
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/MultipleFieldsFromOnePropertyTests.cs
@@ -0,0 +1,79 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class MultipleFieldsFromOnePropertyTests
+	{
+		[Fact]
+		public void WriteMultipleFieldsFromSinglePropertyTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, new CultureInfo("en-US")))
+			{
+				var records = new List<Test>
+				{
+					new Test { Dob = DateTime.Parse("9/6/2017", new CultureInfo("en-US")) }
+				};
+				csv.Context.RegisterClassMap<TestMap>();
+				csv.WriteRecords(records);
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("A,B,C");
+				expected.AppendLine("9/6/2017 12:00:00 AM,9/6/2017 12:00:00 AM,9/6/2017 12:00:00 AM");
+
+				Assert.Equal(expected.ToString(), reader.ReadToEnd());
+			}
+		}
+
+		[Fact]
+		public void ReadingWhenMultipleMapsForAPropertyAreSpecifiedUsesTheLastMapTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
+			{
+				writer.WriteLine("A,B,C");
+				writer.WriteLine("9/6/2017 12:00:00 AM,9/7/2017 12:00:00 AM,9/8/2017 12:00:00 AM");
+				writer.Flush();
+				stream.Position = 0;
+
+				csv.Context.RegisterClassMap<TestMap>();
+				var records = csv.GetRecords<Test>().ToList();
+
+				Assert.Equal(DateTime.Parse("9/8/2017", CultureInfo.InvariantCulture), records[0].Dob);
+			}
+		}
+
+		private class Test
+		{
+			public DateTime Dob { get; set; }
+		}
+
+		private sealed class TestMap : ClassMap<Test>
+		{
+			public TestMap()
+			{
+				Map(m => m.Dob, false).Name("A");
+				Map(m => m.Dob, false).Name("B");
+				Map(m => m.Dob, false).Name("C");
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/MultipleHeadersTest.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/MultipleHeadersTest.cs
new file mode 100644
index 0000000..086bb86
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/MultipleHeadersTest.cs
@@ -0,0 +1,84 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using Xunit;
+using System.Dynamic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class MultipleHeadersTest
+	{
+		[Fact]
+		public void GenericTypeTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteHeader<A>();
+				csv.NextRecord();
+				csv.WriteRecord(new A { Id = 1 });
+				csv.NextRecord();
+
+				csv.WriteHeader<B>();
+				csv.NextRecord();
+				csv.WriteRecord(new B { Name = "one" });
+				csv.NextRecord();
+				writer.Flush();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id");
+				expected.AppendLine("1");
+				expected.AppendLine("Name");
+				expected.AppendLine("one");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void DynamicTypeTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				dynamic a = new ExpandoObject();
+				a.Id = 1;
+				csv.WriteDynamicHeader(a);
+				csv.NextRecord();
+				csv.WriteRecord(a);
+				csv.NextRecord();
+
+				dynamic b = new ExpandoObject();
+				b.Name = "one";
+				csv.WriteDynamicHeader(b);
+				csv.NextRecord();
+				csv.WriteRecord(b);
+				csv.NextRecord();
+				writer.Flush();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id");
+				expected.AppendLine("1");
+				expected.AppendLine("Name");
+				expected.AppendLine("one");
+
+				Assert.Equal(expected.ToString(), writer.ToString());
+			}
+		}
+
+		private class A
+		{
+			public int Id { get; set; }
+		}
+
+		private class B
+		{
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/NewLineTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/NewLineTests.cs
new file mode 100644
index 0000000..34e1e0b
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/NewLineTests.cs
@@ -0,0 +1,92 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using CsvHelper.Tests.Mocks;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+    public class NewLineTests
+    {
+		[Fact]
+		public void CRLFTest()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one" },
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(records);
+
+				Assert.Equal("1,one\r\n", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void CRTest()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one" },
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+				NewLine = "\r",
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(records);
+
+				Assert.Equal("1,one\r", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void LFTest()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one" },
+			};
+
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+				NewLine = "\n",
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(records);
+
+				Assert.Equal("1,one\n", writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/NoPropertyMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/NoPropertyMappingTests.cs
new file mode 100644
index 0000000..e284836
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/NoPropertyMappingTests.cs
@@ -0,0 +1,218 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using CsvHelper.Configuration;
+using Xunit;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class NoPropertyMappingTests
+	{
+		[Fact]
+		public void NoPropertyWithHeaderAndNameTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<Test>
+				{
+					new Test { Id = 1 },
+					new Test { Id = 2 }
+				};
+
+				csv.Context.RegisterClassMap<TestWithNameMap>();
+				csv.WriteRecords(list);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,Constant,Name");
+				expected.AppendLine("1,const,");
+				expected.AppendLine("2,const,");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void NoPropertyWithHeaderAndNoNameTest()
+		{
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				var list = new List<Test>
+				{
+					new Test { Id = 1 },
+					new Test { Id = 2 }
+				};
+
+				csv.Context.RegisterClassMap<TestWithNoNameMap>();
+				csv.WriteRecords(list);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("Id,");
+				expected.AppendLine("1,const");
+				expected.AppendLine("2,const");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void NoPropertyWithNoHeaderAndNameTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Id = 1 },
+					new Test { Id = 2 }
+				};
+
+				csv.Context.RegisterClassMap<TestWithNameMap>();
+				csv.WriteRecords(list);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("1,const,");
+				expected.AppendLine("2,const,");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void NoPropertyWithNoHeaderAndNoNameTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Id = 1 },
+					new Test { Id = 2 }
+				};
+
+				csv.Context.RegisterClassMap<TestWithNoNameMap>();
+				csv.WriteRecords(list);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("1,const");
+				expected.AppendLine("2,const");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		[Fact]
+		public void OutOfOrderTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var list = new List<Test>
+				{
+					new Test { Id = 1, Name = "one" },
+					new Test { Id = 2, Name = "two" }
+				};
+
+				csv.Context.RegisterClassMap<TestMapOutOfOrderWithEmptyFieldsMap>();
+				csv.WriteRecords(list);
+
+				writer.Flush();
+				stream.Position = 0;
+
+				var result = reader.ReadToEnd();
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("one,,,1");
+				expected.AppendLine("two,,,2");
+
+				Assert.Equal(expected.ToString(), result);
+			}
+		}
+
+		private class Test
+		{
+			public int Id { get; set; }
+
+			public string Name { get; set; }
+		}
+
+		private sealed class TestWithNameMap : ClassMap<Test>
+		{
+			public TestWithNameMap()
+			{
+				Map(m => m.Id);
+				Map().Name("Constant").Constant("const");
+				Map(m => m.Name);
+			}
+		}
+
+		private sealed class TestWithNoNameMap : ClassMap<Test>
+		{
+			public TestWithNoNameMap()
+			{
+				Map(m => m.Id);
+				Map().Constant("const");
+			}
+		}
+
+		private sealed class TestMapOutOfOrderWithEmptyFieldsMap : ClassMap<Test>
+		{
+			public TestMapOutOfOrderWithEmptyFieldsMap()
+			{
+				Map(m => m.Name).Index(0);
+				Map().Index(1).Constant(null);
+				Map().Index(2).Constant(string.Empty);
+				Map(m => m.Id).Index(3);
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/SanitizationTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/SanitizationTests.cs
new file mode 100644
index 0000000..1442cd5
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/SanitizationTests.cs
@@ -0,0 +1,422 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace CsvHelper.Tests.Serializing
+{
+	
+	public class SanitizationTests
+	{
+		[Fact]
+		public void WriteField_NoQuotes_OptionsNone_DoesNotSanitize()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.None,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{ch}foo", false);
+				}
+
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{ch}foo"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_OptionsNone_DoesNotSanitize()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.None,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}{ch}foo{config.Quote}", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}{ch}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_OptionsException_ThrowsException()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Exception,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					Assert.Throws<WriterException>(() => csv.WriteField($"{ch}foo", false));
+				}
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_OptionsException_ThrowsException()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Exception,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					Assert.Throws<WriterException>(() => csv.WriteField($"{config.Quote}{ch}foo{config.Quote}", false));
+				}
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_OptionsException_CharIsNotFirst_DoesNotThrowException()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Exception,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"a{ch}foo", false);
+				}
+
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"a{ch}foo"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_OptionsException_CharIsNotFirst_DoesNotThrowException()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Exception,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}a{ch}foo{config.Quote}", false);
+				}
+
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}a{ch}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_OptionsStrip_StripsCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{ch}foo", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"foo"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_OptionsStrip_CharIsNotFirst_DoesNotStripCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"a{ch}foo", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"a{ch}foo"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_MultipleChars_OptionsStrip_StripsCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{ch}{ch}{ch}foo", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"foo"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_MultipleChars_OptionsStrip_CharIsNotFirst_DoesNotStripCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"a{ch}{ch}{ch}foo", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"a{ch}{ch}{ch}foo"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_OptionsStrip_StripsCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}{ch}foo{config.Quote}", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_OptionsStrip_CharIsNotFirst_DoesNotStripCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}a{ch}foo{config.Quote}", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}a{ch}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_MultipleChars_OptionsStrip_StripsCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}{ch}{ch}{ch}foo{config.Quote}", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_MultipleChars_OptionsStripCharIsNotFirst_DoesNotStripCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Strip,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}a{ch}{ch}{ch}foo{config.Quote}", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}a{ch}{ch}{ch}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_OptionsEscape_QuotesFieldAndEscapes()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Escape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{ch}foo", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}{config.InjectionEscapeCharacter}{ch}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_NoQuotes_OptionsEscape_CharIsNotFirst_DoesNotQuoteFieldAndEscape()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Escape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"a{ch}foo", false);
+				}
+
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"a{ch}foo"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_OptionsEscape_EscapesInsideQuotes()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Escape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}{ch}foo{config.Quote}", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}{config.InjectionEscapeCharacter}{ch}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_Quotes_OptionsEscape_CharIsNotFirst_DoesNotEscapeInsideQuotes()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				InjectionOptions = InjectionOptions.Escape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				foreach (var ch in config.InjectionCharacters)
+				{
+					csv.WriteField($"{config.Quote}a{ch}foo{config.Quote}", false);
+				}
+				csv.Flush();
+				writer.Flush();
+
+				var expected = string.Join(config.Delimiter, config.InjectionCharacters.Select(ch => $"{config.Quote}a{ch}foo{config.Quote}"));
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/ShouldQuoteTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/ShouldQuoteTests.cs
new file mode 100644
index 0000000..a97d2c6
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/ShouldQuoteTests.cs
@@ -0,0 +1,187 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class ShouldQuoteTests
+	{    
+		[Fact]
+		public void QuoteAllFieldsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = _ => true,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("one");
+				csv.Flush();
+
+				Assert.Equal("\"one\"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void QuoteNoFieldsTest()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = _ => false,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("o\"e");
+				csv.Flush();
+
+				Assert.Equal("o\"e", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void ContainsQuoteTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField($"o{csv.Configuration.Quote}e");
+				csv.Flush();
+
+				Assert.Equal($"\"o{csv.Configuration.Quote}{csv.Configuration.Quote}e\"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void StartsWithSpaceTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField(" one");
+				csv.Flush();
+
+				Assert.Equal("\" one\"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void EndsWithSpaceTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField("one ");
+				csv.Flush();
+
+				Assert.Equal("\"one \"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void ContainsCrTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField("o\re");
+				csv.Flush();
+
+				Assert.Equal("\"o\re\"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void ContainsLfTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField("o\ne");
+				csv.Flush();
+
+				Assert.Equal("\"o\ne\"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void ContainsCrLfTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField("o\r\ne");
+				csv.Flush();
+
+				Assert.Equal("\"o\r\ne\"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void ContainsDelimiterTest()
+		{
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
+			{
+				csv.WriteField($"o{csv.Configuration.Delimiter}e");
+				csv.Flush();
+
+				Assert.Equal($"\"o{csv.Configuration.Delimiter}e\"", writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void Test1()
+		{
+			var data = new List<(int row, int column, string field)>();
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				ShouldQuote = args =>
+				{
+					data.Add((args.Row.Row, args.Row.Index, args.Field));
+
+					return ConfigurationFunctions.ShouldQuote(args);
+				},
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("Id");
+				csv.WriteField("Name");
+				csv.NextRecord();
+
+				csv.WriteField("1");
+				csv.WriteField("one");
+				csv.NextRecord();
+
+				csv.Flush();
+			}
+
+			Assert.Equal(4, data.Count);
+
+			Assert.Equal(1, data[0].row);
+			Assert.Equal(0, data[0].column);
+			Assert.Equal("Id", data[0].field);
+
+			Assert.Equal(1, data[1].row);
+			Assert.Equal(1, data[1].column);
+			Assert.Equal("Name", data[1].field);
+
+			Assert.Equal(2, data[2].row);
+			Assert.Equal(0, data[2].column);
+			Assert.Equal("1", data[2].field);
+
+			Assert.Equal(2, data[3].row);
+			Assert.Equal(1, data[3].column);
+			Assert.Equal("one", data[3].field);
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/TrimTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/TrimTests.cs
new file mode 100644
index 0000000..836f7df
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/TrimTests.cs
@@ -0,0 +1,41 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+	public class TrimTests
+	{
+		[Fact]
+		public void Test()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				TrimOptions = TrimOptions.Trim,
+			};
+			using (var stream = new MemoryStream())
+			using (var reader = new StreamReader(stream))
+			using (var writer = new StreamWriter(stream))
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteField("  a b c  ");
+				csv.WriteField("  d e f  ");
+				csv.NextRecord();
+				writer.Flush();
+				stream.Position = 0;
+
+				var expected = new TestStringBuilder(csv.Configuration.NewLine);
+				expected.AppendLine("a b c,d e f");
+
+				Assert.Equal(expected.ToString(), reader.ReadToEnd());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteBufferTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteBufferTests.cs
new file mode 100644
index 0000000..4e73fab
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteBufferTests.cs
@@ -0,0 +1,36 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using CsvHelper.Configuration;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests.Writing
+{
+	
+    public class WriteBufferTests
+    {
+		[Fact]
+        public void Write_FieldThatIsLargerThenTwiceTheBuffer_Writes()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				BufferSize = 16
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				var random = new Random();
+				csv.WriteField("one");
+				csv.WriteField(new string(Enumerable.Range(0, 1000).Select(i => (char)random.Next((int)'a', (int)'z' + 1)).ToArray()));
+			}
+		}
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteCustomEscapeTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteCustomEscapeTests.cs
new file mode 100644
index 0000000..f45da08
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteCustomEscapeTests.cs
@@ -0,0 +1,63 @@
+using CsvHelper.Configuration;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+using Xunit;
+
+namespace CsvHelper.Tests.Writing
+{
+	public class WriteCustomEscapeTests
+	{
+		[Fact]
+		public void WriteField_CustomEscapeChar_ModeRFC4180_EscapesQuotesAndEscapeCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+				Escape = '\\',
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				// {"json":"{\"name\":\"foo\"}"}
+				// json string -> csv field
+				// "{\"json\":\"{\\\"name\\\":\\\"foo\\\"}\"}"
+				csv.WriteField(@"{""json"":""{\""name\"":\""foo\""}""}");
+				csv.Flush();
+
+				var expected = @"""{\""json\"":\""{\\\""name\\\"":\\\""foo\\\""}\""}""";
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteField_CustomEscapeChar_ModeEscape_EscapesQuotesAndEscapeCharacter()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture)
+			{
+				HasHeaderRecord = false,
+				Escape = '\\',
+				Mode = CsvMode.Escape,
+			};
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				// {"json":"{\"name\":\"foo\"}"}
+				// json string -> csv field
+				// {\"json\":\"{\\\"name\\\":\\\"foo\\\"}\"}
+				csv.WriteField(@"{""json"":""{\""name\"":\""foo\""}""}");
+				csv.Flush();
+
+				var expected = @"{\""json\"":\""{\\\""name\\\"":\\\""foo\\\""}\""}";
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteNullTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteNullTests.cs
new file mode 100644
index 0000000..7d7f23f
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Writing/WriteNullTests.cs
@@ -0,0 +1,84 @@
+using CsvHelper.Configuration;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Xunit;
+
+namespace CsvHelper.Tests.Writing
+{
+	public class WriteNullTests
+	{
+		[Fact]
+		public void WriteRecordsEnumerableGeneric_RecordIsNull_WritesEmptyRecord()
+		{
+			var records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one"},
+				null,
+				new Foo { Id = 2, Name = "two" },
+			};
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(records);
+				csv.Flush();
+
+				var expected = new TestStringBuilder(config.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,one");
+				expected.AppendLine(",");
+				expected.AppendLine("2,two");
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteRecordsEnumerable_RecordIsNull_WritesEmptyRecord()
+		{
+			IEnumerable records = new List<Foo>
+			{
+				new Foo { Id = 1, Name = "one"},
+				null,
+				new Foo { Id = 2, Name = "two" },
+			};
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecords(records);
+				csv.Flush();
+
+				var expected = new TestStringBuilder(config.NewLine);
+				expected.AppendLine("Id,Name");
+				expected.AppendLine("1,one");
+				expected.AppendLine("");
+				expected.AppendLine("2,two");
+
+				Assert.Equal(expected, writer.ToString());
+			}
+		}
+
+		[Fact]
+		public void WriteRecord_RecordIsNull_WritesEmptyRecord()
+		{
+			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
+			using (var writer = new StringWriter())
+			using (var csv = new CsvWriter(writer, config))
+			{
+				csv.WriteRecord((Foo)null);
+				csv.Flush();
+
+				Assert.Equal(",", writer.ToString());
+			}
+		}
+
+		private class Foo
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+	}
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/XunitException.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/XunitException.cs
new file mode 100644
index 0000000..d209d41
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/XunitException.cs
@@ -0,0 +1,19 @@
+// Copyright 2009-2022 Josh Close
+// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
+// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
+// https://github.com/JoshClose/CsvHelper
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CsvHelper.Tests
+{
+	public class XUnitException : Exception
+	{
+		public XUnitException() : base() { }
+
+		public XUnitException(string message) : base(message) { }
+    }
+}
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/xunit.runner.json b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/xunit.runner.json
new file mode 100644
index 0000000..d4e998c
--- /dev/null
+++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/xunit.runner.json
@@ -0,0 +1,4 @@
+{
+	"$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+	"parallelizeTestCollections": false
+}
\ No newline at end of file