GlobalObject

constructor

GlobalObject()

init()

Sub New()

constructor(aParser: EcmaScriptCompiler)

GlobalObject(EcmaScriptCompiler aParser)

init(_ aParser: EcmaScriptCompiler)

Sub New(aParser As EcmaScriptCompiler)

constructor(obj: GlobalObject)

GlobalObject(GlobalObject obj)

init(_ obj: GlobalObject)

Sub New(obj As GlobalObject)

constructor(obj: GlobalObject; aProto: EcmaScriptObject)

GlobalObject(GlobalObject obj, EcmaScriptObject aProto)

init(_ obj: GlobalObject, _ aProto: EcmaScriptObject)

Sub New(obj As GlobalObject, aProto As EcmaScriptObject)

method AddValue(aValue: String; aData: Object): EcmaScriptObject

EcmaScriptObject AddValue(String aValue, Object aData)

func AddValue(_ aValue: String, _ aData: Object) -> EcmaScriptObject

Function AddValue(aValue As String, aData As Object) As EcmaScriptObject

method AddValues(aValue: array of String; aData: array of Object): EcmaScriptObject

EcmaScriptObject AddValues(String[] aValue, Object[] aData)

func AddValues(_ aValue: String..., _ aData: Object...) -> EcmaScriptObject

Function AddValues(aValue As String(), aData As Object()) As EcmaScriptObject

