using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Bson;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Linq.JsonPath;
using Newtonsoft.Json.Schema;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Schema, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Dynamic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100cbd8d53b9d7de30f1f1278f636ec462cf9c254991291e66ebb157a885638a517887633b898ccbcf0d5c5ff7be85a6abe9e765d0ac7cd33c68dac67e7e64530e8222101109f154ab14a941c490ac155cd1d4fcba0fabb49016b4ef28593b015cab5937da31172f03f67d09edda404b88a60023f062ae71d0b2e4438b74cc11dc9")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9ca358aa-317b-4925-8ada-4a29e943a363")]
[assembly: CLSCompliant(true)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Newtonsoft")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © James Newton-King 2008")]
[assembly: AssemblyDescription("Json.NET is a popular high-performance JSON framework for .NET")]
[assembly: AssemblyFileVersion("13.0.3.27908")]
[assembly: AssemblyInformationalVersion("13.0.3+0a2e291c0d9c0c7675d445703e51750363a549ef")]
[assembly: AssemblyProduct("Json.NET")]
[assembly: AssemblyTitle("Json.NET .NET Standard 2.0")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/JamesNK/Newtonsoft.Json")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("13.0.0.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class IsReadOnlyAttribute : Attribute
{
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true)]
internal sealed class NotNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
internal sealed class NotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public NotNullWhenAttribute(bool returnValue)
{
ReturnValue = returnValue;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
internal sealed class MaybeNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
internal sealed class AllowNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
internal class DoesNotReturnIfAttribute : Attribute
{
public bool ParameterValue { get; }
public DoesNotReturnIfAttribute(bool parameterValue)
{
ParameterValue = parameterValue;
}
}
}
namespace Newtonsoft.Json
{
public enum ConstructorHandling
{
Default,
AllowNonPublicDefaultConstructor
}
public enum DateFormatHandling
{
IsoDateFormat,
MicrosoftDateFormat
}
public enum DateParseHandling
{
None,
DateTime,
DateTimeOffset
}
public enum DateTimeZoneHandling
{
Local,
Utc,
Unspecified,
RoundtripKind
}
public class DefaultJsonNameTable : JsonNameTable
{
private class Entry
{
internal readonly string Value;
internal readonly int HashCode;
internal Entry Next;
internal Entry(string value, int hashCode, Entry next)
{
Value = value;
HashCode = hashCode;
Next = next;
}
}
private static readonly int HashCodeRandomizer;
private int _count;
private Entry[] _entries;
private int _mask = 31;
static DefaultJsonNameTable()
{
HashCodeRandomizer = Environment.TickCount;
}
public DefaultJsonNameTable()
{
_entries = new Entry[_mask + 1];
}
public override string? Get(char[] key, int start, int length)
{
if (length == 0)
{
return string.Empty;
}
int num = length + HashCodeRandomizer;
num += (num << 7) ^ key[start];
int num2 = start + length;
for (int i = start + 1; i < num2; i++)
{
num += (num << 7) ^ key[i];
}
num -= num >> 17;
num -= num >> 11;
num -= num >> 5;
int num3 = Volatile.Read(ref _mask);
int num4 = num & num3;
for (Entry entry = _entries[num4]; entry != null; entry = entry.Next)
{
if (entry.HashCode == num && TextEquals(entry.Value, key, start, length))
{
return entry.Value;
}
}
return null;
}
public string Add(string key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
int length = key.Length;
if (length == 0)
{
return string.Empty;
}
int num = length + HashCodeRandomizer;
for (int i = 0; i < key.Length; i++)
{
num += (num << 7) ^ key[i];
}
num -= num >> 17;
num -= num >> 11;
num -= num >> 5;
for (Entry entry = _entries[num & _mask]; entry != null; entry = entry.Next)
{
if (entry.HashCode == num && entry.Value.Equals(key, StringComparison.Ordinal))
{
return entry.Value;
}
}
return AddEntry(key, num);
}
private string AddEntry(string str, int hashCode)
{
int num = hashCode & _mask;
Entry entry = new Entry(str, hashCode, _entries[num]);
_entries[num] = entry;
if (_count++ == _mask)
{
Grow();
}
return entry.Value;
}
private void Grow()
{
Entry[] entries = _entries;
int num = _mask * 2 + 1;
Entry[] array = new Entry[num + 1];
for (int i = 0; i < entries.Length; i++)
{
Entry entry = entries[i];
while (entry != null)
{
int num2 = entry.HashCode & num;
Entry next = entry.Next;
entry.Next = array[num2];
array[num2] = entry;
entry = next;
}
}
_entries = array;
Volatile.Write(ref _mask, num);
}
private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length)
{
if (str1.Length != str2Length)
{
return false;
}
for (int i = 0; i < str1.Length; i++)
{
if (str1[i] != str2[str2Start + i])
{
return false;
}
}
return true;
}
}
[Flags]
public enum DefaultValueHandling
{
Include = 0,
Ignore = 1,
Populate = 2,
IgnoreAndPopulate = 3
}
public enum FloatFormatHandling
{
String,
Symbol,
DefaultValue
}
public enum FloatParseHandling
{
Double,
Decimal
}
public enum Formatting
{
None,
Indented
}
public interface IArrayPool<T>
{
T[] Rent(int minimumLength);
void Return(T[]? array);
}
public interface IJsonLineInfo
{
int LineNumber { get; }
int LinePosition { get; }
bool HasLineInfo();
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonArrayAttribute : JsonContainerAttribute
{
private bool _allowNullItems;
public bool AllowNullItems
{
get
{
return _allowNullItems;
}
set
{
_allowNullItems = value;
}
}
public JsonArrayAttribute()
{
}
public JsonArrayAttribute(bool allowNullItems)
{
_allowNullItems = allowNullItems;
}
public JsonArrayAttribute(string id)
: base(id)
{
}
}
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
public sealed class JsonConstructorAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public abstract class JsonContainerAttribute : Attribute
{
internal bool? _isReference;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
private Type? _namingStrategyType;
private object[]? _namingStrategyParameters;
public string? Id { get; set; }
public string? Title { get; set; }
public string? Description { get; set; }
public Type? ItemConverterType { get; set; }
public object[]? ItemConverterParameters { get; set; }
public Type? NamingStrategyType
{
get
{
return _namingStrategyType;
}
set
{
_namingStrategyType = value;
NamingStrategyInstance = null;
}
}
public object[]? NamingStrategyParameters
{
get
{
return _namingStrategyParameters;
}
set
{
_namingStrategyParameters = value;
NamingStrategyInstance = null;
}
}
internal NamingStrategy? NamingStrategyInstance { get; set; }
public bool IsReference
{
get
{
return _isReference.GetValueOrDefault();
}
set
{
_isReference = value;
}
}
public bool ItemIsReference
{
get
{
return _itemIsReference.GetValueOrDefault();
}
set
{
_itemIsReference = value;
}
}
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get
{
return _itemReferenceLoopHandling.GetValueOrDefault();
}
set
{
_itemReferenceLoopHandling = value;
}
}
public TypeNameHandling ItemTypeNameHandling
{
get
{
return _itemTypeNameHandling.GetValueOrDefault();
}
set
{
_itemTypeNameHandling = value;
}
}
protected JsonContainerAttribute()
{
}
protected JsonContainerAttribute(string id)
{
Id = id;
}
}
public static class JsonConvert
{
public static readonly string True = "true";
public static readonly string False = "false";
public static readonly string Null = "null";
public static readonly string Undefined = "undefined";
public static readonly string PositiveInfinity = "Infinity";
public static readonly string NegativeInfinity = "-Infinity";
public static readonly string NaN = "NaN";
public static Func<JsonSerializerSettings>? DefaultSettings { get; set; }
public static string ToString(DateTime value)
{
return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
}
public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
{
DateTime value2 = DateTimeUtils.EnsureDateTime(value, timeZoneHandling);
using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
stringWriter.Write('"');
DateTimeUtils.WriteDateTimeString(stringWriter, value2, format, null, CultureInfo.InvariantCulture);
stringWriter.Write('"');
return stringWriter.ToString();
}
public static string ToString(DateTimeOffset value)
{
return ToString(value, DateFormatHandling.IsoDateFormat);
}
public static string ToString(DateTimeOffset value, DateFormatHandling format)
{
using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
stringWriter.Write('"');
DateTimeUtils.WriteDateTimeOffsetString(stringWriter, value, format, null, CultureInfo.InvariantCulture);
stringWriter.Write('"');
return stringWriter.ToString();
}
public static string ToString(bool value)
{
if (!value)
{
return False;
}
return True;
}
public static string ToString(char value)
{
return ToString(char.ToString(value));
}
public static string ToString(Enum value)
{
return value.ToString("D");
}
public static string ToString(int value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(short value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(ushort value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(uint value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(long value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
private static string ToStringInternal(BigInteger value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(ulong value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(float value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
if (floatFormatHandling == FloatFormatHandling.Symbol || (!double.IsInfinity(value) && !double.IsNaN(value)))
{
return text;
}
if (floatFormatHandling == FloatFormatHandling.DefaultValue)
{
if (nullable)
{
return Null;
}
return "0.0";
}
return quoteChar + text + quoteChar;
}
public static string ToString(double value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureDecimalPlace(double value, string text)
{
if (double.IsNaN(value) || double.IsInfinity(value) || StringUtils.IndexOf(text, '.') != -1 || StringUtils.IndexOf(text, 'E') != -1 || StringUtils.IndexOf(text, 'e') != -1)
{
return text;
}
return text + ".0";
}
private static string EnsureDecimalPlace(string text)
{
if (StringUtils.IndexOf(text, '.') != -1)
{
return text;
}
return text + ".0";
}
public static string ToString(byte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(sbyte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(decimal value)
{
return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
}
public static string ToString(Guid value)
{
return ToString(value, '"');
}
internal static string ToString(Guid value, char quoteChar)
{
string text = value.ToString("D", CultureInfo.InvariantCulture);
string text2 = quoteChar.ToString(CultureInfo.InvariantCulture);
return text2 + text + text2;
}
public static string ToString(TimeSpan value)
{
return ToString(value, '"');
}
internal static string ToString(TimeSpan value, char quoteChar)
{
return ToString(value.ToString(), quoteChar);
}
public static string ToString(Uri? value)
{
if (value == null)
{
return Null;
}
return ToString(value, '"');
}
internal static string ToString(Uri value, char quoteChar)
{
return ToString(value.OriginalString, quoteChar);
}
public static string ToString(string? value)
{
return ToString(value, '"');
}
public static string ToString(string? value, char delimiter)
{
return ToString(value, delimiter, StringEscapeHandling.Default);
}
public static string ToString(string? value, char delimiter, StringEscapeHandling stringEscapeHandling)
{
if (delimiter != '"' && delimiter != '\'')
{
throw new ArgumentException("Delimiter must be a single or double quote.", "delimiter");
}
return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, appendDelimiters: true, stringEscapeHandling);
}
public static string ToString(object? value)
{
if (value == null)
{
return Null;
}
return ConvertUtils.GetTypeCode(value.GetType()) switch
{
PrimitiveTypeCode.String => ToString((string)value),
PrimitiveTypeCode.Char => ToString((char)value),
PrimitiveTypeCode.Boolean => ToString((bool)value),
PrimitiveTypeCode.SByte => ToString((sbyte)value),
PrimitiveTypeCode.Int16 => ToString((short)value),
PrimitiveTypeCode.UInt16 => ToString((ushort)value),
PrimitiveTypeCode.Int32 => ToString((int)value),
PrimitiveTypeCode.Byte => ToString((byte)value),
PrimitiveTypeCode.UInt32 => ToString((uint)value),
PrimitiveTypeCode.Int64 => ToString((long)value),
PrimitiveTypeCode.UInt64 => ToString((ulong)value),
PrimitiveTypeCode.Single => ToString((float)value),
PrimitiveTypeCode.Double => ToString((double)value),
PrimitiveTypeCode.DateTime => ToString((DateTime)value),
PrimitiveTypeCode.Decimal => ToString((decimal)value),
PrimitiveTypeCode.DBNull => Null,
PrimitiveTypeCode.DateTimeOffset => ToString((DateTimeOffset)value),
PrimitiveTypeCode.Guid => ToString((Guid)value),
PrimitiveTypeCode.Uri => ToString((Uri)value),
PrimitiveTypeCode.TimeSpan => ToString((TimeSpan)value),
PrimitiveTypeCode.BigInteger => ToStringInternal((BigInteger)value),
_ => throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType())),
};
}
[DebuggerStepThrough]
public static string SerializeObject(object? value)
{
return SerializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting)
{
return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return SerializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return SerializeObject(value, null, formatting, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, JsonSerializerSettings? settings)
{
return SerializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
return SerializeObjectInternal(value, type, jsonSerializer);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
{
return SerializeObject(value, null, formatting, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Type? type, Formatting formatting, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
jsonSerializer.Formatting = formatting;
return SerializeObjectInternal(value, type, jsonSerializer);
}
private static string SerializeObjectInternal(object? value, Type? type, JsonSerializer jsonSerializer)
{
StringWriter stringWriter = new StringWriter(new StringBuilder(256), CultureInfo.InvariantCulture);
using (JsonTextWriter jsonTextWriter = new JsonTextWriter(stringWriter))
{
jsonTextWriter.Formatting = jsonSerializer.Formatting;
jsonSerializer.Serialize(jsonTextWriter, value, type);
}
return stringWriter.ToString();
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value)
{
return DeserializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, JsonSerializerSettings settings)
{
return DeserializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, Type type)
{
return DeserializeObject(value, type, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static T? DeserializeObject<T>(string value)
{
return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
{
return DeserializeObject<T>(value);
}
[DebuggerStepThrough]
public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
{
return DeserializeObject<T>(value, settings);
}
[DebuggerStepThrough]
public static T? DeserializeObject<T>(string value, params JsonConverter[] converters)
{
return (T)DeserializeObject(value, typeof(T), converters);
}
[DebuggerStepThrough]
public static T? DeserializeObject<T>(string value, JsonSerializerSettings? settings)
{
return (T)DeserializeObject(value, typeof(T), settings);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, Type type, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return DeserializeObject(value, type, settings);
}
public static object? DeserializeObject(string value, Type? type, JsonSerializerSettings? settings)
{
ValidationUtils.ArgumentNotNull(value, "value");
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
if (!jsonSerializer.IsCheckAdditionalContentSet())
{
jsonSerializer.CheckAdditionalContent = true;
}
using JsonTextReader reader = new JsonTextReader(new StringReader(value));
return jsonSerializer.Deserialize(reader, type);
}
[DebuggerStepThrough]
public static void PopulateObject(string value, object target)
{
PopulateObject(value, target, null);
}
public static void PopulateObject(string value, object target, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
using JsonReader jsonReader = new JsonTextReader(new StringReader(value));
jsonSerializer.Populate(jsonReader, target);
if (settings == null || !settings.CheckAdditionalContent)
{
return;
}
while (jsonReader.Read())
{
if (jsonReader.TokenType != JsonToken.Comment)
{
throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
}
}
}
public static string SerializeXmlNode(XmlNode? node)
{
return SerializeXmlNode(node, Formatting.None);
}
public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
{
OmitRootObject = omitRootObject
};
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static XmlDocument? DeserializeXmlNode(string value)
{
return DeserializeXmlNode(value, null);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
{
return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), xmlNodeConverter);
}
public static string SerializeXNode(XObject? node)
{
return SerializeXNode(node, Formatting.None);
}
public static string SerializeXNode(XObject? node, Formatting formatting)
{
return SerializeXNode(node, formatting, omitRootObject: false);
}
public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
{
OmitRootObject = omitRootObject
};
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static XDocument? DeserializeXNode(string value)
{
return DeserializeXNode(value, null);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
{
return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XDocument)DeserializeObject(value, typeof(XDocument), xmlNodeConverter);
}
}
public abstract class JsonConverter
{
public virtual bool CanRead => true;
public virtual bool CanWrite => true;
public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer);
public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer);
public abstract bool CanConvert(Type objectType);
}
public abstract class JsonConverter<T> : JsonConverter
{
public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (!((value != null) ? (value is T) : ReflectionUtils.IsNullable(typeof(T))))
{
throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
WriteJson(writer, (T)value, serializer);
}
public abstract void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer);
public sealed override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
bool flag = existingValue == null;
if (!flag && !(existingValue is T))
{
throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
return ReadJson(reader, objectType, flag ? default(T) : ((T)existingValue), !flag, serializer);
}
public abstract T? ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer);
public sealed override bool CanConvert(Type objectType)
{
return typeof(T).IsAssignableFrom(objectType);
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonConverterAttribute : Attribute
{
private readonly Type _converterType;
public Type ConverterType => _converterType;
public object[]? ConverterParameters { get; }
public JsonConverterAttribute(Type converterType)
{
if (converterType == null)
{
throw new ArgumentNullException("converterType");
}
_converterType = converterType;
}
public JsonConverterAttribute(Type converterType, params object[] converterParameters)
: this(converterType)
{
ConverterParameters = converterParameters;
}
}
public class JsonConverterCollection : Collection<JsonConverter>
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonDictionaryAttribute : JsonContainerAttribute
{
public JsonDictionaryAttribute()
{
}
public JsonDictionaryAttribute(string id)
: base(id)
{
}
}
[Serializable]
public class JsonException : Exception
{
public JsonException()
{
}
public JsonException(string message)
: base(message)
{
}
public JsonException(string message, Exception? innerException)
: base(message, innerException)
{
}
public JsonException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
return new JsonException(message);
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public class JsonExtensionDataAttribute : Attribute
{
public bool WriteData { get; set; }
public bool ReadData { get; set; }
public JsonExtensionDataAttribute()
{
WriteData = true;
ReadData = true;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public sealed class JsonIgnoreAttribute : Attribute
{
}
public abstract class JsonNameTable
{
public abstract string? Get(char[] key, int start, int length);
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonObjectAttribute : JsonContainerAttribute
{
private MemberSerialization _memberSerialization;
internal MissingMemberHandling? _missingMemberHandling;
internal Required? _itemRequired;
internal NullValueHandling? _itemNullValueHandling;
public MemberSerialization MemberSerialization
{
get
{
return _memberSerialization;
}
set
{
_memberSerialization = value;
}
}
public MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling.GetValueOrDefault();
}
set
{
_missingMemberHandling = value;
}
}
public NullValueHandling ItemNullValueHandling
{
get
{
return _itemNullValueHandling.GetValueOrDefault();
}
set
{
_itemNullValueHandling = value;
}
}
public Required ItemRequired
{
get
{
return _itemRequired.GetValueOrDefault();
}
set
{
_itemRequired = value;
}
}
public JsonObjectAttribute()
{
}
public JsonObjectAttribute(MemberSerialization memberSerialization)
{
MemberSerialization = memberSerialization;
}
public JsonObjectAttribute(string id)
: base(id)
{
}
}
internal enum JsonContainerType
{
None,
Object,
Array,
Constructor
}
internal struct JsonPosition
{
private static readonly char[] SpecialCharacters = new char[18]
{
'.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t',
'\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029'
};
internal JsonContainerType Type;
internal int Position;
internal string? PropertyName;
internal bool HasIndex;
public JsonPosition(JsonContainerType type)
{
Type = type;
HasIndex = TypeHasIndex(type);
Position = -1;
PropertyName = null;
}
internal int CalculateLength()
{
switch (Type)
{
case JsonContainerType.Object:
return PropertyName.Length + 5;
case JsonContainerType.Array:
case JsonContainerType.Constructor:
return MathUtils.IntLength((ulong)Position) + 2;
default:
throw new ArgumentOutOfRangeException("Type");
}
}
internal void WriteTo(StringBuilder sb, ref StringWriter? writer, ref char[]? buffer)
{
switch (Type)
{
case JsonContainerType.Object:
{
string propertyName = PropertyName;
if (propertyName.IndexOfAny(SpecialCharacters) != -1)
{
sb.Append("['");
if (writer == null)
{
writer = new StringWriter(sb);
}
JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', appendDelimiters: false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer);
sb.Append("']");
}
else
{
if (sb.Length > 0)
{
sb.Append('.');
}
sb.Append(propertyName);
}
break;
}
case JsonContainerType.Array:
case JsonContainerType.Constructor:
sb.Append('[');
sb.Append(Position);
sb.Append(']');
break;
}
}
internal static bool TypeHasIndex(JsonContainerType type)
{
if (type != JsonContainerType.Array)
{
return type == JsonContainerType.Constructor;
}
return true;
}
internal static string BuildPath(List<JsonPosition> positions, JsonPosition? currentPosition)
{
int num = 0;
if (positions != null)
{
for (int i = 0; i < positions.Count; i++)
{
num += positions[i].CalculateLength();
}
}
if (currentPosition.HasValue)
{
num += currentPosition.GetValueOrDefault().CalculateLength();
}
StringBuilder stringBuilder = new StringBuilder(num);
StringWriter writer = null;
char[] buffer = null;
if (positions != null)
{
foreach (JsonPosition position in positions)
{
position.WriteTo(stringBuilder, ref writer, ref buffer);
}
}
currentPosition?.WriteTo(stringBuilder, ref writer, ref buffer);
return stringBuilder.ToString();
}
internal static string FormatMessage(IJsonLineInfo? lineInfo, string path, string message)
{
if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
{
message = message.Trim();
if (!StringUtils.EndsWith(message, '.'))
{
message += ".";
}
message += " ";
}
message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
if (lineInfo != null && lineInfo.HasLineInfo())
{
message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
}
message += ".";
return message;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonPropertyAttribute : Attribute
{
internal NullValueHandling? _nullValueHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal TypeNameHandling? _typeNameHandling;
internal bool? _isReference;
internal int? _order;
internal Required? _required;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
public Type? ItemConverterType { get; set; }
public object[]? ItemConverterParameters { get; set; }
public Type? NamingStrategyType { get; set; }
public object[]? NamingStrategyParameters { get; set; }
public NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling.GetValueOrDefault();
}
set
{
_nullValueHandling = value;
}
}
public DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling.GetValueOrDefault();
}
set
{
_defaultValueHandling = value;
}
}
public ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling.GetValueOrDefault();
}
set
{
_referenceLoopHandling = value;
}
}
public ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling.GetValueOrDefault();
}
set
{
_objectCreationHandling = value;
}
}
public TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling.GetValueOrDefault();
}
set
{
_typeNameHandling = value;
}
}
public bool IsReference
{
get
{
return _isReference.GetValueOrDefault();
}
set
{
_isReference = value;
}
}
public int Order
{
get
{
return _order.GetValueOrDefault();
}
set
{
_order = value;
}
}
public Required Required
{
get
{
return _required.GetValueOrDefault();
}
set
{
_required = value;
}
}
public string? PropertyName { get; set; }
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get
{
return _itemReferenceLoopHandling.GetValueOrDefault();
}
set
{
_itemReferenceLoopHandling = value;
}
}
public TypeNameHandling ItemTypeNameHandling
{
get
{
return _itemTypeNameHandling.GetValueOrDefault();
}
set
{
_itemTypeNameHandling = value;
}
}
public bool ItemIsReference
{
get
{
return _itemIsReference.GetValueOrDefault();
}
set
{
_itemIsReference = value;
}
}
public JsonPropertyAttribute()
{
}
public JsonPropertyAttribute(string propertyName)
{
PropertyName = propertyName;
}
}
public abstract class JsonReader : IDisposable
{
protected internal enum State
{
Start,
Complete,
Property,
ObjectStart,
Object,
ArrayStart,
Array,
Closed,
PostValue,
ConstructorStart,
Constructor,
Error,
Finished
}
private JsonToken _tokenType;
private object? _value;
internal char _quoteChar;
internal State _currentState;
private JsonPosition _currentPosition;
private CultureInfo? _culture;
private DateTimeZoneHandling _dateTimeZoneHandling;
private int? _maxDepth;
private bool _hasExceededMaxDepth;
internal DateParseHandling _dateParseHandling;
internal FloatParseHandling _floatParseHandling;
private string? _dateFormatString;
private List<JsonPosition>? _stack;
protected State CurrentState => _currentState;
public bool CloseInput { get; set; }
public bool SupportMultipleContent { get; set; }
public virtual char QuoteChar
{
get
{
return _quoteChar;
}
protected internal set
{
_quoteChar = value;
}
}
public DateTimeZoneHandling DateTimeZoneHandling
{
get
{
return _dateTimeZoneHandling;
}
set
{
if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
{
throw new ArgumentOutOfRangeException("value");
}
_dateTimeZoneHandling = value;
}
}
public DateParseHandling DateParseHandling
{
get
{
return _dateParseHandling;
}
set
{
if (value < DateParseHandling.None || value > DateParseHandling.DateTimeOffset)
{
throw new ArgumentOutOfRangeException("value");
}
_dateParseHandling = value;
}
}
public FloatParseHandling FloatParseHandling
{
get
{
return _floatParseHandling;
}
set
{
if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal)
{
throw new ArgumentOutOfRangeException("value");
}
_floatParseHandling = value;
}
}
public string? DateFormatString
{
get
{
return _dateFormatString;
}
set
{
_dateFormatString = value;
}
}
public int? MaxDepth
{
get
{
return _maxDepth;
}
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", "value");
}
_maxDepth = value;
}
}
public virtual JsonToken TokenType => _tokenType;
public virtual object? Value => _value;
public virtual Type? ValueType => _value?.GetType();
public virtual int Depth
{
get
{
int num = _stack?.Count ?? 0;
if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None)
{
return num;
}
return num + 1;
}
}
public virtual string Path
{
get
{
if (_currentPosition.Type == JsonContainerType.None)
{
return string.Empty;
}
JsonPosition? currentPosition = ((_currentState != State.ArrayStart && _currentState != State.ConstructorStart && _currentState != State.ObjectStart) ? new JsonPosition?(_currentPosition) : null);
return JsonPosition.BuildPath(_stack, currentPosition);
}
}
public CultureInfo Culture
{
get
{
return _culture ?? CultureInfo.InvariantCulture;
}
set
{
_culture = value;
}
}
public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
}
public async Task SkipAsync(CancellationToken cancellationToken = default(CancellationToken))
{
if (TokenType == JsonToken.PropertyName)
{
await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false) && depth < Depth)
{
}
}
}
internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
throw CreateUnexpectedEndException();
}
}
public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
}
public virtual Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
}
internal async Task<byte[]?> ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken)
{
List<byte> buffer = new List<byte>();
do
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
SetToken(JsonToken.None);
}
}
while (!ReadArrayElementIntoByteArrayReportDone(buffer));
byte[] array = buffer.ToArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
}
public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
}
public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
}
public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(ReadAsDouble());
}
public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
}
public virtual Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString());
}
internal async Task<bool> ReadAndMoveToContentAsync(CancellationToken cancellationToken)
{
bool flag = await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
if (flag)
{
flag = await MoveToContentAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
}
return flag;
}
internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
{
JsonToken tokenType = TokenType;
if (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
{
return MoveToContentFromNonContentAsync(cancellationToken);
}
return AsyncUtils.True;
}
private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
{
JsonToken tokenType;
do
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
return false;
}
tokenType = TokenType;
}
while (tokenType == JsonToken.None || tokenType == JsonToken.Comment);
return true;
}
internal JsonPosition GetPosition(int depth)
{
if (_stack != null && depth < _stack.Count)
{
return _stack[depth];
}
return _currentPosition;
}
protected JsonReader()
{
_currentState = State.Start;
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
_floatParseHandling = FloatParseHandling.Double;
_maxDepth = 64;
CloseInput = true;
}
private void Push(JsonContainerType value)
{
UpdateScopeWithFinishedValue();
if (_currentPosition.Type == JsonContainerType.None)
{
_currentPosition = new JsonPosition(value);
return;
}
if (_stack == null)
{
_stack = new List<JsonPosition>();
}
_stack.Add(_currentPosition);
_currentPosition = new JsonPosition(value);
if (!_maxDepth.HasValue || !(Depth + 1 > _maxDepth) || _hasExceededMaxDepth)
{
return;
}
_hasExceededMaxDepth = true;
throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
}
private JsonContainerType Pop()
{
JsonPosition currentPosition;
if (_stack != null && _stack.Count > 0)
{
currentPosition = _currentPosition;
_currentPosition = _stack[_stack.Count - 1];
_stack.RemoveAt(_stack.Count - 1);
}
else
{
currentPosition = _currentPosition;
_currentPosition = default(JsonPosition);
}
if (_maxDepth.HasValue && Depth <= _maxDepth)
{
_hasExceededMaxDepth = false;
}
return currentPosition.Type;
}
private JsonContainerType Peek()
{
return _currentPosition.Type;
}
public abstract bool Read();
public virtual int? ReadAsInt32()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is int)
{
return (int)value;
}
int num;
if (value is BigInteger bigInteger)
{
num = (int)bigInteger;
}
else
{
try
{
num = Convert.ToInt32(value, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
}
}
SetToken(JsonToken.Integer, num, updateIndex: false);
return num;
}
case JsonToken.String:
{
string s = (string)Value;
return ReadInt32String(s);
}
default:
throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal int? ReadInt32String(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (int.TryParse(s, NumberStyles.Integer, Culture, out var result))
{
SetToken(JsonToken.Integer, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual string? ReadAsString()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.String:
return (string)Value;
default:
if (JsonTokenUtils.IsPrimitiveToken(contentToken))
{
object value = Value;
if (value != null)
{
string text = ((!(value is IFormattable formattable)) ? ((value is Uri uri) ? uri.OriginalString : value.ToString()) : formattable.ToString(null, Culture));
SetToken(JsonToken.String, text, updateIndex: false);
return text;
}
}
throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
public virtual byte[]? ReadAsBytes()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.StartObject:
{
ReadIntoWrappedTypeObject();
byte[] array2 = ReadAsBytes();
ReaderReadAndAssert();
if (TokenType != JsonToken.EndObject)
{
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
SetToken(JsonToken.Bytes, array2, updateIndex: false);
return array2;
}
case JsonToken.String:
{
string text = (string)Value;
Guid g;
byte[] array3 = ((text.Length == 0) ? CollectionUtils.ArrayEmpty<byte>() : ((!ConvertUtils.TryConvertGuid(text, out g)) ? Convert.FromBase64String(text) : g.ToByteArray()));
SetToken(JsonToken.Bytes, array3, updateIndex: false);
return array3;
}
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Bytes:
if (Value is Guid guid)
{
byte[] array = guid.ToByteArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
return (byte[])Value;
case JsonToken.StartArray:
return ReadArrayIntoByteArray();
default:
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal byte[] ReadArrayIntoByteArray()
{
List<byte> list = new List<byte>();
do
{
if (!Read())
{
SetToken(JsonToken.None);
}
}
while (!ReadArrayElementIntoByteArrayReportDone(list));
byte[] array = list.ToArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer)
{
switch (TokenType)
{
case JsonToken.None:
throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
case JsonToken.Integer:
buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
return false;
case JsonToken.EndArray:
return true;
case JsonToken.Comment:
return false;
default:
throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
}
public virtual double? ReadAsDouble()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is double)
{
return (double)value;
}
double num = ((!(value is BigInteger bigInteger)) ? Convert.ToDouble(value, CultureInfo.InvariantCulture) : ((double)bigInteger));
SetToken(JsonToken.Float, num, updateIndex: false);
return num;
}
case JsonToken.String:
return ReadDoubleString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal double? ReadDoubleString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out var result))
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual bool? ReadAsBoolean()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
bool flag = ((!(Value is BigInteger bigInteger)) ? Convert.ToBoolean(Value, CultureInfo.InvariantCulture) : (bigInteger != 0L));
SetToken(JsonToken.Boolean, flag, updateIndex: false);
return flag;
}
case JsonToken.String:
return ReadBooleanString((string)Value);
case JsonToken.Boolean:
return (bool)Value;
default:
throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal bool? ReadBooleanString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (bool.TryParse(s, out var result))
{
SetToken(JsonToken.Boolean, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual decimal? ReadAsDecimal()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is decimal)
{
return (decimal)value;
}
decimal num;
if (value is BigInteger bigInteger)
{
num = (decimal)bigInteger;
}
else
{
try
{
num = Convert.ToDecimal(value, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
}
}
SetToken(JsonToken.Float, num, updateIndex: false);
return num;
}
case JsonToken.String:
return ReadDecimalString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal decimal? ReadDecimalString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (decimal.TryParse(s, NumberStyles.Number, Culture, out var result))
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out result) == ParseResult.Success)
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual DateTime? ReadAsDateTime()
{
switch (GetContentToken())
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
if (Value is DateTimeOffset dateTimeOffset)
{
SetToken(JsonToken.Date, dateTimeOffset.DateTime, updateIndex: false);
}
return (DateTime)Value;
case JsonToken.String:
return ReadDateTimeString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
}
internal DateTime? ReadDateTimeString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out var dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual DateTimeOffset? ReadAsDateTimeOffset()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
if (Value is DateTime dateTime)
{
SetToken(JsonToken.Date, new DateTimeOffset(dateTime), updateIndex: false);
}
return (DateTimeOffset)Value;
case JsonToken.String:
{
string s = (string)Value;
return ReadDateTimeOffsetString(s);
}
default:
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal DateTimeOffset? ReadDateTimeOffsetString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (DateTimeUtils.TryParseDateTimeOffset(s, _dateFormatString, Culture, out var dt))
{
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
if (DateTimeOffset.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to DateTimeOffset: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
internal void ReaderReadAndAssert()
{
if (!Read())
{
throw CreateUnexpectedEndException();
}
}
internal JsonReaderException CreateUnexpectedEndException()
{
return JsonReaderException.Create(this, "Unexpected end when reading JSON.");
}
internal void ReadIntoWrappedTypeObject()
{
ReaderReadAndAssert();
if (Value != null && Value.ToString() == "$type")
{
ReaderReadAndAssert();
if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal))
{
ReaderReadAndAssert();
if (Value.ToString() == "$value")
{
return;
}
}
}
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
}
public void Skip()
{
if (TokenType == JsonToken.PropertyName)
{
Read();
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (Read() && depth < Depth)
{
}
}
}
protected void SetToken(JsonToken newToken)
{
SetToken(newToken, null, updateIndex: true);
}
protected void SetToken(JsonToken newToken, object? value)
{
SetToken(newToken, value, updateIndex: true);
}
protected void SetToken(JsonToken newToken, object? value, bool updateIndex)
{
_tokenType = newToken;
_value = value;
switch (newToken)
{
case JsonToken.StartObject:
_currentState = State.ObjectStart;
Push(JsonContainerType.Object);
break;
case JsonToken.StartArray:
_currentState = State.ArrayStart;
Push(JsonContainerType.Array);
break;
case JsonToken.StartConstructor:
_currentState = State.ConstructorStart;
Push(JsonContainerType.Constructor);
break;
case JsonToken.EndObject:
ValidateEnd(JsonToken.EndObject);
break;
case JsonToken.EndArray:
ValidateEnd(JsonToken.EndArray);
break;
case JsonToken.EndConstructor:
ValidateEnd(JsonToken.EndConstructor);
break;
case JsonToken.PropertyName:
_currentState = State.Property;
_currentPosition.PropertyName = (string)value;
break;
case JsonToken.Raw:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Boolean:
case JsonToken.Null:
case JsonToken.Undefined:
case JsonToken.Date:
case JsonToken.Bytes:
SetPostValueState(updateIndex);
break;
case JsonToken.Comment:
break;
}
}
internal void SetPostValueState(bool updateIndex)
{
if (Peek() != 0 || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
if (updateIndex)
{
UpdateScopeWithFinishedValue();
}
}
private void UpdateScopeWithFinishedValue()
{
if (_currentPosition.HasIndex)
{
_currentPosition.Position++;
}
}
private void ValidateEnd(JsonToken endToken)
{
JsonContainerType jsonContainerType = Pop();
if (GetTypeForCloseToken(endToken) != jsonContainerType)
{
throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, jsonContainerType));
}
if (Peek() != 0 || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
}
protected void SetStateBasedOnCurrent()
{
JsonContainerType jsonContainerType = Peek();
switch (jsonContainerType)
{
case JsonContainerType.Object:
_currentState = State.Object;
break;
case JsonContainerType.Array:
_currentState = State.Array;
break;
case JsonContainerType.Constructor:
_currentState = State.Constructor;
break;
case JsonContainerType.None:
SetFinished();
break;
default:
throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, jsonContainerType));
}
}
private void SetFinished()
{
_currentState = ((!SupportMultipleContent) ? State.Finished : State.Start);
}
private JsonContainerType GetTypeForCloseToken(JsonToken token)
{
return token switch
{
JsonToken.EndObject => JsonContainerType.Object,
JsonToken.EndArray => JsonContainerType.Array,
JsonToken.EndConstructor => JsonContainerType.Constructor,
_ => throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token)),
};
}
void IDisposable.Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (_currentState != State.Closed && disposing)
{
Close();
}
}
public virtual void Close()
{
_currentState = State.Closed;
_tokenType = JsonToken.None;
_value = null;
}
internal void ReadAndAssert()
{
if (!Read())
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter)
{
if (!ReadForType(contract, hasConverter))
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal bool ReadForType(JsonContract? contract, bool hasConverter)
{
if (hasConverter)
{
return Read();
}
switch (contract?.InternalReadType ?? ReadType.Read)
{
case ReadType.Read:
return ReadAndMoveToContent();
case ReadType.ReadAsInt32:
ReadAsInt32();
break;
case ReadType.ReadAsInt64:
{
bool result = ReadAndMoveToContent();
if (TokenType == JsonToken.Undefined)
{
throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long)));
}
return result;
}
case ReadType.ReadAsDecimal:
ReadAsDecimal();
break;
case ReadType.ReadAsDouble:
ReadAsDouble();
break;
case ReadType.ReadAsBytes:
ReadAsBytes();
break;
case ReadType.ReadAsBoolean:
ReadAsBoolean();
break;
case ReadType.ReadAsString:
ReadAsString();
break;
case ReadType.ReadAsDateTime:
ReadAsDateTime();
break;
case ReadType.ReadAsDateTimeOffset:
ReadAsDateTimeOffset();
break;
default:
throw new ArgumentOutOfRangeException();
}
return TokenType != JsonToken.None;
}
internal bool ReadAndMoveToContent()
{
if (Read())
{
return MoveToContent();
}
return false;
}
internal bool MoveToContent()
{
JsonToken tokenType = TokenType;
while (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
{
if (!Read())
{
return false;
}
tokenType = TokenType;
}
return true;
}
private JsonToken GetContentToken()
{
JsonToken tokenType;
do
{
if (!Read())
{
SetToken(JsonToken.None);
return JsonToken.None;
}
tokenType = TokenType;
}
while (tokenType == JsonToken.Comment);
return tokenType;
}
}
[Serializable]
public class JsonReaderException : JsonException
{
public int LineNumber { get; }
public int LinePosition { get; }
public string? Path { get; }
public JsonReaderException()
{
}
public JsonReaderException(string message)
: base(message)
{
}
public JsonReaderException(string message, Exception innerException)
: base(message, innerException)
{
}
public JsonReaderException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonReaderException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonReaderException(message, path, lineNumber, linePosition, ex);
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public sealed class JsonRequiredAttribute : Attribute
{
}
[Serializable]
public class JsonSerializationException : JsonException
{
public int LineNumber { get; }
public int LinePosition { get; }
public string? Path { get; }
public JsonSerializationException()
{
}
public JsonSerializationException(string message)
: base(message)
{
}
public JsonSerializationException(string message, Exception innerException)
: base(message, innerException)
{
}
public JsonSerializationException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonSerializationException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonSerializationException(message, path, lineNumber, linePosition, ex);
}
}
public class JsonSerializer
{
internal TypeNameHandling _typeNameHandling;
internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling;
internal PreserveReferencesHandling _preserveReferencesHandling;
internal ReferenceLoopHandling _referenceLoopHandling;
internal MissingMemberHandling _missingMemberHandling;
internal ObjectCreationHandling _objectCreationHandling;
internal NullValueHandling _nullValueHandling;
internal DefaultValueHandling _defaultValueHandling;
internal ConstructorHandling _constructorHandling;
internal MetadataPropertyHandling _metadataPropertyHandling;
internal JsonConverterCollection? _converters;
internal IContractResolver _contractResolver;
internal ITraceWriter? _traceWriter;
internal IEqualityComparer? _equalityComparer;
internal ISerializationBinder _serializationBinder;
internal StreamingContext _context;
private IReferenceResolver? _referenceResolver;
private Formatting? _formatting;
private DateFormatHandling? _dateFormatHandling;
private DateTimeZoneHandling? _dateTimeZoneHandling;
private DateParseHandling? _dateParseHandling;
private FloatFormatHandling? _floatFormatHandling;
private FloatParseHandling? _floatParseHandling;
private StringEscapeHandling? _stringEscapeHandling;
private CultureInfo _culture;
private int? _maxDepth;
private bool _maxDepthSet;
private bool? _checkAdditionalContent;
private string? _dateFormatString;
private bool _dateFormatStringSet;
public virtual IReferenceResolver? ReferenceResolver
{
get
{
return GetReferenceResolver();
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Reference resolver cannot be null.");
}
_referenceResolver = value;
}
}
[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
public virtual SerializationBinder Binder
{
get
{
if (_serializationBinder is SerializationBinder result)
{
return result;
}
if (_serializationBinder is SerializationBinderAdapter serializationBinderAdapter)
{
return serializationBinderAdapter.SerializationBinder;
}
throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Serialization binder cannot be null.");
}
_serializationBinder = (value as ISerializationBinder) ?? new SerializationBinderAdapter(value);
}
}
public virtual ISerializationBinder SerializationBinder
{
get
{
return _serializationBinder;
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Serialization binder cannot be null.");
}
_serializationBinder = value;
}
}
public virtual ITraceWriter? TraceWriter
{
get
{
return _traceWriter;
}
set
{
_traceWriter = value;
}
}
public virtual IEqualityComparer? EqualityComparer
{
get
{
return _equalityComparer;
}
set
{
_equalityComparer = value;
}
}
public virtual TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling;
}
set
{
if (value < TypeNameHandling.None || value > TypeNameHandling.Auto)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameHandling = value;
}
}
[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
public virtual FormatterAssemblyStyle TypeNameAssemblyFormat
{
get
{
return (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling;
}
set
{
if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
}
}
public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
{
get
{
return _typeNameAssemblyFormatHandling;
}
set
{
if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameAssemblyFormatHandling = value;
}
}
public virtual PreserveReferencesHandling PreserveReferencesHandling
{
get
{
return _preserveReferencesHandling;
}
set
{
if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All)
{
throw new ArgumentOutOfRangeException("value");
}
_preserveReferencesHandling = value;
}
}
public virtual ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling;
}
set
{
if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
{
throw new ArgumentOutOfRangeException("value");
}
_referenceLoopHandling = value;
}
}
public virtual MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling;
}
set
{
if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error)
{
throw new ArgumentOutOfRangeException("value");
}
_missingMemberHandling = value;
}
}
public virtual NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling;
}
set
{
if (value < NullValueHandling.Include || value > NullValueHandling.Ignore)
{
throw new ArgumentOutOfRangeException("value");
}
_nullValueHandling = value;
}
}
public virtual DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling;
}
set
{
if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate)
{
throw new ArgumentOutOfRangeException("value");
}
_defaultValueHandling = value;
}
}
public virtual ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling;
}
set
{
if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace)
{
throw new ArgumentOutOfRangeException("value");
}
_objectCreationHandling = value;
}
}
public virtual ConstructorHandling ConstructorHandling
{
get
{
return _constructorHandling;
}
set
{
if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor)
{
throw new ArgumentOutOfRangeException("value");
}
_constructorHandling = value;
}
}
public virtual MetadataPropertyHandling MetadataPropertyHandling
{
get
{
return _metadataPropertyHandling;
}
set
{
if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore)
{
throw new ArgumentOutOfRangeException("value");
}
_metadataPropertyHandling = value;
}
}
public virtual JsonConverterCollection Converters
{
get
{
if (_converters == null)
{
_converters = new JsonConverterCollection();
}
return _converters;
}
}
public virtual IContractResolver ContractResolver
{
get
{
return _contractResolver;
}
set
{
_contractResolver = value ?? DefaultContractResolver.Instance;
}
}
public virtual StreamingContext Context
{
get
{
return _context;
}
set
{
_context = value;
}
}
public virtual Formatting Formatting
{
get
{
return _formatting.GetValueOrDefault();
}
set
{
_formatting = value;
}
}
public virtual DateFormatHandling DateFormatHandling
{
get
{
return _dateFormatHandling.GetValueOrDefault();
}
set
{
_dateFormatHandling = value;
}
}
public virtual DateTimeZoneHandling DateTimeZoneHandling
{
get
{
return _dateTimeZoneHandling ?? DateTimeZoneHandling.RoundtripKind;
}
set
{
_dateTimeZoneHandling = value;
}
}
public virtual DateParseHandling DateParseHandling
{
get
{
return _dateParseHandling ?? DateParseHandling.DateTime;
}
set
{
_dateParseHandling = value;
}
}
public virtual FloatParseHandling FloatParseHandling
{
get
{
return _floatParseHandling.GetValueOrDefault();
}
set
{
_floatParseHandling = value;
}
}
public virtual FloatFormatHandling FloatFormatHandling
{
get
{
return _floatFormatHandling.GetValueOrDefault();
}
set
{
_floatFormatHandling = value;
}
}
public virtual StringEscapeHandling StringEscapeHandling
{
get
{
return _stringEscapeHandling.GetValueOrDefault();
}
set
{
_stringEscapeHandling = value;
}
}
public virtual string DateFormatString
{
get
{
return _dateFormatString ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
}
set
{
_dateFormatString = value;
_dateFormatStringSet = true;
}
}
public virtual CultureInfo Culture
{
get
{
return _culture ?? JsonSerializerSettings.DefaultCulture;
}
set
{
_culture = value;
}
}
public virtual int? MaxDepth
{
get
{
return _maxDepth;
}
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", "value");
}
_maxDepth = value;
_maxDepthSet = true;
}
}
public virtual bool CheckAdditionalContent
{
get
{
return _checkAdditionalContent.GetValueOrDefault();
}
set
{
_checkAdditionalContent = value;
}
}
public virtual event EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>? Error;
internal bool IsCheckAdditionalContentSet()
{
return _checkAdditionalContent.HasValue;
}
public JsonSerializer()
{
_referenceLoopHandling = ReferenceLoopHandling.Error;
_missingMemberHandling = MissingMemberHandling.Ignore;
_nullValueHandling = NullValueHandling.Include;
_defaultValueHandling = DefaultValueHandling.Include;
_objectCreationHandling = ObjectCreationHandling.Auto;
_preserveReferencesHandling = PreserveReferencesHandling.None;
_constructorHandling = ConstructorHandling.Default;
_typeNameHandling = TypeNameHandling.None;
_metadataPropertyHandling = MetadataPropertyHandling.Default;
_context = JsonSerializerSettings.DefaultContext;
_serializationBinder = DefaultSerializationBinder.Instance;
_culture = JsonSerializerSettings.DefaultCulture;
_contractResolver = DefaultContractResolver.Instance;
}
public static JsonSerializer Create()
{
return new JsonSerializer();
}
public static JsonSerializer Create(JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = Create();
if (settings != null)
{
ApplySerializerSettings(jsonSerializer, settings);
}
return jsonSerializer;
}
public static JsonSerializer CreateDefault()
{
return Create(JsonConvert.DefaultSettings?.Invoke());
}
public static JsonSerializer CreateDefault(JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = CreateDefault();
if (settings != null)
{
ApplySerializerSettings(jsonSerializer, settings);
}
return jsonSerializer;
}
private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings)
{
if (!CollectionUtils.IsNullOrEmpty(settings.Converters))
{
for (int i = 0; i < settings.Converters.Count; i++)
{
serializer.Converters.Insert(i, settings.Converters[i]);
}
}
if (settings._typeNameHandling.HasValue)
{
serializer.TypeNameHandling = settings.TypeNameHandling;
}
if (settings._metadataPropertyHandling.HasValue)
{
serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling;
}
if (settings._typeNameAssemblyFormatHandling.HasValue)
{
serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling;
}
if (settings._preserveReferencesHandling.HasValue)
{
serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
}
if (settings._referenceLoopHandling.HasValue)
{
serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
}
if (settings._missingMemberHandling.HasValue)
{
serializer.MissingMemberHandling = settings.MissingMemberHandling;
}
if (settings._objectCreationHandling.HasValue)
{
serializer.ObjectCreationHandling = settings.ObjectCreationHandling;
}
if (settings._nullValueHandling.HasValue)
{
serializer.NullValueHandling = settings.NullValueHandling;
}
if (settings._defaultValueHandling.HasValue)
{
serializer.DefaultValueHandling = settings.DefaultValueHandling;
}
if (settings._constructorHandling.HasValue)
{
serializer.ConstructorHandling = settings.ConstructorHandling;
}
if (settings._context.HasValue)
{
serializer.Context = settings.Context;
}
if (settings._checkAdditionalContent.HasValue)
{
serializer._checkAdditionalContent = settings._checkAdditionalContent;
}
if (settings.Error != null)
{
serializer.Error += settings.Error;
}
if (settings.ContractResolver != null)
{
serializer.ContractResolver = settings.ContractResolver;
}
if (settings.ReferenceResolverProvider != null)
{
serializer.ReferenceResolver = settings.ReferenceResolverProvider();
}
if (settings.TraceWriter != null)
{
serializer.TraceWriter = settings.TraceWriter;
}
if (settings.EqualityComparer != null)
{
serializer.EqualityComparer = settings.EqualityComparer;
}
if (settings.SerializationBinder != null)
{
serializer.SerializationBinder = settings.SerializationBinder;
}
if (settings._formatting.HasValue)
{
serializer._formatting = settings._formatting;
}
if (settings._dateFormatHandling.HasValue)
{
serializer._dateFormatHandling = settings._dateFormatHandling;
}
if (settings._dateTimeZoneHandling.HasValue)
{
serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
}
if (settings._dateParseHandling.HasValue)
{
serializer._dateParseHandling = settings._dateParseHandling;
}
if (settings._dateFormatStringSet)
{
serializer._dateFormatString = settings._dateFormatString;
serializer._dateFormatStringSet = settings._dateFormatStringSet;
}
if (settings._floatFormatHandling.HasValue)
{
serializer._floatFormatHandling = settings._floatFormatHandling;
}
if (settings._floatParseHandling.HasValue)
{
serializer._floatParseHandling = settings._floatParseHandling;
}
if (settings._stringEscapeHandling.HasValue)
{
serializer._stringEscapeHandling = settings._stringEscapeHandling;
}
if (settings._culture != null)
{
serializer._culture = settings._culture;
}
if (settings._maxDepthSet)
{
serializer._maxDepth = settings._maxDepth;
serializer._maxDepthSet = settings._maxDepthSet;
}
}
[DebuggerStepThrough]
public void Populate(TextReader reader, object target)
{
Populate(new JsonTextReader(reader), target);
}
[DebuggerStepThrough]
public void Populate(JsonReader reader, object target)
{
PopulateInternal(reader, target);
}
internal virtual void PopulateInternal(JsonReader reader, object target)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
ValidationUtils.ArgumentNotNull(target, "target");
SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
new JsonSerializerInternalReader(this).Populate(traceJsonReader ?? reader, target);
if (traceJsonReader != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
}
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader)
{
return Deserialize(reader, null);
}
[DebuggerStepThrough]
public object? Deserialize(TextReader reader, Type objectType)
{
return Deserialize(new JsonTextReader(reader), objectType);
}
[DebuggerStepThrough]
public T? Deserialize<T>(JsonReader reader)
{
return (T)Deserialize(reader, typeof(T));
}
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader, Type? objectType)
{
return DeserializeInternal(reader, objectType);
}
internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
object? result = new JsonSerializerInternalReader(this).Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent);
if (traceJsonReader != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
return result;
}
internal void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString)
{
if (_culture != null && !_culture.Equals(reader.Culture))
{
previousCulture = reader.Culture;
reader.Culture = _culture;
}
else
{
previousCulture = null;
}
if (_dateTimeZoneHandling.HasValue && reader.DateTimeZoneHandling != _dateTimeZoneHandling)
{
previousDateTimeZoneHandling = reader.DateTimeZoneHandling;
reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
else
{
previousDateTimeZoneHandling = null;
}
if (_dateParseHandling.HasValue && reader.DateParseHandling != _dateParseHandling)
{
previousDateParseHandling = reader.DateParseHandling;
reader.DateParseHandling = _dateParseHandling.GetValueOrDefault();
}
else
{
previousDateParseHandling = null;
}
if (_floatParseHandling.HasValue && reader.FloatParseHandling != _floatParseHandling)
{
previousFloatParseHandling = reader.FloatParseHandling;
reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault();
}
else
{
previousFloatParseHandling = null;
}
if (_maxDepthSet && reader.MaxDepth != _maxDepth)
{
previousMaxDepth = reader.MaxDepth;
reader.MaxDepth = _maxDepth;
}
else
{
previousMaxDepth = null;
}
if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString)
{
previousDateFormatString = reader.DateFormatString;
reader.DateFormatString = _dateFormatString;
}
else
{
previousDateFormatString = null;
}
if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver defaultContractResolver)
{
jsonTextReader.PropertyNameTable = defaultContractResolver.GetNameTable();
}
}
private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString)
{
if (previousCulture != null)
{
reader.Culture = previousCulture;
}
if (previousDateTimeZoneHandling.HasValue)
{
reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
}
if (previousDateParseHandling.HasValue)
{
reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault();
}
if (previousFloatParseHandling.HasValue)
{
reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault();
}
if (_maxDepthSet)
{
reader.MaxDepth = previousMaxDepth;
}
if (_dateFormatStringSet)
{
reader.DateFormatString = previousDateFormatString;
}
if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable != null && _contractResolver is DefaultContractResolver defaultContractResolver && jsonTextReader.PropertyNameTable == defaultContractResolver.GetNameTable())
{
jsonTextReader.PropertyNameTable = null;
}
}
public void Serialize(TextWriter textWriter, object? value)
{
Serialize(new JsonTextWriter(textWriter), value);
}
public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
{
SerializeInternal(jsonWriter, value, objectType);
}
public void Serialize(TextWriter textWriter, object? value, Type objectType)
{
Serialize(new JsonTextWriter(textWriter), value, objectType);
}
public void Serialize(JsonWriter jsonWriter, object? value)
{
SerializeInternal(jsonWriter, value, null);
}
private TraceJsonReader CreateTraceJsonReader(JsonReader reader)
{
TraceJsonReader traceJsonReader = new TraceJsonReader(reader);
if (reader.TokenType != 0)
{
traceJsonReader.WriteCurrentToken();
}
return traceJsonReader;
}
internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType)
{
ValidationUtils.ArgumentNotNull(jsonWriter, "jsonWriter");
Formatting? formatting = null;
if (_formatting.HasValue && jsonWriter.Formatting != _formatting)
{
formatting = jsonWriter.Formatting;
jsonWriter.Formatting = _formatting.GetValueOrDefault();
}
DateFormatHandling? dateFormatHandling = null;
if (_dateFormatHandling.HasValue && jsonWriter.DateFormatHandling != _dateFormatHandling)
{
dateFormatHandling = jsonWriter.DateFormatHandling;
jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault();
}
DateTimeZoneHandling? dateTimeZoneHandling = null;
if (_dateTimeZoneHandling.HasValue && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling)
{
dateTimeZoneHandling = jsonWriter.DateTimeZoneHandling;
jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
FloatFormatHandling? floatFormatHandling = null;
if (_floatFormatHandling.HasValue && jsonWriter.FloatFormatHandling != _floatFormatHandling)
{
floatFormatHandling = jsonWriter.FloatFormatHandling;
jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault();
}
StringEscapeHandling? stringEscapeHandling = null;
if (_stringEscapeHandling.HasValue && jsonWriter.StringEscapeHandling != _stringEscapeHandling)
{
stringEscapeHandling = jsonWriter.StringEscapeHandling;
jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault();
}
CultureInfo cultureInfo = null;
if (_culture != null && !_culture.Equals(jsonWriter.Culture))
{
cultureInfo = jsonWriter.Culture;
jsonWriter.Culture = _culture;
}
string dateFormatString = null;
if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString)
{
dateFormatString = jsonWriter.DateFormatString;
jsonWriter.DateFormatString = _dateFormatString;
}
TraceJsonWriter traceJsonWriter = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? new TraceJsonWriter(jsonWriter) : null);
new JsonSerializerInternalWriter(this).Serialize(traceJsonWriter ?? jsonWriter, value, objectType);
if (traceJsonWriter != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null);
}
if (formatting.HasValue)
{
jsonWriter.Formatting = formatting.GetValueOrDefault();
}
if (dateFormatHandling.HasValue)
{
jsonWriter.DateFormatHandling = dateFormatHandling.GetValueOrDefault();
}
if (dateTimeZoneHandling.HasValue)
{
jsonWriter.DateTimeZoneHandling = dateTimeZoneHandling.GetValueOrDefault();
}
if (floatFormatHandling.HasValue)
{
jsonWriter.FloatFormatHandling = floatFormatHandling.GetValueOrDefault();
}
if (stringEscapeHandling.HasValue)
{
jsonWriter.StringEscapeHandling = stringEscapeHandling.GetValueOrDefault();
}
if (_dateFormatStringSet)
{
jsonWriter.DateFormatString = dateFormatString;
}
if (cultureInfo != null)
{
jsonWriter.Culture = cultureInfo;
}
}
internal IReferenceResolver GetReferenceResolver()
{
if (_referenceResolver == null)
{
_referenceResolver = new DefaultReferenceResolver();
}
return _referenceResolver;
}
internal JsonConverter? GetMatchingConverter(Type type)
{
return GetMatchingConverter(_converters, type);
}
internal static JsonConverter? GetMatchingConverter(IList<JsonConverter>? converters, Type objectType)
{
if (converters != null)
{
for (int i = 0; i < converters.Count; i++)
{
JsonConverter jsonConverter = converters[i];
if (jsonConverter.CanConvert(objectType))
{
return jsonConverter;
}
}
}
return null;
}
internal void OnError(Newtonsoft.Json.Serialization.ErrorEventArgs e)
{
this.Error?.Invoke(this, e);
}
}
public class JsonSerializerSettings
{
internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error;
internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore;
internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include;
internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include;
internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto;
internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None;
internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default;
internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None;
internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default;
internal static readonly StreamingContext DefaultContext;
internal const Formatting DefaultFormatting = Formatting.None;
internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat;
internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime;
internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double;
internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String;
internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default;
internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;
internal static readonly CultureInfo DefaultCulture;
internal const bool DefaultCheckAdditionalContent = false;
internal const string DefaultDateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
internal const int DefaultMaxDepth = 64;
internal Formatting? _formatting;
internal DateFormatHandling? _dateFormatHandling;
internal DateTimeZoneHandling? _dateTimeZoneHandling;
internal DateParseHandling? _dateParseHandling;
internal FloatFormatHandling? _floatFormatHandling;
internal FloatParseHandling? _floatParseHandling;
internal StringEscapeHandling? _stringEscapeHandling;
internal CultureInfo? _culture;
internal bool? _checkAdditionalContent;
internal int? _maxDepth;
internal bool _maxDepthSet;
internal string? _dateFormatString;
internal bool _dateFormatStringSet;
internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal PreserveReferencesHandling? _preserveReferencesHandling;
internal NullValueHandling? _nullValueHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal MissingMemberHandling? _missingMemberHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal StreamingContext? _context;
internal ConstructorHandling? _constructorHandling;
internal TypeNameHandling? _typeNameHandling;
internal MetadataPropertyHandling? _metadataPropertyHandling;
public ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling.GetValueOrDefault();
}
set
{
_referenceLoopHandling = value;
}
}
public MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling.GetValueOrDefault();
}
set
{
_missingMemberHandling = value;
}
}
public ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling.GetValueOrDefault();
}
set
{
_objectCreationHandling = value;
}
}
public NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling.GetValueOrDefault();
}
set
{
_nullValueHandling = value;
}
}
public DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling.GetValueOrDefault();
}
set
{
_defaultValueHandling = value;
}
}
public IList<JsonConverter> Converters { get; set; }
public PreserveReferencesHandling PreserveReferencesHandling
{
get
{
return _preserveReferencesHandling.GetValueOrDefault();
}
set
{
_preserveReferencesHandling = value;
}
}
public TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling.GetValueOrDefault();
}
set
{using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using GameConsole;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Microsoft.Data.Sqlite;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using SQLitePCL;
using TMPro;
using ULTRASTATS.Capture;
using ULTRASTATS.Core;
using ULTRASTATS.Legacy;
using ULTRASTATS.Patches;
using ULTRASTATS.Queries;
using ULTRASTATS.Storage;
using ULTRASTATS.UI;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ULTRASTATS")]
[assembly: AssemblyConfiguration("Package")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5ea8e60157e0ecbfb2ce3cec5474b8c8a6684e42")]
[assembly: AssemblyProduct("ULTRASTATS")]
[assembly: AssemblyTitle("ULTRASTATS")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ULTRASTATS
{
internal static class BepInExLogs_US
{
private static bool DebugEnabled => Plugin.DebugLoggingEnabled;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ModLoaded()
{
Plugin.Log.LogInfo((object)"[ULTRASTATS] : Mod loaded");
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Queue(string message)
{
Plugin.Log.LogInfo((object)("[Queue] : " + message));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void QueueCleared()
{
Queue("Queue has been cleared!");
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void QueueAppended(long id, string path)
{
Queue($"Run {id} has been appended to {path}");
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Debug(string message)
{
if (DebugEnabled)
{
Plugin.Log.LogInfo((object)("[Debug] : " + message));
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Debug(Func<string> messageFactory)
{
if (DebugEnabled)
{
Plugin.Log.LogInfo((object)("[Debug] : " + messageFactory()));
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Warn(string message)
{
Plugin.Log.LogWarning((object)("[ULTRASTATS] : " + message));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Error(string message)
{
Plugin.Log.LogError((object)("[ULTRASTATS] : " + message));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Error(string context, Exception ex)
{
Plugin.Log.LogError((object)$"[ULTRASTATS] : {context}: {ex}");
}
}
[BepInProcess("ULTRAKILL.exe")]
[BepInPlugin("atom.ultrastats", "ULTRASTATS", "0.1.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
internal enum MainMenuButtonCornerOption
{
BottomRight,
BottomLeft,
TopRight,
TopLeft
}
internal enum DefaultMainMenuTabOption
{
Info,
Stats,
Plots
}
public const string ModGuid = "atom.ultrastats";
public const string ModName = "ULTRASTATS";
public const string ModVer = "0.1.3";
private Harmony? _harmony;
private bool _lifecycleHooksRegistered;
internal static Plugin Instance { get; private set; }
internal static ManualLogSource Log { get; private set; }
internal static UltraStatsConfig Config { get; private set; }
internal static string DataFolderPath => UltraStatsPaths.DataFolderPath;
internal static string DataFolderParentPath => UltraStatsPaths.DataFolderParentPath;
internal static bool DebugLoggingEnabled => Config?.EnableDebugLogging ?? false;
internal static bool EndscreenDiscardEnabled => Config?.EnableEndscreenDiscard ?? false;
internal static KeyCode EndscreenDiscardKey => (KeyCode)(((??)Config?.DiscardPendingRunKey) ?? 127);
internal static bool CampaignLoggingEnabled => Config?.EnableCampaignLogging ?? true;
internal static bool CybergrindLoggingEnabled => Config?.EnableCybergrindLogging ?? true;
internal static bool CustomLevelLoggingEnabled
{
get
{
if (AngryLevelLoaderInstalled)
{
return Config?.EnableCustomLevelLogging ?? true;
}
return false;
}
}
internal static bool AngryLevelLoaderInstalled => CustomLevelMetadataResolver.AngryAvailable;
internal static MainMenuButtonCornerOption MainMenuButtonCorner => (MainMenuButtonCornerOption)(Config?.MainMenuButtonCorner ?? ULTRASTATS.Core.MainMenuButtonCorner.BottomRight);
internal static DefaultMainMenuTabOption DefaultMainMenuTab => (DefaultMainMenuTabOption)(Config?.DefaultTab ?? MainMenuDefaultTab.Stats);
internal static RunFilterSortDirection NewColumnFirstClickSortDirection => Config?.NewColumnFirstClickSortDirection ?? RunFilterSortDirection.Ascending;
internal static AngryBundleSortMode AngryBundleSortMode => Config?.AngryBundleSortMode ?? AngryBundleSortMode.Alphabetical;
internal static bool ShowLegacyTransitionNotice => Config?.ShowLegacyTransitionNotice ?? true;
internal static bool HasSeenFreshInstallWelcome => File.Exists(UltraStatsPaths.FreshInstallWelcomeSeenMarkerPath);
private void Awake()
{
//IL_027d: Unknown result type (might be due to invalid IL or missing references)
//IL_0287: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
Config = new UltraStatsConfig();
Config.BuildUI();
UltraStatsStartupNoticeController.CaptureStartupState();
BepInExLogs_US.ModLoaded();
BepInExLogs_US.Debug(() => "Data folder parent = " + DataFolderParentPath);
BepInExLogs_US.Debug(() => "Data folder = " + DataFolderPath);
BepInExLogs_US.Debug(() => $"Campaign logging enabled = {CampaignLoggingEnabled}");
BepInExLogs_US.Debug(() => $"Cybergrind logging enabled = {CybergrindLoggingEnabled}");
BepInExLogs_US.Debug(() => $"Custom level logging enabled = {CustomLevelLoggingEnabled}");
BepInExLogs_US.Debug(() => $"Angry Level Loader available = {AngryLevelLoaderInstalled}");
BepInExLogs_US.Debug(() => $"Main menu button corner = {MainMenuButtonCorner}");
BepInExLogs_US.Debug(() => $"Main menu default tab = {DefaultMainMenuTab}");
BepInExLogs_US.Debug(() => $"New column first-click sort = {NewColumnFirstClickSortDirection}");
BepInExLogs_US.Debug(() => $"Angry bundle sort mode = {AngryBundleSortMode}");
BepInExLogs_US.Debug(() => $"Show legacy transition notice = {ShowLegacyTransitionNotice}");
BepInExLogs_US.Debug(() => $"Has seen fresh install welcome = {HasSeenFreshInstallWelcome}");
BepInExLogs_US.Debug(() => (!Chainloader.PluginInfos.ContainsKey("com.eternalUnion.angryLevelLoader")) ? "Angry Level Loader is not loaded." : "Angry Level Loader is loaded.");
if (!AngryLevelLoaderInstalled)
{
BepInExLogs_US.Warn("Angry Level Loader not found. Custom level logging is disabled.");
}
try
{
UltraStatsBootstrap.Initialize();
}
catch (Exception ex)
{
BepInExLogs_US.Error("SQLite bootstrap failed", ex);
return;
}
Application.quitting += OnAppQuitting;
SceneManager.activeSceneChanged += OnActiveSceneChanged;
_lifecycleHooksRegistered = true;
_harmony = new Harmony("atom.ultrastats");
_harmony.PatchAll();
MainMenuButton_US.Init();
BepInExLogs_US.Debug("Harmony patches applied.");
}
private void OnDestroy()
{
try
{
if (_lifecycleHooksRegistered)
{
SceneManager.activeSceneChanged -= OnActiveSceneChanged;
Application.quitting -= OnAppQuitting;
_lifecycleHooksRegistered = false;
}
MainMenuButton_US.Shutdown();
FlushPendingRuns("Plugin.OnDestroy");
UltraStatsBootstrap.Shutdown();
}
finally
{
Harmony? harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
}
private static void OnAppQuitting()
{
FlushPendingRuns("Application.quitting");
}
private static void OnActiveSceneChanged(Scene oldScene, Scene newScene)
{
FlushPendingRuns("SceneManager.activeSceneChanged");
}
private static void FlushPendingRuns(string reason)
{
UltraStatsBootstrap.TryCommitActiveRun(reason);
UltraStatsBootstrap.FlushPendingRuns(reason);
}
internal static void MarkFreshInstallWelcomeSeen()
{
if (HasSeenFreshInstallWelcome)
{
return;
}
try
{
Directory.CreateDirectory(UltraStatsPaths.InternalStateDirectory);
File.WriteAllText(UltraStatsPaths.FreshInstallWelcomeSeenMarkerPath, DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString());
}
catch (Exception ex)
{
Log.LogWarning((object)("[ULTRASTATS] Could not persist fresh install welcome state: " + ex.Message));
}
}
}
internal readonly struct FilterCycleLabelContent
{
public string Text { get; }
public bool IsRichText { get; }
public Color? Color { get; }
private FilterCycleLabelContent(string text, bool isRichText, Color? color)
{
Text = text ?? string.Empty;
IsRichText = isRichText;
Color = color;
}
public static FilterCycleLabelContent Plain(string text, Color? color = null)
{
return new FilterCycleLabelContent(text, isRichText: false, color);
}
public static FilterCycleLabelContent Rich(string richText)
{
return new FilterCycleLabelContent(richText, isRichText: true, null);
}
public string ToDisplayText()
{
if (string.IsNullOrEmpty(Text))
{
return string.Empty;
}
if (IsRichText)
{
return Text;
}
return UltraStatsRichCycleButton.WrapColor(UltraStatsRichCycleButton.EscapeRichText(Text), Color);
}
}
internal static class FilterBooleanLabelPresets
{
public static FilterCycleLabelContent CheatsUsed => FilterCycleLabelContent.Rich("<color=#44FF45>CHEATS USED</color>");
public static FilterCycleLabelContent MajorAssists => FilterCycleLabelContent.Rich("<color=#4B98E6>MAJOR ASSISTS</color>");
public static FilterCycleLabelContent Challenge => FilterCycleLabelContent.Rich("<color=#FFAE00>CHALLENGE</color>");
public static FilterCycleLabelContent NoDamage => FilterCycleLabelContent.Rich("<color=orange>NO DAMAGE</color>");
public static FilterCycleLabelContent StrayModeSaveFile => FilterRichTextLabels.StrayModeSaveFile;
public static FilterCycleLabelContent MasqueradeDivinitySaveFile => FilterRichTextLabels.MasqueradeDivinitySaveFile;
public static FilterCycleLabelContent FentoKill => FilterCycleLabelContent.Rich("<color=#FF0000>FENTOKILL</color>");
public static FilterCycleLabelContent BillionNemesis => FilterCycleLabelContent.Rich("<color=#FF00FF>BILLION NEMESIS</color>");
public static FilterCycleLabelContent ForceRadiance => FilterCycleLabelContent.Rich(FlagRichTextFormatter.FormatForceRadianceText("FORCERADIANCE"));
public static FilterCycleLabelContent ForceSand => FilterCycleLabelContent.Rich(FlagRichTextFormatter.FormatForceSandText("FORCESAND"));
}
internal readonly struct FilterCycleDisplayState
{
public string ValueText { get; }
public Color? ValueColor { get; }
public FilterCycleLabelContent Label { get; }
public FilterCycleDisplayState(string valueText, Color? valueColor, FilterCycleLabelContent label)
{
ValueText = valueText ?? string.Empty;
ValueColor = valueColor;
Label = label;
}
}
internal static class FilterCycleButtons
{
private const string NeutralTriStateSymbol = "*";
private static readonly Color DefaultIncludeColor = new Color(0.33f, 0.9f, 0.33f, 1f);
private static readonly Color DefaultExcludeColor = new Color(0.92f, 0.24f, 0.24f, 1f);
public static UltraStatsFilterTriStateButton CreateTriStateButton(RectTransform parent, Transform styleRoot, string name, FilterCycleLabelContent label, Color? neutralValueColor = null, Color? includeValueColor = null, Color? excludeValueColor = null, float height = 34f)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
UltraStatsRichCycleButton ultraStatsRichCycleButton = CreateSequenceButton(parent, styleRoot, name, new FilterCycleDisplayState[3]
{
new FilterCycleDisplayState("*", neutralValueColor, label),
new FilterCycleDisplayState("+", (Color)(((??)includeValueColor) ?? DefaultIncludeColor), label),
new FilterCycleDisplayState("-", (Color)(((??)excludeValueColor) ?? DefaultExcludeColor), label)
}, height);
UltraStatsFilterTriStateButton ultraStatsFilterTriStateButton = ((Component)ultraStatsRichCycleButton).gameObject.AddComponent<UltraStatsFilterTriStateButton>();
ultraStatsFilterTriStateButton.Initialize(ultraStatsRichCycleButton);
return ultraStatsFilterTriStateButton;
}
public static UltraStatsRichCycleButton CreateSequenceButton(RectTransform parent, Transform styleRoot, string name, FilterCycleDisplayState[] states, float height = 34f)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)parent == (Object)null)
{
throw new ArgumentNullException("parent");
}
if ((Object)(object)styleRoot == (Object)null)
{
throw new ArgumentNullException("styleRoot");
}
if (states == null || states.Length == 0)
{
throw new ArgumentException("At least one cycle state is required.", "states");
}
UltraStatsVanillaButtonState state;
Button val = MainMenuButton_US.CreateVanillaStyledButton((Transform)(object)parent, styleRoot, name, new Vector2(220f, height), UltraStatsRichCycleButton.BuildButtonText(states[0]), null, out state);
LayoutElement obj = ((Component)val).gameObject.GetComponent<LayoutElement>() ?? ((Component)val).gameObject.AddComponent<LayoutElement>();
obj.preferredHeight = height;
obj.minHeight = height;
obj.preferredWidth = 0f;
obj.minWidth = 0f;
obj.flexibleWidth = 1f;
ConfigureButtonLabelVisuals(val);
UltraStatsRichCycleButton ultraStatsRichCycleButton = ((Component)val).gameObject.AddComponent<UltraStatsRichCycleButton>();
ultraStatsRichCycleButton.Initialize(val, states, 0);
return ultraStatsRichCycleButton;
}
private static void ConfigureButtonLabelVisuals(Button button)
{
TMP_Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
foreach (TMP_Text obj in componentsInChildren)
{
obj.richText = true;
obj.enableAutoSizing = false;
obj.fontSize = 16f;
obj.fontStyle = (FontStyles)1;
obj.alignment = (TextAlignmentOptions)514;
obj.enableWordWrapping = false;
obj.overflowMode = (TextOverflowModes)0;
}
Text[] componentsInChildren2 = ((Component)button).GetComponentsInChildren<Text>(true);
foreach (Text obj2 in componentsInChildren2)
{
obj2.supportRichText = true;
obj2.resizeTextForBestFit = false;
obj2.fontSize = 16;
obj2.fontStyle = (FontStyle)1;
obj2.alignment = (TextAnchor)4;
obj2.horizontalOverflow = (HorizontalWrapMode)1;
}
}
}
internal sealed class UltraStatsRichCycleButton : MonoBehaviour
{
private Button _button;
private FilterCycleDisplayState[] _states = Array.Empty<FilterCycleDisplayState>();
private TMP_Text[] _tmpTexts = Array.Empty<TMP_Text>();
private Text[] _legacyTexts = Array.Empty<Text>();
private int _stateIndex;
public int StateIndex => _stateIndex;
public event Action<int>? OnStateIndexChanged;
public void Initialize(Button button, FilterCycleDisplayState[] states, int initialStateIndex)
{
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Expected O, but got Unknown
if ((Object)(object)button == (Object)null)
{
throw new ArgumentNullException("button");
}
if (states == null || states.Length == 0)
{
throw new ArgumentException("At least one cycle state is required.", "states");
}
_button = button;
_states = new FilterCycleDisplayState[states.Length];
Array.Copy(states, _states, states.Length);
_tmpTexts = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
_legacyTexts = ((Component)button).GetComponentsInChildren<Text>(true);
_stateIndex = Mathf.Clamp(initialStateIndex, 0, _states.Length - 1);
TMP_Text[] tmpTexts = _tmpTexts;
for (int i = 0; i < tmpTexts.Length; i++)
{
tmpTexts[i].richText = true;
}
Text[] legacyTexts = _legacyTexts;
for (int i = 0; i < legacyTexts.Length; i++)
{
legacyTexts[i].supportRichText = true;
}
((UnityEvent)_button.onClick).AddListener(new UnityAction(AdvanceState));
RefreshLabel();
}
public void SetStateIndexWithoutNotify(int index)
{
if (_states.Length != 0)
{
_stateIndex = Mathf.Clamp(index, 0, _states.Length - 1);
RefreshLabel();
}
}
private void OnDestroy()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
if ((Object)(object)_button != (Object)null)
{
((UnityEvent)_button.onClick).RemoveListener(new UnityAction(AdvanceState));
}
}
private void AdvanceState()
{
if (_states.Length != 0)
{
_stateIndex = (_stateIndex + 1) % _states.Length;
RefreshLabel();
this.OnStateIndexChanged?.Invoke(_stateIndex);
}
}
private void RefreshLabel()
{
if (_states.Length != 0)
{
string text = BuildButtonText(_states[_stateIndex]);
TMP_Text[] tmpTexts = _tmpTexts;
for (int i = 0; i < tmpTexts.Length; i++)
{
tmpTexts[i].text = text;
}
Text[] legacyTexts = _legacyTexts;
for (int i = 0; i < legacyTexts.Length; i++)
{
legacyTexts[i].text = text;
}
}
}
public static string BuildButtonText(FilterCycleDisplayState state)
{
string text = WrapColor(EscapeRichText(state.ValueText), state.ValueColor);
string text2 = state.Label.ToDisplayText();
if (!string.IsNullOrEmpty(text2))
{
return text + " " + text2;
}
return text;
}
internal static string WrapColor(string value, Color? color)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
if (string.IsNullOrEmpty(value) || !color.HasValue)
{
return value;
}
return "<color=#" + ColorUtility.ToHtmlStringRGBA(color.Value) + ">" + value + "</color>";
}
internal static string EscapeRichText(string value)
{
if (string.IsNullOrEmpty(value))
{
return string.Empty;
}
return value.Replace("&", "&").Replace("<", "<").Replace(">", ">");
}
}
internal sealed class UltraStatsFilterTriStateButton : MonoBehaviour
{
private UltraStatsRichCycleButton _cycleButton;
public RunFilterTriState Value => (RunFilterTriState)Mathf.Clamp(_cycleButton?.StateIndex ?? 0, 0, 2);
public event Action<RunFilterTriState>? OnValueChanged;
public void Initialize(UltraStatsRichCycleButton cycleButton)
{
_cycleButton = cycleButton ?? throw new ArgumentNullException("cycleButton");
_cycleButton.OnStateIndexChanged += HandleCycleStateChanged;
}
public void SetValueWithoutNotify(RunFilterTriState value)
{
_cycleButton?.SetStateIndexWithoutNotify(Mathf.Clamp((int)value, 0, 2));
}
private void OnDestroy()
{
if ((Object)(object)_cycleButton != (Object)null)
{
_cycleButton.OnStateIndexChanged -= HandleCycleStateChanged;
}
}
private void HandleCycleStateChanged(int stateIndex)
{
this.OnValueChanged?.Invoke((RunFilterTriState)Mathf.Clamp(stateIndex, 0, 2));
}
}
internal static class FilterRichTextLabels
{
public static FilterCycleLabelContent StrayModeSaveFile => FilterCycleLabelContent.Rich("<color=#80bfff>ST</color><color=#ffa7ff>RA</color>Y<color=#ffa7ff>MO</color><color=#80bfff>DE</color>");
public static FilterCycleLabelContent MasqueradeDivinitySaveFile => FilterCycleLabelContent.Rich("<color=#E1AC04>MASQUERADE DIVINITY</color>");
public static FilterCycleLabelContent GetSaveFileLabel(int saveSlot)
{
return saveSlot switch
{
1015064007 => StrayModeSaveFile,
11 => MasqueradeDivinitySaveFile,
_ => FilterCycleLabelContent.Plain($"Save {saveSlot}"),
};
}
public static string GetSaveFileDisplayText(int saveSlot)
{
return GetSaveFileLabel(saveSlot).ToDisplayText();
}
}
internal static class FilterWindowLayout
{
public const float ColumnStackSpacing = 5f;
public const float ControlRowSpacing = 10f;
public const float CompactRowSpacing = 6f;
public const float CompactSectionGapHeight = 6f;
public const float SectionGapHeight = 10f;
public const float LowerSectionSpacing = 6f;
public const float BooleanSectionSpacing = 8f;
public const float DividerThickness = 1f;
public const float DividerTopPadding = 0f;
public const float DividerBottomPadding = 0f;
public const float LowerSectionDividerTopPadding = 11f;
public const float LowerSectionDividerBottomPadding = 10f;
public const float CenterDividerWidth = 2f;
public const float SectionLabelHeight = 15f;
public const float InlineRowHeight = 30f;
public const float InlineLabelWidth = 120f;
public const float TriStateButtonHeight = 30f;
public static RectTransform CreateVerticalSection(Transform parent, string name, float spacing = 6f)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Expected O, but got Unknown
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name, new Type[4]
{
typeof(RectTransform),
typeof(VerticalLayoutGroup),
typeof(ContentSizeFitter),
typeof(LayoutElement)
});
val.transform.SetParent(parent, false);
LayoutElement component = val.GetComponent<LayoutElement>();
component.minHeight = 0f;
component.flexibleHeight = 0f;
VerticalLayoutGroup component2 = val.GetComponent<VerticalLayoutGroup>();
((LayoutGroup)component2).padding = new RectOffset(0, 0, 0, 0);
((HorizontalOrVerticalLayoutGroup)component2).spacing = spacing;
((LayoutGroup)component2).childAlignment = (TextAnchor)0;
((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = true;
((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true;
((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = true;
((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
ContentSizeFitter component3 = val.GetComponent<ContentSizeFitter>();
component3.horizontalFit = (FitMode)0;
component3.verticalFit = (FitMode)2;
return val.GetComponent<RectTransform>();
}
public static GameObject CreateSpacer(Transform parent, string name, float height)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
GameObject val = new GameObject(name, new Type[2]
{
typeof(RectTransform),
typeof(LayoutElement)
});
val.transform.SetParent(parent, false);
LayoutElement component = val.GetComponent<LayoutElement>();
component.preferredHeight = height;
component.minHeight = height;
component.flexibleHeight = 0f;
return val;
}
public static RectTransform CreateDivider(Transform parent, string name, Color color, float topPadding = 0f, float bottomPadding = 0f, float thickness = 1f)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name, new Type[2]
{
typeof(RectTransform),
typeof(LayoutElement)
});
val.transform.SetParent(parent, false);
LayoutElement component = val.GetComponent<LayoutElement>();
float num = Mathf.Max(1f, thickness);
float minHeight = (component.preferredHeight = Mathf.Max(0f, topPadding) + num + Mathf.Max(0f, bottomPadding));
component.minHeight = minHeight;
component.flexibleHeight = 0f;
GameObject val2 = new GameObject(name + "Line", new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val2.transform.SetParent(val.transform, false);
Image component2 = val2.GetComponent<Image>();
((Graphic)component2).color = color;
((Graphic)component2).raycastTarget = false;
RectTransform component3 = val2.GetComponent<RectTransform>();
component3.anchorMin = new Vector2(0f, 1f);
component3.anchorMax = new Vector2(1f, 1f);
component3.pivot = new Vector2(0.5f, 1f);
component3.sizeDelta = new Vector2(0f, num);
component3.anchoredPosition = new Vector2(0f, 0f - Mathf.Max(0f, topPadding));
return val.GetComponent<RectTransform>();
}
public static TextMeshProUGUI CreateTextLabel(Transform parent, Transform styleRoot, string name, string text, float fontSize, TextAlignmentOptions alignment, float preferredHeight, float preferredWidth = -1f)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name, new Type[3]
{
typeof(RectTransform),
typeof(TextMeshProUGUI),
typeof(LayoutElement)
});
val.transform.SetParent(parent, false);
LayoutElement component = val.GetComponent<LayoutElement>();
if (preferredHeight > 0f)
{
component.preferredHeight = preferredHeight;
component.minHeight = preferredHeight;
}
if (preferredWidth >= 0f)
{
component.preferredWidth = preferredWidth;
component.minWidth = preferredWidth;
component.flexibleWidth = 0f;
}
TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
((TMP_Text)component2).richText = true;
MainMenuButton_US.ApplyPanelTextStyle(styleRoot, component2);
((TMP_Text)component2).text = text ?? string.Empty;
((TMP_Text)component2).fontSize = fontSize;
((Graphic)component2).color = Color.white;
((TMP_Text)component2).alignment = alignment;
((TMP_Text)component2).enableWordWrapping = false;
((TMP_Text)component2).overflowMode = (TextOverflowModes)1;
((Graphic)component2).raycastTarget = false;
return component2;
}
}
internal static class FlagRichTextFormatter
{
private static readonly string[] ForceRadiancePalette = new string[13]
{
"#48ffff", "#c7f797", "#ffff7f", "#ffbf50", "#ffafbf", "#ff7087", "#9f70c7", "#6087cf", "#48ffff", "#c7f797",
"#ffff7f", "#ffbf50", "#ffafbf"
};
private static readonly string[] ForceSandPalette = new string[9] { "#E0AD6D", "#E29D6A", "#E49067", "#DD7A60", "#DA685B", "#EA655E", "#EB585A", "#EA4D58", "#EE4858" };
public static string FormatForceRadianceText(string text)
{
return ApplyPalette(text, ForceRadiancePalette);
}
public static string FormatForceSandText(string text)
{
return ApplyPalette(text, ForceSandPalette);
}
public static string FormatRunDateByFlags(string dateText, long flags)
{
return FormatRunDateByFlags(dateText, FlagEncoding.Has(flags, 16L), FlagEncoding.Has(flags, 32L));
}
public static string FormatRunDateByFlags(string dateText, bool forceRadianceEnabled, bool forceSandEnabled)
{
if (string.IsNullOrEmpty(dateText) || dateText == "-")
{
return dateText ?? string.Empty;
}
if (forceRadianceEnabled && forceSandEnabled)
{
int num = (dateText.Length + 1) / 2;
return ApplyPalette(dateText.Substring(0, num), ForceRadiancePalette) + ApplyPalette(dateText.Substring(num), ForceSandPalette);
}
if (forceRadianceEnabled)
{
return ApplyPalette(dateText, ForceRadiancePalette);
}
if (forceSandEnabled)
{
return ApplyPalette(dateText, ForceSandPalette);
}
return dateText;
}
public static string FormatNoHitDeathsText(string deathsText, long flags)
{
if (!FlagEncoding.Has(flags, 8L) || string.IsNullOrEmpty(deathsText) || deathsText == "-")
{
return deathsText ?? string.Empty;
}
return WrapColor(deathsText, "orange");
}
private static string ApplyPalette(string text, string[] palette)
{
if (string.IsNullOrEmpty(text))
{
return string.Empty;
}
if (palette == null || palette.Length == 0)
{
return UltraStatsRichCycleButton.EscapeRichText(text);
}
StringBuilder stringBuilder = new StringBuilder(text.Length * 24);
for (int i = 0; i < text.Length; i++)
{
stringBuilder.Append("<color=");
stringBuilder.Append(palette[i % palette.Length]);
stringBuilder.Append('>');
stringBuilder.Append(UltraStatsRichCycleButton.EscapeRichText(text[i].ToString()));
stringBuilder.Append("</color>");
}
return stringBuilder.ToString();
}
private static string WrapColor(string text, string colorToken)
{
if (string.IsNullOrEmpty(text))
{
return string.Empty;
}
return "<color=" + colorToken + ">" + UltraStatsRichCycleButton.EscapeRichText(text) + "</color>";
}
}
internal enum StartupNoticeType
{
None,
FreshInstallWelcome,
LegacyTransition
}
internal static class UltraStatsStartupNoticeController
{
private readonly struct StartupNoticeCopy
{
public string Title { get; }
public string Body { get; }
public StartupNoticeCopy(string title, string body)
{
Title = title;
Body = body;
}
}
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static Func<string> <>9__17_0;
public static UnityAction <>9__20_0;
internal string <CaptureStartupState>b__17_0()
{
return $"Startup notices captured: hasDbAtStartup={_hadDatabaseAtStartup}, hasLegacyAtStartup={_hadLegacyDataAtStartup}";
}
internal void <BuildNoticeOverlay>b__20_0()
{
}
}
private const string OverlayObjectName = "ULTRASTATS_StartupNoticeOverlay";
private const float WindowWidth = 760f;
private const float WindowHeight = 344f;
private const float WindowInset = 18f;
private const float TitleTopInset = -44f;
private const float TitleBottomInset = -12f;
private const float DividerTopInset = -54f;
private const float DividerBottomInset = -52f;
private const float BodyTopInset = -66f;
private const float BodyBottomInset = 18f;
private const float CloseButtonTopOffset = 18f;
private static readonly StartupNoticeCopy FreshInstallCopy = new StartupNoticeCopy("ULTRASTATS NOTICE", "Dear User,\nWelcome to ULTRASTATS, the stattracker for ULTRAKILL. If you have any issues with ULTRASTATS please DM me on discord (atomsmasher_1586).\nThis mod is currently still early in development with much more planned to come so stay tuned! To see your saved runs click on the button in the bottom right (you can change where the button appears in Plugin Configurator).\n\nP.S. If you see this and are an old user, it's because ULTRASTATS can't find your run database.");
private static readonly StartupNoticeCopy LegacyTransitionCopy = new StartupNoticeCopy("ULTRASTATS NOTICE", "Dear User,\nWelcome to ULTRASTATS v0.1.2!\nA lot has changed with this update, mainly switching the way ULTRASTATS stores data. Now your runs are all stored in a database file (ultrastats.db) instead of in .jsonl files. If everything looks correct in the stats chart then you are free to delete the old (now unused) Difficulty_ folders in your ULTRASTATS data folder.\n\nTHIS MESSAGE WILL REAPPEAR UNTIL THOSE OLD FOLDERS ARE DELETED OR STARTUP NOTICES ARE DISABLED IN PLUGIN CONFIGURATOR.\n\nIf something goes wrong with conversion from .jsonl to .db delete ultrastats.db to reattempt conversion. If that still doesn't work DM me on discord (atomsmasher_1586).");
private static bool _startupStateCaptured;
private static bool _hadDatabaseAtStartup;
private static bool _hadLegacyDataAtStartup;
private static bool _noticeHandledThisSession;
public static void CaptureStartupState()
{
if (!_startupStateCaptured)
{
_hadDatabaseAtStartup = File.Exists(UltraStatsPaths.DatabasePath);
_hadLegacyDataAtStartup = LegacyBootstrapImporter.HasLegacyData(UltraStatsPaths.LegacyJsonlRoot);
_startupStateCaptured = true;
BepInExLogs_US.Debug(() => $"Startup notices captured: hasDbAtStartup={_hadDatabaseAtStartup}, hasLegacyAtStartup={_hadLegacyDataAtStartup}");
}
}
public static void TryShowIfNeeded(Transform mainMenu)
{
if ((Object)(object)mainMenu == (Object)null || _noticeHandledThisSession)
{
return;
}
CaptureStartupState();
_noticeHandledThisSession = true;
if (!((Object)(object)mainMenu.Find("ULTRASTATS_StartupNoticeOverlay") != (Object)null))
{
StartupNoticeType startupNoticeType = DecideNoticeType();
if (startupNoticeType != 0)
{
BuildNoticeOverlay(mainMenu, startupNoticeType);
}
}
}
private static StartupNoticeType DecideNoticeType()
{
bool flag = File.Exists(UltraStatsPaths.DatabasePath);
if (_hadLegacyDataAtStartup && flag && Plugin.ShowLegacyTransitionNotice)
{
return StartupNoticeType.LegacyTransition;
}
if (!_hadDatabaseAtStartup && !_hadLegacyDataAtStartup && !Plugin.HasSeenFreshInstallWelcome)
{
return StartupNoticeType.FreshInstallWelcome;
}
return StartupNoticeType.None;
}
private static void BuildNoticeOverlay(Transform mainMenu, StartupNoticeType noticeType)
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Expected O, but got Unknown
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Expected O, but got Unknown
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_0197: Unknown result type (might be due to invalid IL or missing references)
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_021b: Unknown result type (might be due to invalid IL or missing references)
//IL_0230: Unknown result type (might be due to invalid IL or missing references)
//IL_0245: Unknown result type (might be due to invalid IL or missing references)
//IL_025a: Unknown result type (might be due to invalid IL or missing references)
//IL_026e: Unknown result type (might be due to invalid IL or missing references)
//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
//IL_02af: Unknown result type (might be due to invalid IL or missing references)
//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0311: Unknown result type (might be due to invalid IL or missing references)
//IL_0325: Unknown result type (might be due to invalid IL or missing references)
//IL_0335: Unknown result type (might be due to invalid IL or missing references)
//IL_0379: Unknown result type (might be due to invalid IL or missing references)
//IL_038e: Unknown result type (might be due to invalid IL or missing references)
//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
//IL_03da: Unknown result type (might be due to invalid IL or missing references)
//IL_0406: Unknown result type (might be due to invalid IL or missing references)
//IL_041b: Unknown result type (might be due to invalid IL or missing references)
//IL_0430: Unknown result type (might be due to invalid IL or missing references)
//IL_0444: Unknown result type (might be due to invalid IL or missing references)
//IL_045a: Unknown result type (might be due to invalid IL or missing references)
//IL_0464: Expected O, but got Unknown
//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Expected O, but got Unknown
GameObject val = new GameObject("ULTRASTATS_StartupNoticeOverlay", new Type[7]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image),
typeof(Button),
typeof(Canvas),
typeof(GraphicRaycaster),
typeof(UltraStatsStartupNoticeModal)
});
val.transform.SetParent(mainMenu, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = Vector2.zero;
component.anchorMax = Vector2.one;
component.offsetMin = Vector2.zero;
component.offsetMax = Vector2.zero;
Canvas component2 = val.GetComponent<Canvas>();
component2.overrideSorting = true;
component2.sortingOrder = 950;
Image component3 = val.GetComponent<Image>();
((Graphic)component3).color = new Color(0f, 0f, 0f, 0.66f);
((Graphic)component3).raycastTarget = true;
UltraStatsStartupNoticeModal component4 = val.GetComponent<UltraStatsStartupNoticeModal>();
component4.Initialize(noticeType);
Button component5 = val.GetComponent<Button>();
((Selectable)component5).transition = (Transition)0;
((UnityEvent)component5.onClick).AddListener(new UnityAction(component4.Dismiss));
GameObject val2 = MainMenuButton_US.CreateStandardWindowSurface(val.transform, "StartupNoticeWindow", new Vector2(760f, 344f), new Color(0f, 0f, 0f, 0.97f));
RectTransform component6 = val2.GetComponent<RectTransform>();
component6.anchorMin = new Vector2(0.5f, 0.5f);
component6.anchorMax = new Vector2(0.5f, 0.5f);
component6.pivot = new Vector2(0.5f, 0.5f);
component6.anchoredPosition = Vector2.zero;
Button obj = val2.AddComponent<Button>();
((Selectable)obj).transition = (Transition)0;
ButtonClickedEvent onClick = obj.onClick;
object obj2 = <>c.<>9__20_0;
if (obj2 == null)
{
UnityAction val3 = delegate
{
};
<>c.<>9__20_0 = val3;
obj2 = (object)val3;
}
((UnityEvent)onClick).AddListener((UnityAction)obj2);
StartupNoticeCopy copy = GetCopy(noticeType);
RectTransform rectTransform = ((TMP_Text)CreateText(val2.transform, "Title", copy.Title, 28f, (FontStyles)1, (TextAlignmentOptions)257, mainMenu)).rectTransform;
rectTransform.anchorMin = new Vector2(0f, 1f);
rectTransform.anchorMax = new Vector2(1f, 1f);
rectTransform.pivot = new Vector2(0f, 1f);
rectTransform.offsetMin = new Vector2(18f, -44f);
rectTransform.offsetMax = new Vector2(-72f, -12f);
GameObject val4 = new GameObject("Divider", new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val4.transform.SetParent(val2.transform, false);
RectTransform component7 = val4.GetComponent<RectTransform>();
component7.anchorMin = new Vector2(0f, 1f);
component7.anchorMax = new Vector2(1f, 1f);
component7.pivot = new Vector2(0.5f, 1f);
component7.offsetMin = new Vector2(18f, -54f);
component7.offsetMax = new Vector2(-18f, -52f);
Image component8 = val4.GetComponent<Image>();
((Graphic)component8).color = Color.white;
((Graphic)component8).raycastTarget = false;
TextMeshProUGUI obj3 = CreateText(val2.transform, "Body", copy.Body, 18f, (FontStyles)0, (TextAlignmentOptions)257, mainMenu);
RectTransform rectTransform2 = ((TMP_Text)obj3).rectTransform;
rectTransform2.anchorMin = new Vector2(0f, 0f);
rectTransform2.anchorMax = new Vector2(1f, 1f);
rectTransform2.offsetMin = new Vector2(18f, 18f);
rectTransform2.offsetMax = new Vector2(-18f, -66f);
((TMP_Text)obj3).lineSpacing = 3f;
((TMP_Text)obj3).enableWordWrapping = true;
((TMP_Text)obj3).overflowMode = (TextOverflowModes)0;
((TMP_Text)obj3).margin = Vector4.zero;
Button obj4 = MainMenuButton_US.CreateWindowCloseButton(val2.transform, mainMenu);
RectTransform component9 = ((Component)obj4).GetComponent<RectTransform>();
component9.anchorMin = new Vector2(1f, 1f);
component9.anchorMax = new Vector2(1f, 1f);
component9.pivot = new Vector2(1f, 1f);
component9.anchoredPosition = new Vector2(0f, 18f);
((UnityEvent)obj4.onClick).AddListener(new UnityAction(component4.Dismiss));
val.transform.SetAsLastSibling();
}
private static StartupNoticeCopy GetCopy(StartupNoticeType noticeType)
{
if (noticeType == StartupNoticeType.LegacyTransition)
{
return LegacyTransitionCopy;
}
return FreshInstallCopy;
}
private static TextMeshProUGUI CreateText(Transform parent, string name, string text, float fontSize, FontStyles fontStyle, TextAlignmentOptions alignment, Transform styleRoot)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name, new Type[2]
{
typeof(RectTransform),
typeof(TextMeshProUGUI)
});
val.transform.SetParent(parent, false);
TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
MainMenuButton_US.ApplyPanelTextStyle(styleRoot, component);
((TMP_Text)component).text = text;
((TMP_Text)component).fontSize = fontSize;
((TMP_Text)component).fontStyle = fontStyle;
((TMP_Text)component).alignment = alignment;
((Graphic)component).color = Color.white;
((Graphic)component).raycastTarget = false;
((TMP_Text)component).margin = Vector4.zero;
return component;
}
}
internal sealed class UltraStatsStartupNoticeModal : MonoBehaviour
{
private StartupNoticeType _noticeType;
private bool _dismissed;
public void Initialize(StartupNoticeType noticeType)
{
_noticeType = noticeType;
}
private void Update()
{
if (!_dismissed && ((Component)this).gameObject.activeInHierarchy && Input.GetKeyDown((KeyCode)27))
{
Dismiss();
}
}
public void Dismiss()
{
if (!_dismissed)
{
_dismissed = true;
if (_noticeType == StartupNoticeType.FreshInstallWelcome)
{
Plugin.MarkFreshInstallWelcomeSeen();
}
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
}
internal static class InfoTab_US
{
private const string InfoTextBeforeImage = "\r\nFor any issues, suggestions, bugs, or complaints you have about ULTRASTATS, please contact me through discord. I'd prefer DMs but I am also active on the New Blood Discord server's ultrakill-modding channel and the ULTRAKILL legacy server's ultramodding channel so you can reach me there too. I'd love to hear from you! \r\n\r\n ULTRASTATS won Mod of the Month for March 2026!!!!!! :D I'm so happy that people liked my mod enough to download it and vote for it above several other (much better if I'm being honest) mods.\r\n";
private const string InfoTextAfterImage = "I'll keep improving ULTRASTATS to the best of my ability so it wins MotY 2026 too.\r\n\r\n The next major update will implement filtering. So you can filter out runs from different save files, only display runs with a certain rank, filter out flagged runs, etc.\r\n\r\n Thanks to each and everyone of you who choose to download ULTRASTATS, it means the world to me that people want to use my silly passion project.\r\n\r\n Thanks to my fellow modders for helping me with my questions and issues.\r\n\r\n Expect the next big update within a couple weeks, probably.\r\n\r\nP.S. You can change what tab is the default through PluginConfigurator, along with some other preference settings.\r\n\r\nKnown issues:\r\n -- Stuttering when spam clicking through the endscreen.\r\n -- UI is garbage... I tried my best okay :(\r\n -- When discard on endscreen is enabled, spam clicking can cause incomplete run data to be saved.\r\nIf you find any other issues DM me on discord.\r\n";
private const float WheelPixelsPerTick = 96f;
private const float ScrollbarWidth = 18f;
private const float ViewportScrollbarInset = 20f;
public static void Build(Transform parent, Transform styleRoot)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject("InfoTabRoot", new Type[1] { typeof(RectTransform) });
val.transform.SetParent(parent, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = Vector2.zero;
component.anchorMax = Vector2.one;
component.offsetMin = Vector2.zero;
component.offsetMax = Vector2.zero;
BuildHeader(val.transform, styleRoot);
BuildScrollView(val.transform, styleRoot);
}
private static void BuildHeader(Transform parent, Transform styleRoot)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_019f: Unknown result type (might be due to invalid IL or missing references)
//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_021a: Unknown result type (might be due to invalid IL or missing references)
//IL_0253: Unknown result type (might be due to invalid IL or missing references)
//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
//IL_02df: Unknown result type (might be due to invalid IL or missing references)
//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0309: Unknown result type (might be due to invalid IL or missing references)
//IL_031d: Unknown result type (might be due to invalid IL or missing references)
//IL_034b: Unknown result type (might be due to invalid IL or missing references)
//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
//IL_040c: Unknown result type (might be due to invalid IL or missing references)
//IL_0420: Unknown result type (might be due to invalid IL or missing references)
//IL_0430: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject("Header", new Type[1] { typeof(RectTransform) });
val.transform.SetParent(parent, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = new Vector2(0f, 1f);
component.anchorMax = new Vector2(1f, 1f);
component.pivot = new Vector2(0.5f, 1f);
component.sizeDelta = new Vector2(0f, 178f);
component.anchoredPosition = Vector2.zero;
GameObject val2 = new GameObject("ModIcon", new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val2.transform.SetParent(val.transform, false);
RectTransform component2 = val2.GetComponent<RectTransform>();
component2.anchorMin = new Vector2(0f, 1f);
component2.anchorMax = new Vector2(0f, 1f);
component2.pivot = new Vector2(0f, 1f);
component2.sizeDelta = new Vector2(152f, 152f);
component2.anchoredPosition = new Vector2(0f, -2f);
Image component3 = val2.GetComponent<Image>();
component3.sprite = MainMenuButton_US.LoadSpriteFromPluginFile("icon.png");
component3.type = (Type)0;
component3.preserveAspect = true;
((Graphic)component3).color = Color.white;
((Graphic)component3).raycastTarget = false;
GameObject val3 = new GameObject("Title", new Type[2]
{
typeof(RectTransform),
typeof(TextMeshProUGUI)
});
val3.transform.SetParent(val.transform, false);
RectTransform component4 = val3.GetComponent<RectTransform>();
component4.anchorMin = new Vector2(0f, 1f);
component4.anchorMax = new Vector2(1f, 1f);
component4.pivot = new Vector2(0f, 1f);
component4.offsetMin = new Vector2(178f, -92f);
component4.offsetMax = new Vector2(12f, 0f);
TextMeshProUGUI component5 = val3.GetComponent<TextMeshProUGUI>();
MainMenuButton_US.ApplyPanelTextStyle(styleRoot, component5);
((TMP_Text)component5).text = "ULTRASTATS";
((TMP_Text)component5).fontSize = 80f;
((TMP_Text)component5).characterSpacing = 2f;
((Graphic)component5).color = Color.white;
((TMP_Text)component5).alignment = (TextAlignmentOptions)257;
((TMP_Text)component5).enableWordWrapping = false;
((TMP_Text)component5).overflowMode = (TextOverflowModes)0;
((Graphic)component5).raycastTarget = false;
GameObject val4 = new GameObject("Meta", new Type[2]
{
typeof(RectTransform),
typeof(TextMeshProUGUI)
});
val4.transform.SetParent(val.transform, false);
RectTransform component6 = val4.GetComponent<RectTransform>();
component6.anchorMin = new Vector2(0f, 1f);
component6.anchorMax = new Vector2(1f, 1f);
component6.pivot = new Vector2(0f, 1f);
component6.offsetMin = new Vector2(182f, -164f);
component6.offsetMax = new Vector2(12f, -92f);
TextMeshProUGUI component7 = val4.GetComponent<TextMeshProUGUI>();
MainMenuButton_US.ApplyPanelTextStyle(styleRoot, component7);
((TMP_Text)component7).text = "Version 0.1.3\nDiscord: atomsmasher_1586";
((TMP_Text)component7).fontSize = 28f;
((Graphic)component7).color = Color.white;
((TMP_Text)component7).lineSpacing = 6f;
((TMP_Text)component7).alignment = (TextAlignmentOptions)257;
((TMP_Text)component7).enableWordWrapping = false;
((TMP_Text)component7).overflowMode = (TextOverflowModes)0;
((Graphic)component7).raycastTarget = false;
GameObject val5 = new GameObject("Divider", new Type[2]
{
typeof(RectTransform),
typeof(Image)
});
val5.transform.SetParent(val.transform, false);
RectTransform component8 = val5.GetComponent<RectTransform>();
component8.anchorMin = new Vector2(0f, 0f);
component8.anchorMax = new Vector2(1f, 0f);
component8.pivot = new Vector2(0.5f, 0f);
component8.offsetMin = new Vector2(-38f, 0f);
component8.offsetMax = new Vector2(38f, 1f);
Image component9 = val5.GetComponent<Image>();
((Graphic)component9).color = Color.white;
((Graphic)component9).raycastTarget = false;
}
private static void BuildScrollView(Transform parent, Transform styleRoot)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Expected O, but got Unknown
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Expected O, but got Unknown
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01db: Unknown result type (might be due to invalid IL or missing references)
//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
//IL_022a: Unknown result type (might be due to invalid IL or missing references)
//IL_022f: Unknown result type (might be due to invalid IL or missing references)
//IL_0241: Unknown result type (might be due to invalid IL or missing references)
//IL_0255: Unknown result type (might be due to invalid IL or missing references)
//IL_026b: Unknown result type (might be due to invalid IL or missing references)
//IL_0281: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Unknown result type (might be due to invalid IL or missing references)
//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
//IL_0358: Unknown result type (might be due to invalid IL or missing references)
//IL_035d: Unknown result type (might be due to invalid IL or missing references)
//IL_036f: Unknown result type (might be due to invalid IL or missing references)
//IL_0383: Unknown result type (might be due to invalid IL or missing references)
//IL_0399: Unknown result type (might be due to invalid IL or missing references)
//IL_03af: Unknown result type (might be due to invalid IL or missing references)
//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
//IL_0413: Unknown result type (might be due to invalid IL or missing references)
//IL_044a: Unknown result type (might be due to invalid IL or missing references)
//IL_044f: Unknown result type (might be due to invalid IL or missing references)
//IL_0461: Unknown result type (might be due to invalid IL or missing references)
//IL_0475: Unknown result type (might be due to invalid IL or missing references)
//IL_048b: Unknown result type (might be due to invalid IL or missing references)
//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
//IL_0500: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject("InfoScrollRoot", new Type[1] { typeof(RectTransform) });
val.transform.SetParent(parent, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = new Vector2(0f, 0f);
component.anchorMax = new Vector2(1f, 1f);
component.offsetMin = new Vector2(0f, 8f);
component.offsetMax = new Vector2(0f, -184f);
GameObject val2 = new GameObject("Viewport", new Type[5]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image),
typeof(RectMask2D),
typeof(UltraStatsFixedWheelScroll)
});
val2.transform.SetParent(val.transform, false);
RectTransform component2 = val2.GetComponent<RectTransform>();
component2.anchorMin = new Vector2(0f, 0f);
component2.anchorMax = new Vector2(1f, 1f);
component2.offsetMin = Vector2.zero;
component2.offsetMax = new Vector2(-20f, 0f);
Image component3 = val2.GetComponent<Image>();
((Graphic)component3).color = new Color(1f, 1f, 1f, 0.001f);
((Graphic)component3).raycastTarget = true;
GameObject val3 = new GameObject("Content", new Type[2]
{
typeof(RectTransform),
typeof(UltraStatsInfoRichContentSizer)
});
val3.transform.SetParent(val2.transform, false);
RectTransform component4 = val3.GetComponent<RectTransform>();
component4.anchorMin = new Vector2(0f, 1f);
component4.anchorMax = new Vector2(1f, 1f);
component4.pivot = new Vector2(0.5f, 1f);
component4.anchoredPosition = Vector2.zero;
component4.sizeDelta = new Vector2(0f, 0f);
GameObject val4 = new GameObject("InfoBodyTextTop", new Type[2]
{
typeof(RectTransform),
typeof(TextMeshProUGUI)
});
val4.transform.SetParent(val3.transform, false);
RectTransform component5 = val4.GetComponent<RectTransform>();
component5.anchorMin = new Vector2(0f, 1f);
component5.anchorMax = new Vector2(1f, 1f);
component5.pivot = new Vector2(0.5f, 1f);
component5.offsetMin = new Vector2(18f, 0f);
component5.offsetMax = new Vector2(-18f, 0f);
component5.anchoredPosition = Vector2.zero;
TextMeshProUGUI component6 = val4.GetComponent<TextMeshProUGUI>();
MainMenuButton_US.ApplyPanelTextStyle(styleRoot, component6);
((TMP_Text)component6).fontSize = 20f;
((Graphic)component6).color = Color.white;
((TMP_Text)component6).alignment = (TextAlignmentOptions)257;
((TMP_Text)component6).enableWordWrapping = true;
((TMP_Text)component6).overflowMode = (TextOverflowModes)0;
((TMP_Text)component6).lineSpacing = 8f;
((TMP_Text)component6).text = "\r\nFor any issues, suggestions, bugs, or complaints you have about ULTRASTATS, please contact me through discord. I'd prefer DMs but I am also active on the New Blood Discord server's ultrakill-modding channel and the ULTRAKILL legacy server's ultramodding channel so you can reach me there too. I'd love to hear from you! \r\n\r\n ULTRASTATS won Mod of the Month for March 2026!!!!!! :D I'm so happy that people liked my mod enough to download it and vote for it above several other (much better if I'm being honest) mods.\r\n";
((Graphic)component6).raycastTarget = false;
GameObject val5 = new GameObject("MotMImage", new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val5.transform.SetParent(val3.transform, false);
RectTransform component7 = val5.GetComponent<RectTransform>();
component7.anchorMin = new Vector2(0.5f, 1f);
component7.anchorMax = new Vector2(0.5f, 1f);
component7.pivot = new Vector2(0.5f, 1f);
component7.sizeDelta = new Vector2(0f, 0f);
component7.anchoredPosition = Vector2.zero;
Image component8 = val5.GetComponent<Image>();
component8.sprite = MainMenuButton_US.LoadSpriteFromPluginFile("images/MotM_March26.png") ?? MainMenuButton_US.LoadSpriteFromPluginFile("MotM_March26.png");
component8.type = (Type)0;
component8.preserveAspect = true;
((Graphic)component8).color = Color.white;
((Graphic)component8).raycastTarget = false;
GameObject val6 = new GameObject("InfoBodyTextBottom", new Type[2]
{
typeof(RectTransform),
typeof(TextMeshProUGUI)
});
val6.transform.SetParent(val3.transform, false);
RectTransform component9 = val6.GetComponent<RectTransform>();
component9.anchorMin = new Vector2(0f, 1f);
component9.anchorMax = new Vector2(1f, 1f);
component9.pivot = new Vector2(0.5f, 1f);
component9.offsetMin = new Vector2(18f, 0f);
component9.offsetMax = new Vector2(-18f, 0f);
component9.anchoredPosition = Vector2.zero;
TextMeshProUGUI component10 = val6.GetComponent<TextMeshProUGUI>();
MainMenuButton_US.ApplyPanelTextStyle(styleRoot, component10);
((TMP_Text)component10).fontSize = 20f;
((Graphic)component10).color = Color.white;
((TMP_Text)component10).alignment = (TextAlignmentOptions)257;
((TMP_Text)component10).enableWordWrapping = true;
((TMP_Text)component10).overflowMode = (TextOverflowModes)0;
((TMP_Text)component10).lineSpacing = 8f;
((TMP_Text)component10).text = "I'll keep improving ULTRASTATS to the best of my ability so it wins MotY 2026 too.\r\n\r\n The next major update will implement filtering. So you can filter out runs from different save files, only display runs with a certain rank, filter out flagged runs, etc.\r\n\r\n Thanks to each and everyone of you who choose to download ULTRASTATS, it means the world to me that people want to use my silly passion project.\r\n\r\n Thanks to my fellow modders for helping me with my questions and issues.\r\n\r\n Expect the next big update within a couple weeks, probably.\r\n\r\nP.S. You can change what tab is the default through PluginConfigurator, along with some other preference settings.\r\n\r\nKnown issues:\r\n -- Stuttering when spam clicking through the endscreen.\r\n -- UI is garbage... I tried my best okay :(\r\n -- When discard on endscreen is enabled, spam clicking can cause incomplete run data to be saved.\r\nIf you find any other issues DM me on discord.\r\n";
((Graphic)component10).raycastTarget = false;
UltraStatsInfoRichContentSizer component11 = val3.GetComponent<UltraStatsInfoRichContentSizer>();
component11.ContentRect = component4;
component11.TopTextRect = component5;
component11.TopText = component6;
component11.ImageRect = component7;
component11.Image = component8;
component11.BottomTextRect = component9;
component11.BottomText = component10;
component11.HorizontalPadding = 18f;
component11.ImageGapBefore = 18f;
component11.ImageGapAfter = 18f;
component11.BottomPadding = 24f;
component11.ImageMaxWidth = 960f;
Scrollbar scrollbar;
UltraStatsScrollbarDrag drag;
ScrollRect obj = UltraStatsScrollViewFactory.AttachChartStyleVerticalScroll(val, val2, component4, "ScrollbarTrack", 18f, 0f, 0f, 96f, out scrollbar, out drag);
Canvas.ForceUpdateCanvases();
obj.verticalNormalizedPosition = 1f;
drag.RefreshHandle();
}
}
internal sealed class UltraStatsInfoRichContentSizer : MonoBehaviour
{
public RectTransform ContentRect;
public RectTransform TopTextRect;
public TextMeshProUGUI TopText;
public RectTransform ImageRect;
public Image Image;
public RectTransform BottomTextRect;
public TextMeshProUGUI BottomText;
public float HorizontalPadding = 18f;
public float ImageGapBefore = 18f;
public float ImageGapAfter = 18f;
public float BottomPadding;
public float ImageMaxWidth = 960f;
private float _lastTopHeight = -1f;
private float _lastBottomHeight = -1f;
private float _lastImageWidth = -1f;
private float _lastImageHeight = -1f;
private void LateUpdate()
{
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_0246: Unknown result type (might be due to invalid IL or missing references)
//IL_025e: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
//IL_020f: Unknown result type (might be due to invalid IL or missing references)
//IL_0276: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)ContentRect == (Object)null || (Object)(object)TopTextRect == (Object)null || (Object)(object)TopText == (Object)null || (Object)(object)ImageRect == (Object)null || (Object)(object)Image == (Object)null || (Object)(object)BottomTextRect == (Object)null || (Object)(object)BottomText == (Object)null)
{
return;
}
Canvas.ForceUpdateCanvases();
float num = Mathf.Ceil(((TMP_Text)TopText).preferredHeight);
float num2 = Mathf.Ceil(((TMP_Text)BottomText).preferredHeight);
float num3 = 0f;
float num4 = 0f;
if ((Object)(object)Image.sprite != (Object)null)
{
Rect rect = ContentRect.rect;
float num5 = Mathf.Max(0f, ((Rect)(ref rect)).width - HorizontalPadding * 2f);
num3 = Mathf.Min(ImageMaxWidth, num5);
Rect rect2 = Image.sprite.rect;
if (num3 > 0f && ((Rect)(ref rect2)).width > 0f && ((Rect)(ref rect2)).height > 0f)
{
num4 = num3 * (((Rect)(ref rect2)).height / ((Rect)(ref rect2)).width);
}
}
if (!(Mathf.Abs(num - _lastTopHeight) < 0.5f) || !(Mathf.Abs(num2 - _lastBottomHeight) < 0.5f) || !(Mathf.Abs(num3 - _lastImageWidth) < 0.5f) || !(Mathf.Abs(num4 - _lastImageHeight) < 0.5f))
{
_lastTopHeight = num;
_lastBottomHeight = num2;
_lastImageWidth = num3;
_lastImageHeight = num4;
TopTextRect.SetSizeWithCurrentAnchors((Axis)1, num);
TopTextRect.anchoredPosition = Vector2.zero;
float num6 = num;
if ((Object)(object)Image.sprite != (Object)null && num3 > 0f && num4 > 0f)
{
num6 += ImageGapBefore;
ImageRect.anchoredPosition = new Vector2(0f, 0f - num6);
ImageRect.sizeDelta = new Vector2(num3, num4);
((Behaviour)Image).enabled = true;
num6 += num4 + ImageGapAfter;
}
else
{
((Behaviour)Image).enabled = false;
ImageRect.sizeDelta = Vector2.zero;
ImageRect.anchoredPosition = new Vector2(0f, 0f - num6);
}
BottomTextRect.anchoredPosition = new Vector2(0f, 0f - num6);
BottomTextRect.SetSizeWithCurrentAnchors((Axis)1, num2);
float num7 = num6 + num2 + BottomPadding;
ContentRect.SetSizeWithCurrentAnchors((Axis)1, num7);
}
}
}
internal static class MainMenuButton_US
{
private enum MenuCorner
{
BottomRight,
BottomLeft,
TopRight,
TopLeft
}
[CompilerGenerated]
private sealed class <InjectIntoMenuScene>d__25 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Scene scene;
private int <i>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InjectIntoMenuScene>d__25(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
_injecting = true;
<i>5__2 = 0;
break;
case 1:
<>1__state = -1;
<i>5__2++;
break;
}
if (<i>5__2 < 600)
{
if (!((Scene)(ref scene)).isLoaded)
{
_injecting = false;
return false;
}
GameObject val = FindRootCanvasObject(scene);
if ((Object)(object)val != (Object)null)
{
Transform val2 = val.transform.Find("Main Menu (1)");
Transform val3 = ((val2 != null) ? val2.Find("LeftSide") : null);
BepInExLogs_US.Debug($"mainMenu found = {(Object)(object)val2 != (Object)null}, leftSide found = {(Object)(object)val3 != (Object)null}");
if ((Object)(object)val2 != (Object)null && (Object)(object)val3 != (Object)null)
{
Inject(val3, val2);
_injecting = false;
return false;
}
}
<>2__current = null;
<>1__state = 1;
return true;
}
BepInExLogs_US.Warn("ULTRASTATS could not find Canvas/Main Menu (1)/LeftSide.");
_injecting = false;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private const string MenuSceneName = "b3e7f2f8052488a45b35549efb98d902";
private const string ButtonObjectName = "ULTRASTATS_MenuButton";
private const string PanelObjectName = "ULTRASTATS_MenuPanel";
private const string BlockerObjectName = "ULTRASTATS_MenuBlocker";
private static readonly Dictionary<string, Sprite> BevelSpriteCache = new Dictionary<string, Sprite>();
private const float PanelWidth = 1200f;
private const float PanelHeight = 770f;
private const float BorderThickness = 4f;
private const float TabWidth = 186f;
private const float TabHeight = 44f;
private const float TabSpacing = -2f;
private const float TabOverlapIntoPanel = 16f;
internal static readonly Color DestructiveTextColor = new Color(0.92f, 0.2f, 0.2f, 1f);
private static readonly Color DefaultBeveledButtonColor = new Color(0.07f, 0.07f, 0.07f, 0.96f);
private static readonly Color DefaultBeveledButtonHoverColor = new Color(0.18f, 0.18f, 0.18f, 0.98f);
private static readonly Color DefaultBeveledButtonPressedColor = new Color(0.28f, 0.28f, 0.28f, 1f);
private static readonly Color DefaultBeveledButtonActiveColor = new Color(0.61f, 0.12f, 0.12f, 1f);
private static bool _subscribed;
private static bool _injecting;
public static void Init()
{
if (!_subscribed)
{
_subscribed = true;
SceneManager.activeSceneChanged += OnActiveSceneChanged;
BepInExLogs_US.Debug("MainMenuButtonInjector.Init called");
}
}
public static void Shutdown()
{
if (_subscribed)
{
_subscribed = false;
SceneManager.activeSceneChanged -= OnActiveSceneChanged;
}
}
public static void RefreshButtonPosition()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
GameObject? obj = FindRootCanvasObject(SceneManager.GetActiveScene());
Transform obj2 = ((obj != null) ? obj.transform.Find("Main Menu (1)") : null);
Transform val = ((obj2 != null) ? obj2.Find("ULTRASTATS_MenuButton") : null);
if ((Object)(object)val != (Object)null)
{
ApplyButtonPosition(((Component)val).GetComponent<RectTransform>());
}
}
private static void ApplyButtonPosition(RectTransform rect)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)rect == (Object)null))
{
switch ((MenuCorner)Plugin.MainMenuButtonCorner)
{
case MenuCorner.BottomLeft:
rect.anchorMin = new Vector2(0f, 0f);
rect.anchorMax = new Vector2(0f, 0f);
rect.pivot = new Vector2(0f, 0f);
rect.anchoredPosition = new Vector2(28f, 28f);
break;
case MenuCorner.TopRight:
rect.anchorMin = new Vector2(1f, 1f);
rect.anchorMax = new Vector2(1f, 1f);
rect.pivot = new Vector2(1f, 1f);
rect.anchoredPosition = new Vector2(-28f, -28f);
break;
case MenuCorner.TopLeft:
rect.anchorMin = new Vector2(0f, 1f);
rect.anchorMax = new Vector2(0f, 1f);
rect.pivot = new Vector2(0f, 1f);
rect.anchoredPosition = new Vector2(28f, -28f);
break;
default:
rect.anchorMin = new Vector2(1f, 0f);
rect.anchorMax = new Vector2(1f, 0f);
rect.pivot = new Vector2(1f, 0f);
rect.anchoredPosition = new Vector2(-28f, 28f);
break;
}
}
}
private static void OnActiveSceneChanged(Scene oldScene, Scene newScene)
{
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
BepInExLogs_US.Debug("Scene changed: '" + ((Scene)(ref oldScene)).name + "' -> '" + ((Scene)(ref newScene)).name + "'");
if (!((Object)(object)Plugin.Instance == (Object)null) && !(((Scene)(ref newScene)).name != "b3e7f2f8052488a45b35549efb98d902") && !_injecting)
{
((MonoBehaviour)Plugin.Instance).StartCoroutine(InjectIntoMenuScene(newScene));
}
}
[IteratorStateMachine(typeof(<InjectIntoMenuScene>d__25))]
private static IEnumerator InjectIntoMenuScene(Scene scene)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InjectIntoMenuScene>d__25(0)
{
scene = scene
};
}
private static GameObject? FindRootCanvasObject(Scene scene)
{
GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
foreach (GameObject val in rootGameObjects)
{
if (((Object)val).name == "Canvas")
{
return val;
}
}
return null;
}
private static void TogglePanel(Transform mainMenu)
{
Transform val = mainMenu.Find("ULTRASTATS_MenuPanel");
Transform val2 = mainMenu.Find("ULTRASTATS_MenuBlocker");
if ((Object)(object)val == (Object)null)
{
BuildPanel(mainMenu);
val = mainMenu.Find("ULTRASTATS_MenuPanel");
val2 = mainMenu.Find("ULTRASTATS_MenuBlocker");
}
if ((Object)(object)val != (Object)null)
{
bool flag = !((Component)val).gameObject.activeSelf;
((Component)val).gameObject.SetActive(flag);
if ((Object)(object)val2 != (Object)null)
{
((Component)val2).gameObject.SetActive(flag);
}
if (flag)
{
ApplyConfiguredDefaults(((Component)val).gameObject);
}
}
}
private static int GetConfiguredDefaultTabIndex()
{
return Plugin.DefaultMainMenuTab switch
{
Plugin.DefaultMainMenuTabOption.Stats => 1,
Plugin.DefaultMainMenuTabOption.Plots => 2,
_ => 0,
};
}
private static void ApplyConfiguredDefaults(GameObject panel)
{
if (!((Object)(object)panel == (Object)null))
{
panel.GetComponent<UltraStatsTabbedPanelController>()?.ShowTab(GetConfiguredDefaultTabIndex());
}
}
private static void BuildPanel(Transform mainMenu)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_020d: Unknown result type (might be due to invalid IL or missing references)
//IL_0214: Expected O, but got Unknown
//IL_0230: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_0250: Unknown result type (might be due to invalid IL or missing references)
//IL_0264: Unknown result type (might be due to invalid IL or missing references)
//IL_0293: Unknown result type (might be due to invalid IL or missing references)
//IL_029a: Expected O, but got Unknown
//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0313: Unknown result type (might be due to invalid IL or missing references)
//IL_0334: Unknown result type (might be due to invalid IL or missing references)
//IL_033e: Expected O, but got Unknown
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
Transform val = mainMenu.Find("LeftSide");
if ((Object)(object)val == (Object)null)
{
BepInExLogs_US.Warn("Could not find LeftSide while building ULTRASTATS panel.");
return;
}
ResolveButtonTemplates(val, out GameObject inactiveTemplate, out GameObject activeTemplate);
CreateScreenBlocker(mainMenu);
GameObject val2 = new GameObject("ULTRASTATS_MenuPanel", new Type[3]
{
typeof(RectTransform),
typeof(UltraStatsMenuPanelCloser),
typeof(UltraStatsTabbedPanelController)
});
val2.transform.SetParent(mainMenu, false);
RectTransform component = val2.GetComponent<RectTransform>();
component.anchorMin = new Vector2(0.5f, 0.5f);
component.anchorMax = new Vector2(0.5f, 0.5f);
component.pivot = new Vector2(0.5f, 0.5f);
component.anchoredPosition = new Vector2(0f, 5f);
RectTransform val3 = (RectTransform)(object)((mainMenu is RectTransform) ? mainMenu : null);
float num = 1200f;
float num2 = 770f;
if ((Object)(object)val3 != (Object)null)
{
Rect rect = val3.rect;
num = Mathf.Max(640f, ((Rect)(ref rect)).width - 80f);
rect = val3.rect;
num2 = Mathf.Max(420f, ((Rect)(ref rect)).height - 80f);
}
float num3 = Mathf.Min(1200f, num);
float num4 = Mathf.Min(770f, num2);
component.sizeDelta = new Vector2(num3, num4);
UltraStatsTabbedPanelController tabs = val2.GetComponent<UltraStatsTabbedPanelController>();
GameObject val4 = CreatePanelBody(val2.transform, "PanelBody");
RectTransform component2 = val4.GetComponent<RectTransform>();
component2.anchorMin = new Vector2(0.5f, 1f);
component2.anchorMax = new Vector2(0.5f, 1f);
component2.pivot = new Vector2(0.5f, 1f);
component2.sizeDelta = new Vector2(num3, num4 - 36f);
component2.anchoredPosition = new Vector2(0f, -36f);
GameObject val5 = new GameObject("ContentRoot", new Type[1] { typeof(RectTransform) });
val5.transform.SetParent(val4.transform, false);
RectTransform component3 = val5.GetComponent<RectTransform>();
component3.anchorMin = Vector2.zero;
component3.anchorMax = Vector2.one;
component3.offsetMin = new Vector2(18f, 30f);
component3.offsetMax = new Vector2(-18f, -30f);
GameObject val6 = new GameObject("TabBar", new Type[2]
{
typeof(RectTransform),
typeof(HorizontalLayoutGroup)
});
val6.transform.SetParent(val2.transform, false);
RectTransform component4 = val6.GetComponent<RectTransform>();
component4.anchorMin = new Vector2(0f, 1f);
component4.anchorMax = new Vector2(1f, 1f);
component4.pivot = new Vector2(0f, 1f);
component4.offsetMin = new Vector2(0f, -52f);
component4.offsetMax = new Vector2(-52f, -8f);
HorizontalLayoutGroup component5 = val6.GetComponent<HorizontalLayoutGroup>();
((HorizontalOrVerticalLayoutGroup)component5).spacing = -2f;
((LayoutGroup)component5).padding = new RectOffset(0, 0, 0, 0);
((HorizontalOrVerticalLayoutGroup)component5).childForceExpandWidth = false;
((HorizontalOrVerticalLayoutGroup)component5).childForceExpandHeight = false;
((HorizontalOrVerticalLayoutGroup)component5).childControlWidth = true;
((HorizontalOrVerticalLayoutGroup)component5).childControlHeight = false;
((LayoutGroup)component5).childAlignment = (TextAnchor)0;
CreateCloseButton(val2.transform, val2, mainMenu);
GameObject val7 = CreateTabPage(val5.transform, "InfoPage");
GameObject val8 = CreateTabPage(val5.transform, "StatsPage");
GameObject val9 = CreateTabPage(val5.transform, "PlotsPage");
InfoTab_US.Build(val7.transform, mainMenu);
StatsTab_US.Build(val8.transform, mainMenu);
PlotsTab_US.Build(val9.transform, mainMenu);
float num5 = Mathf.Floor((num3 - 52f - -4f) / 3f);
num5 = Mathf.Clamp(num5, 120f, 186f);
tabs.AddTab(CreateTabButton(val6.transform, inactiveTemplate, activeTemplate, "INFO", num5, delegate
{
tabs.ShowTab(0);
}), val7);
tabs.AddTab(CreateTabButton(val6.transform, inactiveTemplate, activeTemplate, "STATS", num5, delegate
{
tabs.ShowTab(1);
}), val8);
tabs.AddTab(CreateTabButton(val6.transform, inactiveTemplate, activeTemplate, "PLOTS", num5, delegate
{
tabs.ShowTab(2);
}), val9);
ApplyConfiguredDefaults(val2);
val2.SetActive(false);
Transform val10 = mainMenu.Find("ULTRASTATS_MenuBlocker");
if ((Object)(object)val10 != (Object)null)
{
((Component)val10).gameObject.SetActive(false);
}
}
private static GameObject CreatePanelBody(Transform parent, string name)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_0191: Unknown result type (might be due to invalid IL or missing references)
//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_01be: Unknown result type (might be due to invalid IL or missing references)
//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
//IL_01d8: Expected O, but got Unknown
GameObject val = new GameObject(name, new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val.transform.SetParent(parent, false);
Image component = val.GetComponent<Image>();
((Graphic)component).color = new Color(0f, 0f, 0f, 0.975f);
((Graphic)component).raycastTarget = true;
CreateBorderStrip(val.transform, "TopBorder", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 1f), new Vector2(0f, -4f), new Vector2(0f, 0f));
CreateBorderStrip(val.transform, "BottomBorder", new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(0f, 0f), new Vector2(0f, 4f));
CreateBorderStrip(val.transform, "LeftBorder", new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(0f, 0f), new Vector2(4f, 0f));
CreateBorderStrip(val.transform, "RightBorder", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(1f, 0f), new Vector2(-4f, 0f), new Vector2(0f, 0f));
return val;
}
private static void CreateScreenBlocker(Transform mainMenu)
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)mainMenu.Find("ULTRASTATS_MenuBlocker") != (Object)null))
{
GameObject val = new GameObject("ULTRASTATS_MenuBlocker", new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val.transform.SetParent(mainMenu, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = Vector2.zero;
component.anchorMax = Vector2.one;
component.offsetMin = Vector2.zero;
component.offsetMax = Vector2.zero;
Image component2 = val.GetComponent<Image>();
((Graphic)component2).color = new Color(0f, 0f, 0f, 0.001f);
((Graphic)component2).raycastTarget = true;
val.SetActive(false);
}
}
internal static GameObject CreateBeveledFrame(Transform parent, string name, Vector2 size, Color fillColor, int borderThickness, int bevelSize, bool interceptClicks)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name, new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val.transform.SetParent(parent, false);
val.GetComponent<RectTransform>().sizeDelta = size;
int num = Mathf.Max(1, Mathf.RoundToInt(size.x));
int num2 = Mathf.Max(1, Mathf.RoundToInt(size.y));
int width = Mathf.Max(1, num - borderThickness * 2);
int height = Mathf.Max(1, num2 - borderThickness * 2);
int bevelSize2 = Mathf.Max(0, bevelSize - borderThickness);
Image component = val.GetComponent<Image>();
component.sprite = GetBevelSprite(num, num2, bevelSize);
component.type = (Type)0;
((Graphic)component).color = Color.white;
((Graphic)component).raycastTarget = interceptClicks;
GameObject val2 = new GameObject("Fill", new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val2.transform.SetParent(val.transform, false);
RectTransform component2 = val2.GetComponent<RectTransform>();
component2.anchorMin = Vector2.zero;
component2.anchorMax = Vector2.one;
component2.offsetMin = new Vector2((float)borderThickness, (float)borderThickness);
component2.offsetMax = new Vector2((float)(-borderThickness), (float)(-borderThickness));
Image component3 = val2.GetComponent<Image>();
component3.sprite = GetBevelSprite(width, height, bevelSize2);
component3.type = (Type)0;
((Graphic)component3).color = fillColor;
((Graphic)component3).raycastTarget = false;
return val;
}
internal static Button CreateStyledBeveledButton(Transform parent, Transform styleRoot, string name, Vector2 size, string? label, Sprite? iconSprite, out UltraStatsBeveledButtonTint tint, Color? fillColor = null, float fontSize = 18f, int borderThickness = 2, int bevelSize = 8, bool iconOnly = false)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_0219: Unknown result type (might be due to invalid IL or missing references)
//IL_0220: Unknown result type (might be due to invalid IL or missing references)
//IL_022b: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_024e: Unknown result type (might be due to invalid IL or missing references)
//IL_027a: Unknown result type (might be due to invalid IL or missing references)
//IL_0255: Unknown result type (might be due to invalid IL or missing references)
//IL_0266: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_018a: Unknown result type (might be due to invalid IL or missing references)
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
GameObject val = CreateBeveledFrame(parent, name, size, (Color)(((??)fillColor) ?? DefaultBeveledButtonColor), borderThickness, bevelSize, interceptClicks: true);
Transform obj = val.transform.Find("Fill");
Image val2 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
Button val3 = val.AddComponent<Button>();
((Selectable)val3).transition = (Transition)0;
Navigation navigation = ((Selectable)val3).navigation;
((Navigation)(ref navigation)).mode = (Mode)0;
((Selectable)val3).navigation = navigation;
tint = val.AddComponent<UltraStatsBeveledButtonTint>();
tint.FillImage = val2 ?? val.GetComponent<Image>();
tint.NormalColor = (Color)(((??)fillColor) ?? DefaultBeveledButtonColor);
tint.HoverColor = DefaultBeveledButtonHoverColor;
tint.PressedColor = DefaultBeveledButtonPressedColor;
tint.ActiveColor = DefaultBeveledButtonActiveColor;
tint.SetActiveVisual(active: false);
if ((Object)(object)iconSprite != (Object)null)
{
GameObject val4 = new GameObject("Icon", new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image)
});
val4.transform.SetParent(val.transform, false);
RectTransform component = val4.GetComponent<RectTransform>();
component.anchorMin = (iconOnly ? new Vector2(0.18f, 0.18f) : new Vector2(0.1f, 0.16f));
component.anchorMax = (iconOnly ? new Vector2(0.82f, 0.82f) : new Vector2(0.34f, 0.84f));
component.offsetMin = Vector2.zero;
component.offsetMax = Vector2.zero;
Image component2 = val4.GetComponent<Image>();
component2.sprite = iconSprite;
component2.type = (Type)0;
((Graphic)component2).material = null;
component2.preserveAspect = true;
((Graphic)component2).color = Color.white;
((Graphic)component2).raycastTarget = false;
}
if (!string.IsNullOrWhiteSpace(label))
{
GameObject val5 = new GameObject("Label", new Type[2]
{
typeof(RectTransform),
typeof(TextMeshProUGUI)
});
val5.transform.SetParent(val.transform, false);
RectTransform component3 = val5.GetComponent<RectTransform>();
component3.anchorMin = Vector2.zero;
component3.anchorMax = Vector2.one;
component3.offsetMin = (((Object)(object)iconSprite != (Object)null && !iconOnly) ? new Vector2(size.y * 0.85f, 0f) : new Vector2(8f, 0f));
component3.offsetMax = new Vector2(-8f, 0f);
TextMeshProUGUI component4 = val5.GetComponent<TextMeshProUGUI>();
ApplyPanelTextStyle(st