internal static void Dir(FunctionObject func, CommonObject that, object value)
 {
    Console.BackgroundColor = ConsoleColor.Black;
    Console.ForegroundColor = ConsoleColor.Yellow;
    ObjectDumper.Write(value, 15);
    Console.ResetColor();
 }

 public ScriptRunner()
 {
     _context = new CSharp.Context();
     var file = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources/calculate.js");
     _context.ExecuteFile(file);
     _calculate = _context.Globals.GetT<FunctionObject>("calculate");
 }

        /// <summary>
        /// Opens a file, appends the specified string to the file, and then closes the file. If the file does not exist, this method creates a file, writes the specified string to the file, then closes the file.
        /// </summary>
        internal static void AppendJson(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue contents, BoxedValue onComplete, BoxedValue encodingName)
        {
            if (!path.IsString)
                throw new ArgumentException("[appendJson] First parameter should be defined and be a string.");
            if (!contents.IsStrictlyObject)
                throw new ArgumentException("[appendJson] Second parameter should be defined and be an object.");
            if (!onComplete.IsUndefined && !onComplete.IsFunction)
                throw new ArgumentException("[appendJson] Third parameter should be an onComplete function.");

            // Get the curent channel
            var channel = Channel.Current;

            // Dispatch the task
            channel.Async(() =>
            {
                // The encoding to use
                Encoding encoding = encodingName.IsString
                    ? TextEncoding.GetEncoding(encodingName.String)
                    : null;

                // Defaults to UTF8
                if (encoding == null)
                    encoding = TextEncoding.UTF8;

                // Unbox the array of lines and execute the append
                File.AppendAllText(
                    path.Unbox<string>(),
                    Native.Serialize(instance.Env, contents, false).Unbox<string>(),
                    encoding
                    );

                // Dispatch the on complete asynchronously
                channel.DispatchCallback(onComplete, instance);
            });
        }

 static void AddHandler(
     FunctionObject func, CommonObject that,
     string eventName, FunctionObject handler)
 {
     EventObject self = that.CastTo<EventObject>();
     self.AddHandler(eventName, handler);
 }

        /// <summary>
        /// Gets the session time.
        /// </summary>
        /// <param name="ctx">The function context.</param>
        /// <param name="instance">The console object instance.</param>
        /// <param name="eventName">The name of the event.</param>
        internal static BoxedValue GetConnectedFor(FunctionObject ctx, ScriptObject instance)
        {
            // Get the first client
            var client = Channel.Current.First;
            if (client == null)
                return Undefined.Boxed;

            // Return the address
            return BoxedValue.Box(
                client.Channel.ConnectedFor
                );
        }

        internal static void Log(FunctionObject func, CommonObject that, object value)
        {
            Console.BackgroundColor = ConsoleColor.Black;
            Console.ForegroundColor = ConsoleColor.Yellow;
            if(value is string)
                Console.WriteLine(value);
            else if (value is BoxedValue)
            {
                BoxedValue boxedValue = ((BoxedValue)value);
                Console.WriteLine(TypeConverter.ToString(boxedValue));
            }

            Console.ResetColor();
        }

        public ScriptEngineContext(IResourceManager resourceManager)
        {
            var envJs = resourceManager.GetStringFromAssemblyOf<ScriptEngine>("Forseti.Scripting.Scripts.env.js");

            _context = Context.enter();
            _context.setOptimizationLevel(-1);
            _scope = _context.initStandardObjects();

            Class myJClass = typeof(SystemConsole);
            Member method = myJClass.getMethod("Print", typeof(string));
            Scriptable function = new FunctionObject("print", method, _scope);
            _scope.put("print", _scope, function);

            SystemConsole.LoggingEnabled = false;
            _context.evaluateString(_scope, envJs, "env.js", 1, null);
            SystemConsole.LoggingEnabled = true;
        }

        void AddGlobalMethodsFromStaticMethodsInType(System.Type type, params string[] methodNames)
        {
            MethodInfo[] methods;
            var query = type.GetMethods(BindingFlags.Public | BindingFlags.Static).Select(m => m);
            if( methodNames.Length > 0 ) 
                query = query.Where(m => methodNames.Contains(m.Name));

            methods = query.ToArray();

            Class javaClass = type;
            foreach (var method in methods)
            {
                Member methodMember = javaClass.getMethod(method.Name, GetParametersForMethod(method));
                var functionName = method.Name.ToCamelCase();
                Scriptable methodFunction = new FunctionObject(functionName, methodMember, _scope);
                _scope.put(functionName, _scope, methodFunction);
            }
        }

 public Delegate CreateDelegate(object instance, EventInfo event_info, FunctionObject f, object script_delegate)
 {
     Type eventHandlerType = event_info.EventHandlerType;
     string name = event_info.Name;
     for (int i = 0; i < this.registered_event_handlers.Count; i++)
     {
         EventRec rec = this.registered_event_handlers[i] as EventRec;
         Delegate hostDelegate = rec.HostDelegate;
         if ((eventHandlerType == rec.EventHandlerType) && (name == rec.EventName))
         {
             EventRec rec2 = new EventRec();
             rec2.Sender = instance;
             rec2.EventHandlerType = eventHandlerType;
             rec2.ScriptDelegate = script_delegate;
             rec2.HostDelegate = hostDelegate;
             rec2.EventName = name;
             this.event_rec_list.Add(rec2);
             return hostDelegate;
         }
     }
     return null;
 }

 public static void Use(FunctionObject _, CommonObject that, CommonObject obj)
 {
     var configObj = that.CastTo<ConfigJsObject>();
     configObj.configBase.Use(typeof(JavaScriptApp), obj);
 }

 public static void Map(FunctionObject _, CommonObject that, string str, BoxedValue func)
 {
     var configObj = that.CastTo<ConfigJsObject>();
     configObj.configBase.Map(str, BuilderJsObject.MapBuilder(func.Func));
 }

 /// <summary>
 /// Creates a new inline group, indenting all following output by another level; unlike group(),
 /// this starts with the inline group collapsed, requiring the use of a disclosure button to
 /// expand it. To move back out a level, call groupEnd()
 /// </summary>
 /// <param name="ctx">The function context.</param>
 /// <param name="instance">The console object instance.</param>
 /// <param name="eventName">The name of the event.</param>
 /// <param name="eventValue">The value of the event.</param>
 internal static void GroupCollapsed(FunctionObject ctx, ScriptObject instance, BoxedValue eventValue)
 {
     ConsoleObject.SendEvent("groupCollapsed", eventValue);
 }

 public static void Run(FunctionObject _, CommonObject that, BoxedValue obj)
 {
     var configObj = that.CastTo<ConfigJsObject>();
     configObj.configBase.Run(new JavaScriptApp(obj.Object));
 }

 /// <summary>
 /// Displays an interactive listing of the properties of a specified JavaScript object. This 
 /// listing lets you use disclosure triangles to examine the contents of child objects.
 /// </summary>
 /// <param name="ctx">The function context.</param>
 /// <param name="instance">The console object instance.</param>
 /// <param name="eventName">The name of the event.</param>
 /// <param name="eventValue">The value of the event.</param>
 internal static void Dir(FunctionObject ctx, ScriptObject instance, BoxedValue eventValue)
 {
     ConsoleObject.SendEvent("dir", eventValue);
 }

 private void FindApplicableConstructorList(IntegerList a, IntegerList param_mod, ref FunctionObject best, ref IntegerList applicable_list)
 {
     for (int i = 0; i < base.Members.Count; i++) {
         MemberObject obj2 = base.Members[i];
         if ((obj2.Kind == MemberKind.Constructor) && !obj2.HasModifier(Modifier.Static)) {
             FunctionObject f = (FunctionObject)obj2;
             this.AddApplicableMethod(f, a, param_mod, 0, ref best, ref applicable_list);
         }
     }
     ClassObject ancestorClass = this.AncestorClass;
     if (!base.Imported) {
         if ((ancestorClass != null) && (best == null)) {
             ancestorClass.FindApplicableConstructorList(a, param_mod, ref best, ref applicable_list);
         }
     }
     else {
         IntegerList list = new IntegerList(false);
         foreach (ConstructorInfo info in this.ImportedType.GetConstructors()) {
             list.Add(base.Scripter.symbol_table.RegisterConstructor(info, base.Id));
         }
         if (base.Scripter.SearchProtected) {
             foreach (ConstructorInfo info2 in this.ImportedType.GetConstructors(base.Scripter.protected_binding_flags)) {
                 list.Add(base.Scripter.symbol_table.RegisterConstructor(info2, base.Id));
             }
         }
         for (int j = 0; j < list.Count; j++) {
             FunctionObject functionObject = base.Scripter.GetFunctionObject(list[j]);
             this.AddApplicableMethod(functionObject, a, param_mod, 0, ref best, ref applicable_list);
         }
         if ((ancestorClass != null) && (best == null)) {
             ancestorClass.FindApplicableConstructorList(a, param_mod, ref best, ref applicable_list);
         }
     }
 }

 static CommonObject ConstructHttp(FunctionObject ctor, CommonObject _, string x)
 {
     var prototype = ctor.GetT<CommonObject>("prototype");
     return new HttpObject(x, ctor.Env, prototype);
 }

 static CommonObject NewEditor(FunctionObject func, CommonObject that)
 {
     var self = that.CastTo<EditorProviderObject>();
     IEditor editor = self.provider.NewEditor();
     return new EditorObject(func.Env, self.editorPrototype, editor);
 }

 private void FindApplicableMethodList(int name_index, IntegerList a, IntegerList param_mod, int res_id, ref FunctionObject best, ref IntegerList applicable_list, bool upcase)
 {
     string upcaseNameByNameIndex = base.Scripter.GetUpcaseNameByNameIndex(name_index);
     for (int i = 0; i < base.Members.Count; i++) {
         MemberObject obj2 = base.Members[i];
         if (obj2.Kind == MemberKind.Method) {
             bool flag;
             if (upcase) {
                 flag = upcaseNameByNameIndex == obj2.UpcaseName;
             }
             else {
                 flag = obj2.NameIndex == name_index;
             }
             if (flag) {
                 FunctionObject f = (FunctionObject)obj2;
                 this.AddApplicableMethod(f, a, param_mod, res_id, ref best, ref applicable_list);
             }
         }
     }
     ClassObject ancestorClass = this.AncestorClass;
     if (!base.Imported) {
         if (ancestorClass != null) {
             ancestorClass.FindApplicableMethodList(name_index, a, param_mod, res_id, ref best, ref applicable_list, upcase);
         }
     }
     else {
         string str2 = base.Scripter.names[name_index];
         IntegerList list = new IntegerList(false);
         foreach (MethodInfo info in this.ImportedType.GetMethods()) {
             if (str2 == info.Name) {
                 bool flag2 = true;
                 foreach (Attribute attribute in Attribute.GetCustomAttributes(info)) {
                     if (attribute is CSLite_ScriptForbid) {
                         flag2 = false;
                     }
                 }
                 if (flag2) {
                     int avalue = base.Scripter.symbol_table.RegisterMethod(info, base.Id);
                     list.Add(avalue);
                 }
             }
         }
         if (base.Scripter.SearchProtected) {
             foreach (MethodInfo info2 in this.ImportedType.GetMethods(base.Scripter.protected_binding_flags)) {
                 if (str2 == info2.Name) {
                     bool flag3 = true;
                     foreach (Attribute attribute2 in Attribute.GetCustomAttributes(info2)) {
                         if (attribute2 is CSLite_ScriptForbid) {
                             flag3 = false;
                         }
                     }
                     if (flag3) {
                         int num3 = base.Scripter.symbol_table.RegisterMethod(info2, base.Id);
                         list.Add(num3);
                     }
                 }
             }
         }
         for (int j = 0; j < list.Count; j++) {
             FunctionObject functionObject = base.Scripter.GetFunctionObject(list[j]);
             this.AddApplicableMethod(functionObject, a, param_mod, res_id, ref best, ref applicable_list);
         }
         if (ancestorClass != null) {
             ancestorClass.FindApplicableMethodList(name_index, a, param_mod, res_id, ref best, ref applicable_list, upcase);
         }
         for (int k = 0; k < this.AncestorIds.Count; k++) {
             ClassObject classObject = base.Scripter.GetClassObject(this.AncestorIds[k]);
             if (classObject.IsInterface) {
                 classObject.FindApplicableMethodList(name_index, a, param_mod, res_id, ref best, ref applicable_list, upcase);
             }
         }
     }
 }

 /// <summary>
 /// Gets the hash code reference of the channel.
 /// </summary>
 /// <param name="ctx">The function context.</param>
 /// <param name="instance">The console object instance.</param>
 /// <param name="eventName">The name of the event.</param>
 internal static BoxedValue GetHashCode(FunctionObject ctx, ScriptObject instance)
 {
     // Return the address
     return BoxedValue.Box(
         Channel.Current.GetHashCode()
         );
 }

 static void Trigger(
     FunctionObject func, CommonObject that,
     string eventName, BoxedValue data)
 {
     EventObject self = that.CastTo<EventObject>();
     self.Trigger(eventName, data);
 }