/// <summary>
/// http://www.ecma-international.org/ecma-262/5.1/#sec-9.2
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static bool ToBoolean(JsValue o)
{
if (o.IsObject())
{
return true;
}
if (o == Undefined.Instance || o == Null.Instance)
{
return false;
}
if (o.IsBoolean())
{
return o.AsBoolean();
}
if (o.IsNumber())
{
var n = o.AsNumber();
if (n.Equals(0) || double.IsNaN(n))
{
return false;
}
else
{
return true;
}
}
if (o.IsString())
{
var s = o.AsString();
if (String.IsNullOrEmpty(s))
{
return false;
}
else
{
return true;
}
}
return true;
}
/// <summary>
/// http://www.ecma-international.org/ecma-262/5.1/#sec-9.2
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static bool ToBoolean(JsValue o)
{
if (o.IsObject())
{
return(true);
}
if (o == Undefined.Instance || o == Null.Instance)
{
return(false);
}
if (o.IsBoolean())
{
return(o.AsBoolean());
}
if (o.IsNumber())
{
var n = o.AsNumber();
if (n.Equals(0) || double.IsNaN(n))
{
return(false);
}
else
{
return(true);
}
}
if (o.IsString())
{
var s = o.AsString();
if (String.IsNullOrEmpty(s))
{
return(false);
}
else
{
return(true);
}
}
return(true);
}
/// <summary>
/// http://www.ecma-international.org/ecma-262/5.1/#sec-9.8
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static string ToString(JsValue o)
{
if (o == null)
{
return(null);
}
if (o.IsObject())
{
var p = o.AsObject() as IPrimitiveInstance;
if (p != null)
{
o = p.PrimitiveValue;
}
}
if (o.IsString())
{
return(o.AsString());
}
if (o == Undefined.Instance)
{
return(Undefined.Text);
}
if (o == Null.Instance)
{
return(Null.Text);
}
if (o.IsBoolean())
{
return(o.AsBoolean() ? "true" : "false");
}
if (o.IsNumber())
{
return(NumberPrototype.ToNumberString(o.AsNumber()));
}
return(ToString(ToPrimitive(o, Types.String)));
}
private static string GetValueString(JsValue jsValue, bool useLiterals)
{
string result;
switch (jsValue.Type)
{
case Types.String:
result = jsValue.AsString();
break;
case Types.Undefined:
result = useLiterals ? "undefined" : null;
break;
case Types.Null:
result = useLiterals ? "null" : null;
break;
case Types.Boolean:
result = jsValue.AsBoolean().ToString();
break;
case Types.Number:
result = jsValue.AsNumber().ToString();
break;
case Types.Object:
result = jsValue.ToObject().ToString();
break;
case Types.None:
result = string.Empty;
break;
default:
result = jsValue.AsString();
break;
}
return(result);
}
public object UncastJsValue(JsValue value)
{
if (value.IsBoolean())
{
return(value.AsBoolean());
}
if (value.IsNumber())
{
return(value.AsNumber());
}
if (value.IsObject())
{
return(value.AsObject());
}
if (value.IsString())
{
return(value.AsString());
}
return(null);
}
public bool PassesFilter(string evtJson)
{
JsValue v = _context.ExecuteFunction("filter", new string[] { evtJson });
if (!v.IsBoolean())
{
var details = string.Format(@"Error, unable to test filter for {0}, filter did not return a boolean value:
Initial script Javascript:
------
{1}
------
Message: {3}
In: {4}", Name,
_context.JavaScript);
throw new Exception(details);
}
return(v.AsBoolean());
}
public void SetValue(JsValue arg)
{
switch (arg.Type)
{
case Types.Boolean:
Cell.SetCellValue(arg.AsBoolean());
break;
case Types.String:
Cell.SetCellValue(arg.AsString());
break;
case Types.Number:
Cell.SetCellValue(arg.AsNumber());
break;
case Types.Object:
if (arg.IsDate())
{
Cell.SetCellValue(arg.AsDate().ToDateTime());
}
else
{
double?value = arg.ConvertToDouble();
if (value.HasValue)
{
Cell.SetCellValue(value.Value);
}
else
{
Cell.SetCellValue((string)null);
}
}
break;
default:
Cell.SetCellValue((string)null);
break;
}
}
public static object GetItem(this Jint.Native.Array.ArrayInstance a, int index)
{
JsValue l = a.Get(index.ToString());
if (l.IsNull())
{
return(null);
}
if (l.IsNumber())
{
return(l.AsNumber());
}
if (l.IsBoolean())
{
return(l.AsBoolean());
}
if (l.IsString())
{
return(l.AsString());
}
if (l.IsNumber())
{
return(l.AsNumber());
}
if (l.IsUndefined())
{
return("undefined");
}
if (l.IsObject())
{
return(l.AsObject());
}
if (l.IsRegExp())
{
return(l.AsObject());
}
throw new ArgumentException(string.Format("Cannot deal with JsValue {0}", l));
}
public static ObjectInstance ToObject(Engine engine, JsValue value)
{
if (value.IsObject())
{
return(value.AsObject());
}
if (value == Undefined.Instance)
{
//throw new JavaScriptException(engine.TypeError);
return(null);
}
if (value == Null.Instance)
{
//throw new JavaScriptException(engine.TypeError);
return(null);
}
if (value.IsBoolean())
{
return(engine.Boolean.Construct(value.AsBoolean()));
}
if (value.IsNumber())
{
return(engine.Number.Construct(value.AsNumber()));
}
if (value.IsString())
{
return(engine.String.Construct(value.AsString()));
}
throw new JavaScriptException(engine.TypeError, value + " is not a object");
}
public static IJsonValue Map(JsValue value)
{
if (value == null || value.IsNull() || value.IsUndefined())
{
return(JsonValue.Null);
}
if (value.IsString())
{
return(JsonValue.Create(value.AsString()));
}
if (value.IsBoolean())
{
return(JsonValue.Create(value.AsBoolean()));
}
if (value.IsNumber())
{
return(JsonValue.Create(value.AsNumber()));
}
if (value.IsDate())
{
return(JsonValue.Create(value.AsDate().ToString()));
}
if (value.IsRegExp())
{
return(JsonValue.Create(value.AsRegExp().Value?.ToString()));
}
if (value.IsArray())
{
var arr = value.AsArray();
var result = JsonValue.Array();
for (var i = 0; i < arr.GetLength(); i++)
{
result.Add(Map(arr.Get(i.ToString())));
}
return(result);
}
if (value.IsObject())
{
var obj = value.AsObject();
var result = JsonValue.Object();
foreach (var kvp in obj.GetOwnProperties())
{
result[kvp.Key] = Map(kvp.Value.Value);
}
return(result);
}
throw new ArgumentException("Invalid json type.", nameof(value));
}
public static bool Equal(JsValue x, JsValue y)
{
var typex = x.Type;
var typey = y.Type;
if (typex == typey)
{
if (typex == Types.Undefined || typex == Types.Null)
{
return(true);
}
if (typex == Types.Number)
{
var nx = TypeConverter.ToNumber(x);
var ny = TypeConverter.ToNumber(y);
if (double.IsNaN(nx) || double.IsNaN(ny))
{
return(false);
}
if (nx.Equals(ny))
{
return(true);
}
return(false);
}
if (typex == Types.String)
{
return(TypeConverter.ToString(x) == TypeConverter.ToString(y));
}
if (typex == Types.Boolean)
{
return(x.AsBoolean() == y.AsBoolean());
}
if (typex == Types.Object)
{
var xObject = x.AsObject();
var yObject = x.AsObject();
// How do I check if these are CLR instances? And if so, how do I consistently get the "inner value"?
return(xObject == yObject);
}
return(x == y);
}
if (x == Null.Instance && y == Undefined.Instance)
{
return(true);
}
if (x == Undefined.Instance && y == Null.Instance)
{
return(true);
}
if (typex == Types.Number && typey == Types.String)
{
return(Equal(x, TypeConverter.ToNumber(y)));
}
if (typex == Types.String && typey == Types.Number)
{
return(Equal(TypeConverter.ToNumber(x), y));
}
if (typex == Types.Boolean)
{
return(Equal(TypeConverter.ToNumber(x), y));
}
if (typey == Types.Boolean)
{
return(Equal(x, TypeConverter.ToNumber(y)));
}
if (typey == Types.Object && (typex == Types.String || typex == Types.Number))
{
return(Equal(x, TypeConverter.ToPrimitive(y)));
}
if (typex == Types.Object && (typey == Types.String || typey == Types.Number))
{
return(Equal(TypeConverter.ToPrimitive(x), y));
}
return(false);
}
/// Implementation from ObjectInstance official specs as the one
/// in ObjectInstance is optimized for the general case and wouldn't work
/// for arrays
public override void Put(string propertyName, JsValue value, bool throwOnError)
{
if (!CanPut(propertyName))
{
if (throwOnError)
{
throw new JavaScriptException(Engine.TypeError);
}
return;
}
if (InternalArray != null)
{
int ind;
if (int.TryParse(propertyName, out ind))
{
object val;
switch (value.Type)
{
case Types.Undefined:
val = null;
break;
case Types.Null:
val = null;
break;
case Types.Boolean:
val = value.AsBoolean();
break;
case Types.String:
val = value.AsString();
break;
case Types.Number:
val = value.AsNumber();
break;
case Types.Object:
val = value;
var ow = ((JsValue)val).AsObject() as ObjectWrapper;
if (ow != null)
{
val = ow.Target;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
if (ind >= InternalArray.Count)
{
for (int i = InternalArray.Count; i <= ind; i++)
{
if (val != null)
InternalArray.Add(GetDefault(val.GetType()));
else
InternalArray.Add(null);
}
}
InternalArray[ind] = val;
}
}
var ownDesc = GetOwnProperty(propertyName);
if (ownDesc.IsDataDescriptor())
{
var valueDesc = new PropertyDescriptor(value: value, writable: null, enumerable: null, configurable: null);
DefineOwnProperty(propertyName, valueDesc, throwOnError);
return;
}
// property is an accessor or inherited
var desc = GetProperty(propertyName);
if (desc.IsAccessorDescriptor())
{
var setter = desc.Set.Value.TryCast<ICallable>();
setter.Call(new JsValue(this), new[] { value });
}
else
{
var newDesc = new PropertyDescriptor(value, true, true, true);
DefineOwnProperty(propertyName, newDesc, throwOnError);
}
}
private object ToBlittableValue(JsValue v, string propertyKey, bool recursiveCall)
{
if (v.IsBoolean())
{
return(v.AsBoolean());
}
if (v.IsString())
{
const string RavenDataByteArrayToBase64 = "raven-data:byte[];base64,";
var valueAsObject = v.ToObject();
var value = valueAsObject?.ToString();
if (value != null && value.StartsWith(RavenDataByteArrayToBase64))
{
value = value.Remove(0, RavenDataByteArrayToBase64.Length);
var byteArray = Convert.FromBase64String(value);
return(Encoding.UTF8.GetString(byteArray));
}
return(value);
}
if (v.IsNumber())
{
var num = v.AsNumber();
KeyValuePair <object, JsValue> property;
if (_propertiesByValue.TryGetValue(propertyKey, out property))
{
var originalValue = property.Key;
if (originalValue is float || originalValue is int)
{
// If the current value is exactly as the original value, we can return the original value before we made the JS conversion,
// which will convert a Int64 to jsFloat.
var jsValue = property.Value;
if (jsValue.IsNumber() && Math.Abs(num - jsValue.AsNumber()) < double.Epsilon)
{
return(originalValue);
}
//We might have change the type of num from Integer to long in the script by design
//Making sure the number isn't a real float before returning it as integer
if (originalValue is int && (Math.Abs(num - Math.Floor(num)) <= double.Epsilon || Math.Abs(num - Math.Ceiling(num)) <= double.Epsilon))
{
return((long)num);
}
return(num); //float
}
}
// If we don't have the type, assume that if the number ending with ".0" it actually an integer.
var integer = Math.Truncate(num);
if (Math.Abs(num - integer) < double.Epsilon)
{
return((long)integer);
}
return(num);
}
if (v.IsNull() || v.IsUndefined())
{
return(null);
}
if (v.IsArray())
{
var jsArray = v.AsArray();
var array = new DynamicJsonArray();
foreach (var property in jsArray.GetOwnProperties())
{
if (InheritedProperties.Contains(property.Key))
{
continue;
}
var jsInstance = property.Value.Value;
if (!jsInstance.HasValue)
{
continue;
}
var ravenJToken = ToBlittableValue(jsInstance.Value, propertyKey + "[" + property.Key + "]", recursiveCall);
if (ravenJToken == null)
{
continue;
}
array.Add(ravenJToken);
}
return(array);
}
if (v.IsDate())
{
return(v.AsDate().ToDateTime());
}
if (v.IsObject())
{
return(ToBlittable(v.AsObject(), propertyKey, recursiveCall));
}
if (v.IsRegExp())
{
return(null);
}
throw new NotSupportedException(v.Type.ToString());
}
/// <summary>
/// http://www.ecma-international.org/ecma-262/5.1/#sec-9.3
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static double ToNumber(JsValue o)
{
// check number first as this is what is usually expected
if (o.IsNumber())
{
return(o.AsNumber());
}
if (o.IsObject())
{
var p = o.AsObject() as IPrimitiveInstance;
if (p != null)
{
o = p.PrimitiveValue;
}
}
if (o == Undefined.Instance)
{
return(double.NaN);
}
if (o == Null.Instance)
{
return(0);
}
if (o.IsBoolean())
{
return(o.AsBoolean() ? 1 : 0);
}
if (o.IsString())
{
var s = StringPrototype.TrimEx(o.AsString());
if (String.IsNullOrEmpty(s))
{
return(0);
}
if ("+Infinity".Equals(s) || "Infinity".Equals(s))
{
return(double.PositiveInfinity);
}
if ("-Infinity".Equals(s))
{
return(double.NegativeInfinity);
}
// todo: use a common implementation with JavascriptParser
try
{
if (!s.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
{
var start = s[0];
if (start != '+' && start != '-' && start != '.' && !char.IsDigit(start))
{
return(double.NaN);
}
double n = Double.Parse(s,
NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign |
NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite |
NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
if (s.StartsWith("-") && n.Equals(0))
{
return(-0.0);
}
return(n);
}
int i = int.Parse(s.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
return(i);
}
catch (OverflowException)
{
return(s.StartsWith("-") ? double.NegativeInfinity : double.PositiveInfinity);
}
catch
{
return(double.NaN);
}
}
return(ToNumber(ToPrimitive(o, Types.Number)));
}
private RavenJToken ToRavenJToken(JsValue v, string propertyKey, bool recursiveCall)
{
if (v.IsBoolean())
{
return(new RavenJValue(v.AsBoolean()));
}
if (v.IsString())
{
const string RavenDataByteArrayToBase64 = "raven-data:byte[];base64,";
var valueAsObject = v.ToObject();
var value = valueAsObject != null?valueAsObject.ToString() : null;
if (value != null && value.StartsWith(RavenDataByteArrayToBase64))
{
value = value.Remove(0, RavenDataByteArrayToBase64.Length);
var byteArray = Convert.FromBase64String(value);
return(new RavenJValue(byteArray));
}
return(new RavenJValue(value));
}
if (v.IsNumber())
{
var num = v.AsNumber();
KeyValuePair <RavenJValue, JsValue> property;
if (propertiesByValue.TryGetValue(propertyKey, out property))
{
var originalValue = property.Key;
if (originalValue.Type == JTokenType.Float ||
originalValue.Type == JTokenType.Integer)
{
// If the current value is exactly as the original value, we can return the original value before we made the JS conversion,
// which will convert a Int64 to jsFloat.
var originalJsValue = property.Value;
if (originalJsValue.IsNumber() && Math.Abs(num - originalJsValue.AsNumber()) < double.Epsilon)
{
return(originalValue);
}
if (originalValue.Type == JTokenType.Integer)
{
return(new RavenJValue((long)num));
}
return(new RavenJValue(num));//float
}
}
// If we don't have the type, assume that if the number ending with ".0" it actually an integer.
var integer = Math.Truncate(num);
if (Math.Abs(num - integer) < double.Epsilon)
{
return(new RavenJValue((long)integer));
}
return(new RavenJValue(num));
}
if (v.IsNull())
{
return(RavenJValue.Null);
}
if (v.IsUndefined())
{
return(RavenJValue.Null);
}
if (v.IsArray())
{
var jsArray = v.AsArray();
var rja = new RavenJArray();
foreach (var property in jsArray.Properties)
{
if (property.Key == "length")
{
continue;
}
var jsInstance = property.Value.Value;
if (!jsInstance.HasValue)
{
continue;
}
var ravenJToken = ToRavenJToken(jsInstance.Value, propertyKey + "[" + property.Key + "]", recursiveCall);
if (ravenJToken == null)
{
continue;
}
rja.Add(ravenJToken);
}
return(rja);
}
if (v.IsObject())
{
return(ToRavenJObject(v, propertyKey, recursiveCall));
}
if (v.IsRegExp())
{
return(null);
}
throw new NotSupportedException(v.Type.ToString());
}
public static JsValue LogicalNot(JsValue val)
{
return(new JsBoolean(!val.AsBoolean().Value));
}
public static ObjectInstance ToObject(Engine engine, JsValue value)
{
if (value.IsObject())
{
return value.AsObject();
}
if (value == Undefined.Instance)
{
throw new JavaScriptException(engine.TypeError);
}
if (value == Null.Instance)
{
throw new JavaScriptException(engine.TypeError);
}
if (value.IsBoolean())
{
return engine.Boolean.Construct(value.AsBoolean());
}
if (value.IsNumber())
{
return engine.Number.Construct(value.AsNumber());
}
if (value.IsString())
{
return engine.String.Construct(value.AsString());
}
throw new JavaScriptException(engine.TypeError);
}
/// <summary>
/// http://www.ecma-international.org/ecma-262/5.1/#sec-9.8
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static string ToString(JsValue o)
{
if (o.IsObject())
{
var p = o.AsObject() as IPrimitiveInstance;
if (p != null)
{
o = p.PrimitiveValue;
}
}
if (o.IsString())
{
return o.AsString();
}
if (o == Undefined.Instance)
{
return Undefined.Text;
}
if (o == Null.Instance)
{
return Null.Text;
}
if (o.IsBoolean())
{
return o.AsBoolean() ? "true" : "false";
}
if (o.IsNumber())
{
return NumberPrototype.ToNumberString(o.AsNumber());
}
return ToString(ToPrimitive(o, Types.String));
}
/// <summary>
/// http://www.ecma-international.org/ecma-262/5.1/#sec-9.3
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static double ToNumber(JsValue o)
{
// check number first as this is what is usually expected
if (o.IsNumber())
{
return o.AsNumber();
}
if (o.IsObject())
{
var p = o.AsObject() as IPrimitiveInstance;
if (p != null)
{
o = p.PrimitiveValue;
}
}
if (o == Undefined.Instance)
{
return double.NaN;
}
if (o == Null.Instance)
{
return 0;
}
if (o.IsBoolean())
{
return o.AsBoolean() ? 1 : 0;
}
if (o.IsString())
{
var s = o.AsString().Trim();
if (String.IsNullOrEmpty(s))
{
return 0;
}
if ("+Infinity".Equals(s) || "Infinity".Equals(s))
{
return double.PositiveInfinity;
}
if ("-Infinity".Equals(s))
{
return double.NegativeInfinity;
}
// todo: use a common implementation with JavascriptParser
try
{
if (!s.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
{
var start = s[0];
if (start != '+' && start != '-' && start != '.' && !char.IsDigit(start))
{
return double.NaN;
}
double n = Double.Parse(s,
NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign |
NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite |
NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
if (s.StartsWith("-") && n.Equals(0))
{
return -0.0;
}
return n;
}
int i = int.Parse(s.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
return i;
}
catch (OverflowException)
{
return s.StartsWith("-") ? double.NegativeInfinity : double.PositiveInfinity;
}
catch
{
return double.NaN;
}
}
return ToNumber(ToPrimitive(o, Types.Number));
}
private LocalVariable GetLocalVariableJS(string key, JsValue value)
{
var result = new LocalVariable()
{
Name = key, TypeName = value.Type.ToString()
};
if (value.IsArray())
{
var trueValue = value.AsArray();
if (trueValue.GetLength() > 0)
{
var props = trueValue.GetOwnProperties();
foreach (var item in props)
{
var ch = GetLocalVariableJS(item.Key, item.Value.Value);
result.Children.Add(ch);
}
}
//result.Value=trueValue.
}
else if (value.IsBoolean())
{
var trueValue = value.AsBoolean();
result.Value = trueValue.ToString();
}
else if (value.IsDate())
{
var trueValue = value.AsDate();
result.Value = trueValue.ToDateTime().ToString("yyyy-MM-dd HH:mm:ss");
}
else if (value.IsNumber())
{
var trueValue = value.AsNumber();
result.Value = trueValue.ToString();
}
else if (value.IsString())
{
var trueValue = value.AsString();
result.Value = trueValue;
}
else if (value.IsObject())
{
var trueValue = value.AsObject();
//判断对象是否原生JS
if (trueValue.GetType().Name == "ObjectInstance")
{
var props = trueValue.GetOwnProperties();
foreach (var item in props)
{
var ch = GetLocalVariableJS(item.Key, item.Value.Value);
result.Children.Add(ch);
}
}
else
{
var csharpValue = value.ToObject();
if (csharpValue != null)
{
//只处理DapperRow
result = GetLocalVariableCSharp(key, csharpValue);
//csharpValue.
}
}
}
return(result);
}
public static bool ConvertToBool(JsValue value) =>
value.IsBoolean() ? value.AsBoolean()
: value.IsNumber() ? (int)value.AsNumber() != 0
: !value.IsNull() && !value.IsUndefined();
public static bool Equal(JsValue x, JsValue y)
{
var typex = x.Type;
var typey = y.Type;
if (typex == typey)
{
if (typex == Types.Undefined || typex == Types.Null)
{
return(true);
}
if (typex == Types.Number)
{
var nx = TypeConverter.ToNumber(x);
var ny = TypeConverter.ToNumber(y);
if (double.IsNaN(nx) || double.IsNaN(ny))
{
return(false);
}
if (nx.Equals(ny))
{
return(true);
}
return(false);
}
if (typex == Types.String)
{
return(TypeConverter.ToString(x) == TypeConverter.ToString(y));
}
if (typex == Types.Boolean)
{
return(x.AsBoolean() == y.AsBoolean());
}
return(x == y);
}
if (x == Null.Instance && y == Undefined.Instance)
{
return(true);
}
if (x == Undefined.Instance && y == Null.Instance)
{
return(true);
}
if (typex == Types.Number && typey == Types.String)
{
return(Equal(x, TypeConverter.ToNumber(y)));
}
if (typex == Types.String && typey == Types.Number)
{
return(Equal(TypeConverter.ToNumber(x), y));
}
if (typex == Types.Boolean)
{
return(Equal(TypeConverter.ToNumber(x), y));
}
if (typey == Types.Boolean)
{
return(Equal(x, TypeConverter.ToNumber(y)));
}
if (typey == Types.Object && (typex == Types.String || typex == Types.Number))
{
return(Equal(x, TypeConverter.ToPrimitive(y)));
}
if (typex == Types.Object && (typey == Types.String || typey == Types.Number))
{
return(Equal(TypeConverter.ToPrimitive(x), y));
}
return(false);
}
public static bool?ConvertToBoolOption(JsValue value) =>
value.IsBoolean() ? value.AsBoolean()
: value.IsNumber() ? (int)value.AsNumber() != 0
: (value.IsNull() || value.IsUndefined()) ? (bool?)null : true;
public static bool StrictlyEqual(JsValue x, JsValue y)
{
var typea = x.Type;
var typeb = y.Type;
if (typea != typeb)
{
return(false);
}
if (typea == Types.Undefined || typea == Types.Null)
{
return(true);
}
if (typea == Types.None)
{
return(true);
}
if (typea == Types.Number)
{
var nx = x.AsNumber();
var ny = y.AsNumber();
if (double.IsNaN(nx) || double.IsNaN(ny))
{
return(false);
}
if (nx.Equals(ny))
{
return(true);
}
return(false);
}
if (typea == Types.String)
{
return(x.AsString() == y.AsString());
}
if (typea == Types.Boolean)
{
return(x.AsBoolean() == y.AsBoolean());
}
if (typea == Types.Object)
{
var xw = x.AsObject() as IObjectWrapper;
if (xw != null)
{
var yw = y.AsObject() as IObjectWrapper;
return(Object.Equals(xw.Target, yw.Target));
}
}
return(x == y);
}
public object ConvertToObject(JsValue jsValue, Type targetType)
{
if (jsValue == _getEngine().Global)
{
return(_global);
}
if (jsValue.IsUndefined())
{
return(null);
}
if (jsValue.IsObject())
{
var obj = jsValue.AsObject();
if (targetType == typeof(string))
{
return(obj.ToString());
}
switch (obj)
{
case ClrObject clr:
return(clr.Target);
case ObjectInstance objInst:
return(GetCreator(targetType)(objInst));
}
return(jsValue);
}
if (jsValue.IsBoolean())
{
var boolVal = jsValue.AsBoolean();
if (targetType == typeof(string))
{
return(boolVal ? "true" : "false");
}
return(boolVal);
}
if (jsValue.IsString())
{
return(jsValue.AsString());
}
if (jsValue.IsNumber())
{
var dbl = jsValue.AsNumber();
if (targetType == typeof(sbyte))
{
return((sbyte)dbl);
}
if (targetType == typeof(byte))
{
return((byte)dbl);
}
if (targetType == typeof(int))
{
return((int)dbl);
}
if (targetType == typeof(uint))
{
return((uint)dbl);
}
if (targetType == typeof(short))
{
return((short)dbl);
}
if (targetType == typeof(ushort))
{
return((ushort)dbl);
}
if (targetType == typeof(long))
{
return((long)dbl);
}
if (targetType == typeof(ulong))
{
return((ulong)dbl);
}
if (targetType == typeof(float))
{
return((float)dbl);
}
if (targetType == typeof(string))
{
return(dbl.ToString(CultureInfo.InvariantCulture));
}
return(dbl);
}
return(null);
}
private static object GetValue(JsValue jsValue)
{
if (jsValue.IsNull())
{
return(null);
}
if (jsValue.IsString())
{
return(jsValue.AsString());
}
if (jsValue.IsBoolean())
{
return(jsValue.AsBoolean());
}
if (jsValue.IsNumber())
{
return(jsValue.AsNumber());
}
if (jsValue.IsDate())
{
return(jsValue.AsDate());
}
if (jsValue is ObjectWrapper ow)
{
var target = ow.Target;
switch (target)
{
case LazyStringValue lsv:
return(lsv);
case LazyCompressedStringValue lcsv:
return(lcsv);
case LazyNumberValue lnv:
return(lnv); //should be already blittable supported type.
}
ThrowInvalidObject(jsValue);
}
else if (jsValue.IsArray())
{
var arr = jsValue.AsArray();
var array = new object[arr.GetLength()];
var i = 0;
foreach ((var key, var val) in arr.GetOwnProperties())
{
if (key == "length")
{
continue;
}
array[i++] = GetValue(val.Value);
}
return(array);
}
else if (jsValue.IsObject())
{
return(jsValue.AsObject());
}
if (jsValue.IsUndefined())
{
return(null);
}
ThrowInvalidObject(jsValue);
return(null);
}
public static bool Equal(JsValue x, JsValue y)
{
var typex = x.Type;
var typey = y.Type;
if (typex == typey)
{
if (typex == Types.Undefined || typex == Types.Null)
{
return true;
}
if (typex == Types.Number)
{
var nx = TypeConverter.ToNumber(x);
var ny = TypeConverter.ToNumber(y);
if (double.IsNaN(nx) || double.IsNaN(ny))
{
return false;
}
if (nx.Equals(ny))
{
return true;
}
return false;
}
if (typex == Types.String)
{
return TypeConverter.ToString(x) == TypeConverter.ToString(y);
}
if (typex == Types.Boolean)
{
return x.AsBoolean() == y.AsBoolean();
}
return x == y;
}
if (x == Null.Instance && y == Undefined.Instance)
{
return true;
}
if (x == Undefined.Instance && y == Null.Instance)
{
return true;
}
if (typex == Types.Number && typey == Types.String)
{
return Equal(x, TypeConverter.ToNumber(y));
}
if (typex == Types.String && typey == Types.Number)
{
return Equal(TypeConverter.ToNumber(x), y);
}
if (typex == Types.Boolean)
{
return Equal(TypeConverter.ToNumber(x), y);
}
if (typey == Types.Boolean)
{
return Equal(x, TypeConverter.ToNumber(y));
}
if (typey == Types.Object && (typex == Types.String || typex == Types.Number))
{
return Equal(x, TypeConverter.ToPrimitive(y));
}
if (typex == Types.Object && (typey == Types.String || typey == Types.Number))
{
return Equal(TypeConverter.ToPrimitive(x), y);
}
return false;
}
public static JToken Map(JsValue value)
{
if (value == null || value.IsNull())
{
return(JValue.CreateNull());
}
if (value.IsUndefined())
{
return(JValue.CreateUndefined());
}
if (value.IsString())
{
return(new JValue(value.AsString()));
}
if (value.IsBoolean())
{
return(new JValue(value.AsBoolean()));
}
if (value.IsNumber())
{
return(new JValue(value.AsNumber()));
}
if (value.IsDate())
{
return(new JValue(value.AsDate().ToDateTime()));
}
if (value.IsRegExp())
{
return(JValue.CreateString(value.AsRegExp().Value?.ToString()));
}
if (value.IsArray())
{
var arr = value.AsArray();
var target = new JArray();
for (var i = 0; i < arr.GetLength(); i++)
{
target.Add(Map(arr.Get(i.ToString())));
}
return(target);
}
if (value.IsObject())
{
var obj = value.AsObject();
var target = new JObject();
foreach (var kvp in obj.GetOwnProperties())
{
target[kvp.Key] = Map(kvp.Value.Value);
}
return(target);
}
throw new ArgumentException("Invalid json type.", nameof(value));
}
/// Implementation from ObjectInstance official specs as the one
/// in ObjectInstance is optimized for the general case and wouldn't work
/// for arrays
public override void Put(string propertyName, JsValue value, bool throwOnError)
{
if (!CanPut(propertyName))
{
if (throwOnError)
{
throw new JavaScriptException(Engine.TypeError);
}
return;
}
if (InternalArray != null)
{
int ind;
if (int.TryParse(propertyName, out ind))
{
object val;
switch (value.Type)
{
case Types.Undefined:
val = null;
break;
case Types.Null:
val = null;
break;
case Types.Boolean:
val = value.AsBoolean();
break;
case Types.String:
val = value.AsString();
break;
case Types.Number:
val = value.AsNumber();
break;
case Types.Object:
val = value;
var ow = ((JsValue)val).AsObject() as ObjectWrapper;
if (ow != null)
{
val = ow.Target;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
if (ind >= InternalArray.Count)
{
for (int i = InternalArray.Count; i <= ind; i++)
{
if (val != null)
{
InternalArray.Add(GetDefault(val.GetType()));
}
else
{
InternalArray.Add(null);
}
}
}
InternalArray[ind] = val;
}
}
var ownDesc = GetOwnProperty(propertyName);
if (ownDesc.IsDataDescriptor())
{
var valueDesc = new PropertyDescriptor(value: value, writable: null, enumerable: null, configurable: null);
DefineOwnProperty(propertyName, valueDesc, throwOnError);
return;
}
// property is an accessor or inherited
var desc = GetProperty(propertyName);
if (desc.IsAccessorDescriptor())
{
var setter = desc.Set.Value.TryCast <ICallable>();
setter.Call(new JsValue(this), new[] { value });
}
else
{
var newDesc = new PropertyDescriptor(value, true, true, true);
DefineOwnProperty(propertyName, newDesc, throwOnError);
}
}