method ArrayConcat(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayConcat(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayConcat(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayConcat(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayEvery(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayEvery(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayEvery(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayEvery(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayFilter(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayFilter(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayFilter(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayFilter(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayForeach(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayForeach(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayForeach(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayForeach(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayIndexOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayIndexOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayIndexOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayIndexOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayIsArray(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayIsArray(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayIsArray(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayIsArray(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayJoin(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayJoin(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayJoin(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayJoin(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayLastIndexOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayLastIndexOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayLastIndexOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayLastIndexOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayMap(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayMap(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayMap(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayMap(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayPop(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayPop(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayPop(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayPop(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property ArrayPrototype: EcmaScriptObject read write;

EcmaScriptObject ArrayPrototype { get; set; }

var ArrayPrototype: EcmaScriptObject { get{} set{} }

Property ArrayPrototype() As EcmaScriptObject

method ArrayPush(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayPush(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayPush(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayPush(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayReduce(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayReduce(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayReduce(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayReduce(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayReduceRight(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayReduceRight(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayReduceRight(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayReduceRight(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayReverse(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayReverse(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayReverse(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayReverse(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayShift(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayShift(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayShift(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayShift(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArraySlice(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArraySlice(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArraySlice(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArraySlice(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArraySome(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArraySome(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArraySome(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArraySome(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArraySort(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArraySort(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArraySort(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArraySort(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArraySplice(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArraySplice(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArraySplice(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArraySplice(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayToLocaleString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayToLocaleString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayToLocaleString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayToLocaleString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayToString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayToString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayToString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ArrayUnshift(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ArrayUnshift(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ArrayUnshift(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ArrayUnshift(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

class var BaseString: String;

static String BaseString

static var BaseString: String

Shared FIELD BaseString() As String

method BooleanCall(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object BooleanCall(ExecutionContext aCaller, Object aSelf, params Object[] args)

func BooleanCall(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function BooleanCall(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method BooleanCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object BooleanCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func BooleanCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function BooleanCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property BooleanPrototype: EcmaScriptObject read write;

EcmaScriptObject BooleanPrototype { get; set; }

var BooleanPrototype: EcmaScriptObject { get{} set{} }

Property BooleanPrototype() As EcmaScriptObject

method BooleanToString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object BooleanToString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func BooleanToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function BooleanToString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method BooleanValueOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object BooleanValueOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func BooleanValueOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function BooleanValueOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method Call(context: ExecutionContext; params args: array of Object): Object

Object Call(ExecutionContext context, params Object[] args)

func Call(_ context: ExecutionContext, _ args: Object...) -> Object

Function Call(context As ExecutionContext, ParamArray args As Object()) As Object

method CallEx(context: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object CallEx(ExecutionContext context, Object aSelf, params Object[] args)

func CallEx(_ context: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function CallEx(context As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

class method CallHelper(Ref: Object; aSelf: Object; arg: array of Object; ec: ExecutionContext): Object

static Object CallHelper(Object Ref, Object aSelf, Object[] arg, ExecutionContext ec)

static func CallHelper(_ Ref: Object, _ aSelf: Object, _ arg: Object..., _ ec: ExecutionContext) -> Object

Shared Function CallHelper(Ref As Object, aSelf As Object, arg As Object(), ec As ExecutionContext) As Object

method CanPut(name: String): Boolean

Boolean CanPut(String name)

func CanPut(_ name: String) -> Boolean

Function CanPut(name As String) As Boolean

property Class: String read write;

String Class { get; set; }

var Class: String { get{} set{} }

Property Class() As String

method Construct(context: ExecutionContext; params args: array of Object): Object

Object Construct(ExecutionContext context, params Object[] args)

func Construct(_ context: ExecutionContext, _ args: Object...) -> Object

Function Construct(context As ExecutionContext, ParamArray args As Object()) As Object

class var Constructor: ConstructorInfo;

static ConstructorInfo Constructor

static var Constructor: ConstructorInfo

Shared FIELD Constructor() As ConstructorInfo

method CreateArray: EcmaScriptObject

EcmaScriptObject CreateArray()

func CreateArray() -> EcmaScriptObject

Function CreateArray() As EcmaScriptObject

method CreateBoolean: EcmaScriptObject

EcmaScriptObject CreateBoolean()

func CreateBoolean() -> EcmaScriptObject

Function CreateBoolean() As EcmaScriptObject

method CreateDate: EcmaScriptObject

EcmaScriptObject CreateDate()

func CreateDate() -> EcmaScriptObject

Function CreateDate() As EcmaScriptObject

method CreateDateObject(date: DateTime): Object

Object CreateDateObject(DateTime date)

func CreateDateObject(_ date: DateTime) -> Object

Function CreateDateObject(date As DateTime) As Object

method CreateError: EcmaScriptObject

EcmaScriptObject CreateError()

func CreateError() -> EcmaScriptObject

Function CreateError() As EcmaScriptObject

method CreateFunction: EcmaScriptObject

EcmaScriptObject CreateFunction()

func CreateFunction() -> EcmaScriptObject

Function CreateFunction() As EcmaScriptObject

method CreateFunctionPrototype

void CreateFunctionPrototype()

func CreateFunctionPrototype()

Sub CreateFunctionPrototype()

method CreateJSON: EcmaScriptObject

EcmaScriptObject CreateJSON()

func CreateJSON() -> EcmaScriptObject

Function CreateJSON() As EcmaScriptObject

method CreateMath: EcmaScriptObject

EcmaScriptObject CreateMath()

func CreateMath() -> EcmaScriptObject

Function CreateMath() As EcmaScriptObject

method CreateNativeError: EcmaScriptObject

EcmaScriptObject CreateNativeError()

func CreateNativeError() -> EcmaScriptObject

Function CreateNativeError() As EcmaScriptObject

method CreateNumber: EcmaScriptObject

EcmaScriptObject CreateNumber()

func CreateNumber() -> EcmaScriptObject

Function CreateNumber() As EcmaScriptObject

method CreateObject: EcmaScriptObject

EcmaScriptObject CreateObject()

func CreateObject() -> EcmaScriptObject

Function CreateObject() As EcmaScriptObject

method CreateRegExp: EcmaScriptObject

EcmaScriptObject CreateRegExp()

func CreateRegExp() -> EcmaScriptObject

Function CreateRegExp() As EcmaScriptObject

method CreateString: EcmaScriptObject

EcmaScriptObject CreateString()

func CreateString() -> EcmaScriptObject

Function CreateString() As EcmaScriptObject

method DateCall(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateCall(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateCall(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateCall(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateCtor(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateCtor(ExecutionContext caller, Object self, params Object[] args)

func DateCtor(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateCtor(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateGetDate(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetDate(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetDate(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetDate(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetDay(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetDay(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetDay(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetDay(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetFullYear(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetFullYear(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetFullYear(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetFullYear(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetHours(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetHours(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetHours(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetHours(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetMilliseconds(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetMilliseconds(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetMilliseconds(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetMilliseconds(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetMinutes(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetMinutes(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetMinutes(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetMinutes(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetMonth(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetMonth(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetMonth(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetMonth(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetSeconds(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetSeconds(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetSeconds(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetSeconds(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetTime(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetTime(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetTime(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetTime(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetTimezoneOffset(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetTimezoneOffset(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetTimezoneOffset(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetTimezoneOffset(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetUTCDate(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetUTCDate(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetUTCDate(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetUTCDate(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetUTCDay(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetUTCDay(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetUTCDay(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetUTCDay(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetUTCFullYear(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetUTCFullYear(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetUTCFullYear(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetUTCFullYear(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetUTCHours(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetUTCHours(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetUTCHours(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetUTCHours(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetUTCMilliseconds(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetUTCMilliseconds(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetUTCMilliseconds(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetUTCMilliseconds(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetUTCMinutes(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetUTCMinutes(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetUTCMinutes(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetUTCMinutes(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetUTCMonth(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateGetUTCMonth(ExecutionContext caller, Object self, params Object[] args)

func DateGetUTCMonth(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateGetUTCMonth(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateGetUTCSeconds(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetUTCSeconds(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetUTCSeconds(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetUTCSeconds(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateGetYear(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateGetYear(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateGetYear(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateGetYear(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateNow(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateNow(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateNow(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateNow(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateParse(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateParse(ExecutionContext caller, Object self, params Object[] args)

func DateParse(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateParse(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

property DatePrototype: EcmaScriptObject read write;

EcmaScriptObject DatePrototype { get; set; }

var DatePrototype: EcmaScriptObject { get{} set{} }

Property DatePrototype() As EcmaScriptObject

method DateSetDate(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetDate(ExecutionContext caller, Object self, params Object[] args)

func DateSetDate(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetDate(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetFullYear(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetFullYear(ExecutionContext caller, Object self, params Object[] args)

func DateSetFullYear(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetFullYear(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetHours(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetHours(ExecutionContext caller, Object self, params Object[] args)

func DateSetHours(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetHours(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetMilliseconds(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetMilliseconds(ExecutionContext caller, Object self, params Object[] args)

func DateSetMilliseconds(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetMilliseconds(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetMinutes(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetMinutes(ExecutionContext caller, Object self, params Object[] args)

func DateSetMinutes(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetMinutes(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetMonth(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetMonth(ExecutionContext caller, Object self, params Object[] args)

func DateSetMonth(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetMonth(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetSeconds(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetSeconds(ExecutionContext caller, Object self, params Object[] args)

func DateSetSeconds(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetSeconds(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetTime(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetTime(ExecutionContext caller, Object self, params Object[] args)

func DateSetTime(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetTime(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetUTCDate(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetUTCDate(ExecutionContext caller, Object self, params Object[] args)

func DateSetUTCDate(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetUTCDate(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetUTCFullYear(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetUTCFullYear(ExecutionContext caller, Object self, params Object[] args)

func DateSetUTCFullYear(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetUTCFullYear(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetUTCHours(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetUTCHours(ExecutionContext caller, Object self, params Object[] args)

func DateSetUTCHours(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetUTCHours(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetUTCMilliseconds(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetUTCMilliseconds(ExecutionContext caller, Object self, params Object[] args)

func DateSetUTCMilliseconds(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetUTCMilliseconds(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetUTCMinutes(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetUTCMinutes(ExecutionContext caller, Object self, params Object[] args)

func DateSetUTCMinutes(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetUTCMinutes(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetUTCMonth(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetUTCMonth(ExecutionContext caller, Object self, params Object[] args)

func DateSetUTCMonth(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetUTCMonth(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateSetUTCSeconds(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateSetUTCSeconds(ExecutionContext caller, Object self, params Object[] args)

func DateSetUTCSeconds(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateSetUTCSeconds(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

class method DateTimeToUnix(date: DateTime): Int64

static Int64 DateTimeToUnix(DateTime date)

static func DateTimeToUnix(_ date: DateTime) -> Int64

Shared Function DateTimeToUnix(date As DateTime) As Int64

method DateToDateString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateToDateString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateToDateString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateToDateString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateToISOString(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateToISOString(ExecutionContext caller, Object self, params Object[] args)

func DateToISOString(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateToISOString(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateToJSON(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateToJSON(ExecutionContext caller, Object self, params Object[] args)

func DateToJSON(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateToJSON(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateToLocaleDateString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateToLocaleDateString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateToLocaleDateString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateToLocaleDateString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateToLocaleString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateToLocaleString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateToLocaleString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateToLocaleString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateToLocaleTimeString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateToLocaleTimeString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateToLocaleTimeString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateToLocaleTimeString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateToString(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateToString(ExecutionContext caller, Object self, params Object[] args)

func DateToString(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateToString(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateToTimeString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateToTimeString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateToTimeString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateToTimeString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateToUTCString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DateToUTCString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DateToUTCString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DateToUTCString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DateUTC(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object DateUTC(ExecutionContext caller, Object self, params Object[] args)

func DateUTC(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function DateUTC(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method DateValueOf(caller: ExecutionContext; instance: Object; params args: array of Object): Object

Object DateValueOf(ExecutionContext caller, Object instance, params Object[] args)

func DateValueOf(_ caller: ExecutionContext, _ instance: Object, _ args: Object...) -> Object

Function DateValueOf(caller As ExecutionContext, instance As Object, ParamArray args As Object()) As Object

property Debug: IDebugSink read write;

IDebugSink Debug { get; set; }

var Debug: IDebugSink { get{} set{} }

Property Debug() As IDebugSink

method decodeURI(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object decodeURI(ExecutionContext aCaller, Object aSelf, params Object[] args)

func decodeURI(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function decodeURI(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method decodeURIComponent(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object decodeURIComponent(ExecutionContext aCaller, Object aSelf, params Object[] args)

func decodeURIComponent(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function decodeURIComponent(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method DecreaseFrame

void DecreaseFrame()

func DecreaseFrame()

Sub DecreaseFrame()

method DefaultCompare(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object DefaultCompare(ExecutionContext aCaller, Object aSelf, params Object[] args)

func DefaultCompare(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function DefaultCompare(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property DefaultCompareInstance: EcmaScriptFunctionObject read write;

EcmaScriptFunctionObject DefaultCompareInstance { get; set; }

var DefaultCompareInstance: EcmaScriptFunctionObject { get{} set{} }

Property DefaultCompareInstance() As EcmaScriptFunctionObject

method DefineOwnProperty(aName: String; aValue: PropertyValue; aThrow: Boolean := true): Boolean

Boolean DefineOwnProperty(String aName, PropertyValue aValue, Boolean aThrow = true)

func DefineOwnProperty(_ aName: String, _ aValue: PropertyValue, _ aThrow: Boolean = true) -> Boolean

Function DefineOwnProperty(aName As String, aValue As PropertyValue, aThrow As Boolean = true) As Boolean

method Delete(aName: String; aThrow: Boolean): Boolean

Boolean Delete(String aName, Boolean aThrow)

func Delete(_ aName: String, _ aThrow: Boolean) -> Boolean

Function Delete(aName As String, aThrow As Boolean) As Boolean

method encodeURI(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object encodeURI(ExecutionContext aCaller, Object aSelf, params Object[] args)

func encodeURI(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function encodeURI(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method encodeURIComponent(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object encodeURIComponent(ExecutionContext aCaller, Object aSelf, params Object[] args)

func encodeURIComponent(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function encodeURIComponent(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ErrorCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ErrorCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ErrorCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ErrorCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property ErrorPrototype: EcmaScriptObject read write;

EcmaScriptObject ErrorPrototype { get; set; }

var ErrorPrototype: EcmaScriptObject { get{} set{} }

Property ErrorPrototype() As EcmaScriptObject

method ErrorToString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ErrorToString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ErrorToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ErrorToString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method escape(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object escape(ExecutionContext aCaller, Object aSelf, params Object[] args)

func escape(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function escape(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method eval(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object eval(ExecutionContext aCaller, Object aSelf, params Object[] args)

func eval(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function eval(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property EvalError: EcmaScriptObject read write;

EcmaScriptObject EvalError { get; set; }

var EvalError: EcmaScriptObject { get{} set{} }

Property EvalError() As EcmaScriptObject

method EvalErrorCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object EvalErrorCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func EvalErrorCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function EvalErrorCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property ExecutionContext: ExecutionContext read write;

ExecutionContext ExecutionContext { get; set; }

var ExecutionContext: ExecutionContext { get{} set{} }

Property ExecutionContext() As ExecutionContext

property Extensible: Boolean read write;

Boolean Extensible { get; set; }

var Extensible: Boolean { get{} set{} }

Property Extensible() As Boolean

property FrameCount: Int32 read write;

Int32 FrameCount { get; set; }

var FrameCount: Int32 { get{} set{} }

Property FrameCount() As Int32

method FromPropertyDescriptor(aProp: PropertyValue): EcmaScriptObject

EcmaScriptObject FromPropertyDescriptor(PropertyValue aProp)

func FromPropertyDescriptor(_ aProp: PropertyValue) -> EcmaScriptObject

Function FromPropertyDescriptor(aProp As PropertyValue) As EcmaScriptObject

method FunctionApply(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object FunctionApply(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func FunctionApply(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function FunctionApply(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method FunctionBind(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object FunctionBind(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func FunctionBind(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function FunctionBind(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method FunctionCall(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object FunctionCall(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func FunctionCall(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function FunctionCall(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method FunctionCtor(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object FunctionCtor(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func FunctionCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function FunctionCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method FunctionProtoCtor(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object FunctionProtoCtor(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func FunctionProtoCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function FunctionProtoCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

property FunctionPrototype: EcmaScriptObject read write;

EcmaScriptObject FunctionPrototype { get; set; }

var FunctionPrototype: EcmaScriptObject { get{} set{} }

Property FunctionPrototype() As EcmaScriptObject

method FunctionToString(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object FunctionToString(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func FunctionToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function FunctionToString(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Get(aExecutionContext: ExecutionContext := nil; aFlags: Int32 := 0; aName: String): Object

Object Get(ExecutionContext aExecutionContext = null, Int32 aFlags = 0, String aName)

func Get(_ aExecutionContext: ExecutionContext = nil, _ aFlags: Int32 = 0, _ aName: String) -> Object

Function Get(aExecutionContext As ExecutionContext = Nothing, aFlags As Int32 = 0, aName As String) As Object

method GetFunction(i: Int32): InternalFunctionDelegate

InternalFunctionDelegate GetFunction(Int32 i)

func GetFunction(_ i: Int32) -> InternalFunctionDelegate

Function GetFunction(i As Int32) As InternalFunctionDelegate

method GetNames: IEnumerator<String>

IEnumerator<String> GetNames()

func GetNames() -> IEnumerator<String>

Function GetNames() As IEnumerator<String>

method GetOwnProperty(name: String): PropertyValue

PropertyValue GetOwnProperty(String name)

func GetOwnProperty(_ name: String) -> PropertyValue

Function GetOwnProperty(name As String) As PropertyValue

method GetOwnProperty(name: String; getPropertyValue: Boolean): PropertyValue

PropertyValue GetOwnProperty(String name, Boolean getPropertyValue)

func GetOwnProperty(_ name: String, _ getPropertyValue: Boolean) -> PropertyValue

Function GetOwnProperty(name As String, getPropertyValue As Boolean) As PropertyValue

method GetProperty(name: String): PropertyValue

PropertyValue GetProperty(String name)

func GetProperty(_ name: String) -> PropertyValue

Function GetProperty(name As String) As PropertyValue

method HasProperty(aName: String): Boolean

Boolean HasProperty(String aName)

func HasProperty(_ aName: String) -> Boolean

Function HasProperty(aName As String) As Boolean

method IncreaseFrame

void IncreaseFrame()

func IncreaseFrame()

Sub IncreaseFrame()

method InnerCompile(strict: Boolean; script: String): InternalDelegate

InternalDelegate InnerCompile(Boolean strict, String script)

func InnerCompile(_ strict: Boolean, _ script: String) -> InternalDelegate

Function InnerCompile(strict As Boolean, script As String) As InternalDelegate

method InnerEval(caller: ExecutionContext; strict: Boolean; self: Object; evalDelegate: InternalDelegate): Object

Object InnerEval(ExecutionContext caller, Boolean strict, Object self, InternalDelegate evalDelegate)

func InnerEval(_ caller: ExecutionContext, _ strict: Boolean, _ self: Object, _ evalDelegate: InternalDelegate) -> Object

Function InnerEval(caller As ExecutionContext, strict As Boolean, self As Object, evalDelegate As InternalDelegate) As Object

method InnerEval(caller: ExecutionContext; strict: Boolean; self: Object; params args: array of Object): Object

Object InnerEval(ExecutionContext caller, Boolean strict, Object self, params Object[] args)

func InnerEval(_ caller: ExecutionContext, _ strict: Boolean, _ self: Object, _ args: Object...) -> Object

Function InnerEval(caller As ExecutionContext, strict As Boolean, self As Object, ParamArray args As Object()) As Object

method InnerEval(strict: Boolean; evalDelegate: InternalDelegate): Object

Object InnerEval(Boolean strict, InternalDelegate evalDelegate)

func InnerEval(_ strict: Boolean, _ evalDelegate: InternalDelegate) -> Object

Function InnerEval(strict As Boolean, evalDelegate As InternalDelegate) As Object

method InnerEval(strict: Boolean; params args: array of Object): Object

Object InnerEval(Boolean strict, params Object[] args)

func InnerEval(_ strict: Boolean, _ args: Object...) -> Object

Function InnerEval(strict As Boolean, ParamArray args As Object()) As Object

method InnerExecutionContext(caller: ExecutionContext; strict: Boolean): ExecutionContext

ExecutionContext InnerExecutionContext(ExecutionContext caller, Boolean strict)

func InnerExecutionContext(_ caller: ExecutionContext, _ strict: Boolean) -> ExecutionContext

Function InnerExecutionContext(caller As ExecutionContext, strict As Boolean) As ExecutionContext

method IntGetNames: IEnumerable<String>

IEnumerable<String> IntGetNames()

func IntGetNames() -> IEnumerable<String>

Function IntGetNames() As IEnumerable<String>

method IsAccessorDescriptor(aProp: PropertyValue): Boolean

Boolean IsAccessorDescriptor(PropertyValue aProp)

func IsAccessorDescriptor(_ aProp: PropertyValue) -> Boolean

Function IsAccessorDescriptor(aProp As PropertyValue) As Boolean

method IsDataDescriptor(aProp: PropertyValue): Boolean

Boolean IsDataDescriptor(PropertyValue aProp)

func IsDataDescriptor(_ aProp: PropertyValue) -> Boolean

Function IsDataDescriptor(aProp As PropertyValue) As Boolean

method isFinite(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object isFinite(ExecutionContext aCaller, Object aSelf, params Object[] args)

func isFinite(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function isFinite(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method IsGenericDescriptor(aProp: PropertyValue): Boolean

Boolean IsGenericDescriptor(PropertyValue aProp)

func IsGenericDescriptor(_ aProp: PropertyValue) -> Boolean

Function IsGenericDescriptor(aProp As PropertyValue) As Boolean

method isNaN(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object isNaN(ExecutionContext aCaller, Object aSelf, params Object[] args)

func isNaN(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function isNaN(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method JSONParse(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object JSONParse(ExecutionContext aCaller, Object aSelf, params Object[] args)

func JSONParse(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function JSONParse(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method JSONParse(aTok: Tokenizer): Object

Object JSONParse(Tokenizer aTok)

func JSONParse(_ aTok: Tokenizer) -> Object

Function JSONParse(aTok As Tokenizer) As Object

method JSONStringify(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object JSONStringify(ExecutionContext aCaller, Object aSelf, params Object[] args)

func JSONStringify(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function JSONStringify(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method MatchToArray(aSelf: EcmaScriptRegexpObject; aInput: String; aMatch: MatchCollection): EcmaScriptArrayObject

EcmaScriptArrayObject MatchToArray(EcmaScriptRegexpObject aSelf, String aInput, MatchCollection aMatch)

func MatchToArray(_ aSelf: EcmaScriptRegexpObject, _ aInput: String, _ aMatch: MatchCollection) -> EcmaScriptArrayObject

Function MatchToArray(aSelf As EcmaScriptRegexpObject, aInput As String, aMatch As MatchCollection) As EcmaScriptArrayObject

method Mathabs(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathabs(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathabs(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathabs(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathacos(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathacos(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathacos(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathacos(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathasin(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathasin(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathasin(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathasin(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathatan(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathatan(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathatan(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathatan(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathatan2(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathatan2(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathatan2(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathatan2(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathceil(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathceil(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathceil(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathceil(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathcos(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathcos(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathcos(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathcos(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathexp(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathexp(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathexp(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathexp(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathfloor(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathfloor(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathfloor(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathfloor(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathlog(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathlog(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathlog(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathlog(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method MathMax(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object MathMax(ExecutionContext caller, Object self, params Object[] args)

func MathMax(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function MathMax(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method MathMin(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object MathMin(ExecutionContext caller, Object self, params Object[] args)

func MathMin(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function MathMin(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method Mathpow(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathpow(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathpow(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathpow(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathrandom(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathrandom(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathrandom(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathrandom(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathround(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathround(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathround(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathround(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathsin(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathsin(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathsin(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathsin(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathsqrt(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathsqrt(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathsqrt(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathsqrt(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method Mathtan(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object Mathtan(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func Mathtan(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function Mathtan(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

property MaxFrames: Int32 read write;

Int32 MaxFrames { get; set; }

var MaxFrames: Int32 { get{} set{} }

Property MaxFrames() As Int32

class var Method_Call: MethodInfo;

static MethodInfo Method_Call

static var Method_Call: MethodInfo

Shared FIELD Method_Call() As MethodInfo

class var Method_CallEx: MethodInfo;

static MethodInfo Method_CallEx

static var Method_CallEx: MethodInfo

Shared FIELD Method_CallEx() As MethodInfo

class var Method_CallHelper: MethodInfo;

static MethodInfo Method_CallHelper

static var Method_CallHelper: MethodInfo

Shared FIELD Method_CallHelper() As MethodInfo

class var Method_Construct: MethodInfo;

static MethodInfo Method_Construct

static var Method_Construct: MethodInfo

Shared FIELD Method_Construct() As MethodInfo

class var Method_DecreaseFrame: MethodInfo;

static MethodInfo Method_DecreaseFrame

static var Method_DecreaseFrame: MethodInfo

Shared FIELD Method_DecreaseFrame() As MethodInfo

class var Method_GetFunction: MethodInfo;

static MethodInfo Method_GetFunction

static var Method_GetFunction: MethodInfo

Shared FIELD Method_GetFunction() As MethodInfo

class var Method_GetNames: MethodInfo;

static MethodInfo Method_GetNames

static var Method_GetNames: MethodInfo

Shared FIELD Method_GetNames() As MethodInfo

class var Method_IncreaseFrame: MethodInfo;

static MethodInfo Method_IncreaseFrame

static var Method_IncreaseFrame: MethodInfo

Shared FIELD Method_IncreaseFrame() As MethodInfo

class var Method_ObjectLiteralSet: MethodInfo;

static MethodInfo Method_ObjectLiteralSet

static var Method_ObjectLiteralSet: MethodInfo

Shared FIELD Method_ObjectLiteralSet() As MethodInfo

class var Method_RaiseNativeError: MethodInfo;

static MethodInfo Method_RaiseNativeError

static var Method_RaiseNativeError: MethodInfo

Shared FIELD Method_RaiseNativeError() As MethodInfo

property Names: IEnumerable<String> read;

IEnumerable<String> Names { get; }

var Names: IEnumerable<String> { get{} }

ReadOnly Property Names() As IEnumerable<String>

method NativeErrorCtor(proto: EcmaScriptObject; arg: String): EcmaScriptObject

EcmaScriptObject NativeErrorCtor(EcmaScriptObject proto, String arg)

func NativeErrorCtor(_ proto: EcmaScriptObject, _ arg: String) -> EcmaScriptObject

Function NativeErrorCtor(proto As EcmaScriptObject, arg As String) As EcmaScriptObject

property NativePrototype: EcmaScriptObject read write;

EcmaScriptObject NativePrototype { get; set; }

var NativePrototype: EcmaScriptObject { get{} set{} }

Property NativePrototype() As EcmaScriptObject

method NativeToString(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object NativeToString(ExecutionContext caller, Object self, params Object[] args)

func NativeToString(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function NativeToString(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method NotStrictGlobalEval(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NotStrictGlobalEval(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NotStrictGlobalEval(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NotStrictGlobalEval(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property NotStrictGlobalEvalFunc: EcmaScriptFunctionObject read write;

EcmaScriptFunctionObject NotStrictGlobalEvalFunc { get; set; }

var NotStrictGlobalEvalFunc: EcmaScriptFunctionObject { get{} set{} }

Property NotStrictGlobalEvalFunc() As EcmaScriptFunctionObject

method NumberCall(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NumberCall(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NumberCall(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NumberCall(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method NumberCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NumberCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NumberCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NumberCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method NumberLocaleString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NumberLocaleString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NumberLocaleString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NumberLocaleString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property NumberPrototype: EcmaScriptObject read write;

EcmaScriptObject NumberPrototype { get; set; }

var NumberPrototype: EcmaScriptObject { get{} set{} }

Property NumberPrototype() As EcmaScriptObject

method NumberToExponential(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NumberToExponential(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NumberToExponential(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NumberToExponential(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method NumberToFixed(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NumberToFixed(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NumberToFixed(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NumberToFixed(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method NumberToPrecision(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NumberToPrecision(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NumberToPrecision(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NumberToPrecision(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method NumberToString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object NumberToString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func NumberToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function NumberToString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method NumberValueOf(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object NumberValueOf(ExecutionContext caller, Object self, params Object[] args)

func NumberValueOf(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function NumberValueOf(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method ObjectCreate(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectCreate(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectCreate(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectCreate(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectdefineProperties(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectdefineProperties(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectdefineProperties(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectdefineProperties(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectdefineProperty(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectdefineProperty(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectdefineProperty(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectdefineProperty(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectFreeze(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectFreeze(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectFreeze(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectFreeze(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectgetOwnPropertyDescriptor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectgetOwnPropertyDescriptor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectgetOwnPropertyDescriptor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectgetOwnPropertyDescriptor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectgetOwnPropertyNames(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectgetOwnPropertyNames(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectgetOwnPropertyNames(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectgetOwnPropertyNames(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectgetPrototypeOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectgetPrototypeOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectgetPrototypeOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectgetPrototypeOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectHasOwnProperty(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectHasOwnProperty(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectHasOwnProperty(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectHasOwnProperty(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectisExtensible(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectisExtensible(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectisExtensible(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectisExtensible(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectisFrozen(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectisFrozen(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectisFrozen(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectisFrozen(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectIsPrototypeOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectIsPrototypeOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectIsPrototypeOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectIsPrototypeOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectisSealed(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectisSealed(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectisSealed(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectisSealed(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectKeys(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectKeys(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectKeys(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectKeys(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectLiteralSet(aName: String; aMode: FunctionDeclarationType; aData: Object; aStrict: Boolean): EcmaScriptObject

EcmaScriptObject ObjectLiteralSet(String aName, FunctionDeclarationType aMode, Object aData, Boolean aStrict)

func ObjectLiteralSet(_ aName: String, _ aMode: FunctionDeclarationType, _ aData: Object, _ aStrict: Boolean) -> EcmaScriptObject

Function ObjectLiteralSet(aName As String, aMode As FunctionDeclarationType, aData As Object, aStrict As Boolean) As EcmaScriptObject

method ObjectPreventExtensions(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectPreventExtensions(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectPreventExtensions(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectPreventExtensions(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectPropertyIsEnumerable(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectPropertyIsEnumerable(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectPropertyIsEnumerable(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectPropertyIsEnumerable(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property ObjectPrototype: EcmaScriptObject read write;

EcmaScriptObject ObjectPrototype { get; set; }

var ObjectPrototype: EcmaScriptObject { get{} set{} }

Property ObjectPrototype() As EcmaScriptObject

method ObjectSeal(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectSeal(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectSeal(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectSeal(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectToLocaleString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectToLocaleString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectToLocaleString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectToLocaleString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectToString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectToString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectToString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method ObjectValueOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ObjectValueOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ObjectValueOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ObjectValueOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method parseFloat(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object parseFloat(ExecutionContext aCaller, Object aSelf, params Object[] args)

func parseFloat(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function parseFloat(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method parseInt(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object parseInt(ExecutionContext aCaller, Object aSelf, params Object[] args)

func parseInt(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function parseInt(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property Parser: EcmaScriptCompiler read write;

EcmaScriptCompiler Parser { get; set; }

var Parser: EcmaScriptCompiler { get{} set{} }

Property Parser() As EcmaScriptCompiler

property Prototype: EcmaScriptObject read write;

EcmaScriptObject Prototype { get; set; }

var Prototype: EcmaScriptObject { get{} set{} }

Property Prototype() As EcmaScriptObject

method Put(context: ExecutionContext := nil; propertyName: String; propertyValue: Object; flags: Int32 := 1): Object

Object Put(ExecutionContext context = null, String propertyName, Object propertyValue, Int32 flags = 1)

func Put(_ context: ExecutionContext = nil, _ propertyName: String, _ propertyValue: Object, _ flags: Int32 = 1) -> Object

Function Put(context As ExecutionContext = Nothing, propertyName As String, propertyValue As Object, flags As Int32 = 1) As Object

method RaiseNativeError(e: NativeErrorType; msg: String)

void RaiseNativeError(NativeErrorType e, String msg)

func RaiseNativeError(_ e: NativeErrorType, _ msg: String)

Sub RaiseNativeError(e As NativeErrorType, msg As String)

property RangeError: EcmaScriptObject read write;

EcmaScriptObject RangeError { get; set; }

var RangeError: EcmaScriptObject { get{} set{} }

Property RangeError() As EcmaScriptObject

method RangeErrorCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object RangeErrorCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func RangeErrorCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function RangeErrorCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property ReferenceError: EcmaScriptObject read write;

EcmaScriptObject ReferenceError { get; set; }

var ReferenceError: EcmaScriptObject { get{} set{} }

Property ReferenceError() As EcmaScriptObject

method ReferenceErrorCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object ReferenceErrorCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func ReferenceErrorCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function ReferenceErrorCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method RegExpCompile(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object RegExpCompile(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func RegExpCompile(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function RegExpCompile(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method RegExpCtor(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object RegExpCtor(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func RegExpCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function RegExpCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method RegExpExec(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object RegExpExec(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func RegExpExec(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function RegExpExec(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

property RegExpPrototype: EcmaScriptObject read write;

EcmaScriptObject RegExpPrototype { get; set; }

var RegExpPrototype: EcmaScriptObject { get{} set{} }

Property RegExpPrototype() As EcmaScriptObject

method RegExpTest(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object RegExpTest(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func RegExpTest(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function RegExpTest(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

method RegExpToString(aCaller: ExecutionContext; aSelf: Object; params Args: array of Object): Object

Object RegExpToString(ExecutionContext aCaller, Object aSelf, params Object[] Args)

func RegExpToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ Args: Object...) -> Object

Function RegExpToString(aCaller As ExecutionContext, aSelf As Object, ParamArray Args As Object()) As Object

property Root: GlobalObject read write;

GlobalObject Root { get; set; }

var Root: GlobalObject { get{} set{} }

Property Root() As GlobalObject

method Sort<T>(aList: T; aStart: Int32; aEnd: Int32; aSwap: Action<T, Int32, Int32>; aCompare: Func<T, Int32, Int32, Int32>): Boolean

Boolean Sort<T>(T aList, Int32 aStart, Int32 aEnd, Action<T, Int32, Int32> aSwap, Func<T, Int32, Int32, Int32> aCompare)

func Sort<T>(_ aList: T, _ aStart: Int32, _ aEnd: Int32, _ aSwap: Action<T, Int32, Int32>, _ aCompare: Func<T, Int32, Int32, Int32>) -> Boolean

Function Sort<T>(aList As T, aStart As Int32, aEnd As Int32, aSwap As Action (Of T, Int32, Int32), aCompare As Func (Of T, Int32, Int32, Int32)) As Boolean

method StoreFunction(aDelegate: InternalFunctionDelegate): Int32

Int32 StoreFunction(InternalFunctionDelegate aDelegate)

func StoreFunction(_ aDelegate: InternalFunctionDelegate) -> Int32

Function StoreFunction(aDelegate As InternalFunctionDelegate) As Int32

method StringCall(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringCall(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringCall(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringCall(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringCharAt(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringCharAt(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringCharAt(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringCharAt(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringCharCodeAt(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringCharCodeAt(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringCharCodeAt(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringCharCodeAt(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringConcat(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringConcat(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringConcat(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringConcat(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringFromCharCode(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringFromCharCode(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringFromCharCode(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringFromCharCode(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringIndexOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringIndexOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringIndexOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringIndexOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringLastIndexOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringLastIndexOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringLastIndexOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringLastIndexOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringLocaleCompare(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringLocaleCompare(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringLocaleCompare(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringLocaleCompare(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringMatch(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringMatch(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringMatch(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringMatch(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property StringPrototype: EcmaScriptObject read write;

EcmaScriptObject StringPrototype { get; set; }

var StringPrototype: EcmaScriptObject { get{} set{} }

Property StringPrototype() As EcmaScriptObject

method StringReplace(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringReplace(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringReplace(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringReplace(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringSearch(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringSearch(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringSearch(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringSearch(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringSlice(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object StringSlice(ExecutionContext caller, Object self, params Object[] args)

func StringSlice(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function StringSlice(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method StringSplit(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object StringSplit(ExecutionContext caller, Object self, params Object[] args)

func StringSplit(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function StringSplit(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method StringSubStr(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object StringSubStr(ExecutionContext caller, Object self, params Object[] args)

func StringSubStr(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function StringSubStr(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method StringSubString(caller: ExecutionContext; self: Object; params args: array of Object): Object

Object StringSubString(ExecutionContext caller, Object self, params Object[] args)

func StringSubString(_ caller: ExecutionContext, _ self: Object, _ args: Object...) -> Object

Function StringSubString(caller As ExecutionContext, self As Object, ParamArray args As Object()) As Object

method StringToLocaleLowerCase(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringToLocaleLowerCase(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringToLocaleLowerCase(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringToLocaleLowerCase(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringToLocaleUpperCase(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringToLocaleUpperCase(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringToLocaleUpperCase(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringToLocaleUpperCase(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringToLowerCase(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringToLowerCase(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringToLowerCase(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringToLowerCase(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringToString(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringToString(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringToString(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringToString(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringToUpperCase(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringToUpperCase(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringToUpperCase(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringToUpperCase(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringTrim(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringTrim(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringTrim(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringTrim(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method StringValueOf(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object StringValueOf(ExecutionContext aCaller, Object aSelf, params Object[] args)

func StringValueOf(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function StringValueOf(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property SyntaxError: EcmaScriptObject read write;

EcmaScriptObject SyntaxError { get; set; }

var SyntaxError: EcmaScriptObject { get{} set{} }

Property SyntaxError() As EcmaScriptObject

method SyntaxErrorCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object SyntaxErrorCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func SyntaxErrorCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function SyntaxErrorCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property Thrower: EcmaScriptFunctionObject read write;

EcmaScriptFunctionObject Thrower { get; set; }

var Thrower: EcmaScriptFunctionObject { get{} set{} }

Property Thrower() As EcmaScriptFunctionObject

method ToPropertyDescriptor(aProp: EcmaScriptObject): PropertyValue

PropertyValue ToPropertyDescriptor(EcmaScriptObject aProp)

func ToPropertyDescriptor(_ aProp: EcmaScriptObject) -> PropertyValue

Function ToPropertyDescriptor(aProp As EcmaScriptObject) As PropertyValue

method ToString: String

String ToString()

func ToString() -> String

Function ToString() As String

property TypeError: EcmaScriptObject read write;

EcmaScriptObject TypeError { get; set; }

var TypeError: EcmaScriptObject { get{} set{} }

Property TypeError() As EcmaScriptObject

method TypeErrorCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object TypeErrorCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func TypeErrorCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function TypeErrorCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

method unescape(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object unescape(ExecutionContext aCaller, Object aSelf, params Object[] args)

func unescape(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function unescape(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

class method UnixToDateTime(date: Int64): DateTime

static DateTime UnixToDateTime(Int64 date)

static func UnixToDateTime(_ date: Int64) -> DateTime

Shared Function UnixToDateTime(date As Int64) As DateTime

property URIError: EcmaScriptObject read write;

EcmaScriptObject URIError { get; set; }

var URIError: EcmaScriptObject { get{} set{} }

Property URIError() As EcmaScriptObject

method URIErrorCtor(aCaller: ExecutionContext; aSelf: Object; params args: array of Object): Object

Object URIErrorCtor(ExecutionContext aCaller, Object aSelf, params Object[] args)

func URIErrorCtor(_ aCaller: ExecutionContext, _ aSelf: Object, _ args: Object...) -> Object

Function URIErrorCtor(aCaller As ExecutionContext, aSelf As Object, ParamArray args As Object()) As Object

property Value: Object read write;

Object Value { get; set; }

var Value: Object { get{} set{} }

Property Value() As Object

property Values: Dictionary<String, PropertyValue> read;

Dictionary<String, PropertyValue> Values { get; }

var Values: Dictionary<String, PropertyValue> { get{} }

ReadOnly Property Values() As Dictionary<String, PropertyValue>

method Walk(aCaller: ExecutionContext; aRoot: EcmaScriptObject; aReviver: EcmaScriptBaseFunctionObject; aName: String; aCurrent: EcmaScriptObject): Object

Object Walk(ExecutionContext aCaller, EcmaScriptObject aRoot, EcmaScriptBaseFunctionObject aReviver, String aName, EcmaScriptObject aCurrent)

func Walk(_ aCaller: ExecutionContext, _ aRoot: EcmaScriptObject, _ aReviver: EcmaScriptBaseFunctionObject, _ aName: String, _ aCurrent: EcmaScriptObject) -> Object

Function Walk(aCaller As ExecutionContext, aRoot As EcmaScriptObject, aReviver As EcmaScriptBaseFunctionObject, aName As String, aCurrent As EcmaScriptObject) As Object