static ScriptEngine CreateScriptEngineWithCoffeeScriptLoaded()
 {
     var engine = new ScriptEngine();
     engine.Execute(Properties.Resources.coffeescript);
     engine.Execute("function compile(c) { return CoffeeScript.compile(c); }");
     return engine;
 }

 private static object __GETTER__ToStringTag(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is SetIterator))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'get [Symbol.toStringTag]' is not generic.");
     return ((SetIterator)thisObj).ToStringTag;
 }

 private static object __GETTER__ByteLength(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is ArrayBufferInstance))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'get byteLength' is not generic.");
     return ((ArrayBufferInstance)thisObj).ByteLength;
 }

 public override string ToString(ScriptEngine engine)
 {
     string msg = engine.Pad() + "Return" + Environment.NewLine;
     engine.IndentationLevel += ScriptEngine.PaddingIncrement;
     msg += engine.Pad() + "LHS:" + Environment.NewLine;
     {
         engine.IndentationLevel += ScriptEngine.PaddingIncrement;
         for (int i = 0; i < _lhs.Count; i++)
         {
             msg += _lhs[i].ToString(engine);
         }
         engine.IndentationLevel -= ScriptEngine.PaddingIncrement;
     }
     msg += engine.Pad() + "RHS:" + Environment.NewLine;
     {
         engine.IndentationLevel += ScriptEngine.PaddingIncrement;
         for (int i = 0; i < _rhs.Count; i++)
         {
             msg += _rhs[i].ToString(engine);
         }
         engine.IndentationLevel -= ScriptEngine.PaddingIncrement;
     }
     engine.IndentationLevel -= ScriptEngine.PaddingIncrement;
     return msg;
 }

 public ResponseInstance(ScriptEngine engine, HttpListenerResponse response)
     : base(engine)
 {
     this.Response = response;
     this.PopulateFields();
     this.PopulateFunctions();
 }

 /// <summary>
 /// Creates a new FunctionContext instance.
 /// </summary>
 /// <param name="engine"> The script engine. </param>
 /// <param name="scope"> The function scope. </param>
 /// <param name="functionName"> The name of the function. </param>
 /// <param name="argumentNames"> The names of the arguments. </param>
 /// <param name="body"> The source code for the body of the function. </param>
 /// <param name="options"> Options that influence the compiler. </param>
 public FunctionMethodGenerator(ScriptEngine engine, DeclarativeScope scope, string functionName, IList<string> argumentNames, string body, CompilerOptions options)
     : base(engine, scope, new StringScriptSource(body), options)
 {
     this.Name = functionName;
     this.ArgumentNames = argumentNames;
     this.BodyText = body;
 }

 private static List<PropertyNameAndValue> GetDeclarativeProperties(ScriptEngine engine)
 {
     return new List<PropertyNameAndValue>(4)
     {
         new PropertyNameAndValue(engine.Symbol.Species, new PropertyDescriptor(new ClrStubFunction(engine.FunctionInstancePrototype, "get [Symbol.species]", 0, __GETTER__Species), null, PropertyAttributes.Configurable)),
     };
 }

 private static object __GETTER__Species(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is MapConstructor))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'get [Symbol.species]' is not generic.");
     return ((MapConstructor)thisObj).Species;
 }

        public override Token Build(Token lastToken, ScriptEngine engine, Script script, ref SourceCode sourceCode)
        {
            while ((++sourceCode).SpecialChar)
            {
            }
            if (sourceCode.Peek() != '{')
            {
                sourceCode.Throw(String.Format("Error parsing a 'do' statement, expected a '{' but got '{0}' instead.",
                                               sourceCode.Peek()));
            }
            List<List<List<Token>>> code = engine.BuildLongTokens(ref sourceCode, ref script, new[] {'}'});

            if (!sourceCode.SeekToNext("while"))
            {
                sourceCode.Throw("Error parsing a 'do' statement, was expecting a 'while' after the { } block.");
            }

            if (!sourceCode.SeekToNext('('))
            {
                sourceCode.Throw("Error parsing a 'do' statement, was expecting a '(' after 'while'.");
            }

            List<List<Token>> exitCondition = engine.BuildTokensAdvanced(ref sourceCode, ref script, new[] {')'});

            return new DoWhileToken(code, exitCondition);
        }

 /// <summary>
 /// Creates a new JavaScriptException instance.
 /// </summary>
 /// <param name="name"> The name of the error, e.g "RangeError". </param>
 /// <param name="message"> A description of the error. </param>
 /// <param name="lineNumber"> The line number in the source file the error occurred on. </param>
 /// <param name="sourcePath"> The path or URL of the source file.  Can be <c>null</c>. </param>
 public JavaScriptException(ScriptEngine engine, string name, string message, int lineNumber, string sourcePath)
     : base(string.Format("{0}: {1}", name, message))
 {
     this.ErrorObject = CreateError(engine, name, message);
     this.LineNumber = lineNumber;
     this.SourcePath = sourcePath;
 }

        public RequireJsCompiler(TextWriter consoleOut, string currentDirectory)
        {
            _jsEngine = new ScriptEngine();
            _jsEngine.CompatibilityMode = CompatibilityMode.ECMAScript3;

            _jsEngine.Evaluate(LoadResource("require.js"));
            _jsEngine.Evaluate(LoadResource("json2.js"));
            _jsEngine.Evaluate(LoadResource(@"adapt\rhino.js"));

            _jsEngine.Evaluate("require(" + new JavaScriptSerializer().Serialize(new {
                baseUrl = ResourceBaseUrl
            }) + ");");

            _fs = new NativeFS(_jsEngine, currentDirectory);
            _jsEngine.SetGlobalValue("YUNoFS", _fs);

            _path = new NativePath(_jsEngine, currentDirectory);
            _jsEngine.SetGlobalValue("YUNoPath", _path);

            _ioAdapter = new IOAdapter(_jsEngine, consoleOut);

            _jsEngine.SetGlobalFunction("load", (Action<string>)_ioAdapter.load);

            _jsEngine.SetGlobalValue("ioe", _ioAdapter);
            _jsEngine.SetGlobalValue("IsRunningYUNoAMD", true);

            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "env.js", @"build\jslib\env.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "yunoamd/args.js", @"build\jslib\yunoamd\args.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "build.js", @"build\build.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "print.js", @"build\jslib\yunoamd\print.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "fs.js", @"build\jslib\yunoamd\fs.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "path.js", @"build\jslib\yunoamd\path.js");
            SetupModuleFromResource(RequireJsCompiler.ResourceBaseUrl + "file.js", @"build\jslib\node\file.js");
        }

 internal Meta(ScriptEngine engine, ModelInstance instance)
     : base(engine, engine.Object.InstancePrototype)
 {
     this.PopulateFunctions();
     this.instance = instance;
     this.typeWrapper = new TypeWrapper(engine, instance.Type);
 }

 private static object __STUB__ToLocaleString(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is NumberInstance))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'toLocaleString' is not generic.");
     return ((NumberInstance)thisObj).ToLocaleString();
 }

 private static object __STUB__ValueOf(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is SymbolInstance))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'valueOf' is not generic.");
     return ((SymbolInstance)thisObj).ValueOf();
 }

 private static object __STUB__Call(ScriptEngine engine, object thisObj, object[] args)
 {
     thisObj = TypeConverter.ToObject(engine, thisObj);
     if (!(thisObj is MapConstructor))
         throw new JavaScriptException(engine, ErrorType.TypeError, "The method 'Call' is not generic.");
     return ((MapConstructor)thisObj).Call();
 }

        internal void HookUpScript(string scriptLanguage) {

            if (scriptLanguage == null) {
                // TODO: Need to revise this, we need to use the InvariantContext here probably
                // but it can't actually do calls yet.
                _scriptEngine = _defaultEngine;
                return;
            }

            _scriptEngine = EngineHelper.GetScriptEngineByName(scriptLanguage);
            _defaultEngine = _defaultEngine ?? _scriptEngine;

            _templateControlVirtualPath = VirtualPathUtility.ToAbsolute(_templateControl.AppRelativeVirtualPath);

            // First, look for a code behind file named <pagename>.aspx.<ext>, where 'ext' is the extension
            // for the page's language
            _inlineScript = false;
            IList<string> extensions = _scriptEngine.Setup.FileExtensions;
            foreach (string extension in extensions) {
                _scriptVirtualPath = _templateControlVirtualPath + extension;
                if (HookUpScriptFile()) {
                    return;
                }
            }

            // Then, look for inline script
            _inlineScript = true;
            _scriptVirtualPath = _templateControlVirtualPath;
            HookUpScriptFile();
        }

    public JSBlockType(ScriptEngine engine, string name)
        : base(engine)
    {
        this.PopulateFunctions();

        this.name = name;
    }

        public static ICollection<string> ReadAllTasks(string path)
        {
            var list = new List<string>();

            if (path.EndsWith(".ts"))
            {
                path = path.Replace(".ts", ".js").Replace(".coffee",".js");
            }

            if (!File.Exists(path))
            {
                return list;
            }

            // executes the gulpfile with some little additions :)
            try
            {
                var engine = new ScriptEngine();
                engine.Execute(Resources.gulpInit);
                engine.ExecuteFile(path);

                // reads the evaluated tasks
                ArrayInstance names = (ArrayInstance)engine.Evaluate("tasks");
                foreach (var elem in names.ElementValues)
                {
                    list.Add((string)elem);
                }
            }
            catch (Exception)
            {
                list.Add("Cannot parse gulpfile");
            }

            return list.Distinct().ToList();
        }

 public override void Execute(ScriptEngine engine, ScriptScope scope)
 {
     if (!string.IsNullOrEmpty(Path))
     {
         engine.ExecuteFile(Path, scope);
     }
 }

        /// <summary>
        /// Creates a new ClrStaticTypeWrapper object.
        /// </summary>
        /// <param name="engine"> The associated script engine. </param>
        /// <param name="type"> The CLR type to wrap. </param>
        /// <param name="flags"> <c>BindingFlags.Static</c> to populate static methods;
        /// <c>BindingFlags.Instance</c> to populate instance methods. </param>
        private ClrStaticTypeWrapper(ScriptEngine engine, Type type)
            : base(engine, GetPrototypeObject(engine, type))
        {
            this.WrappedType = type;

            // Pick up the public constructors, if any.
            var constructors = type.GetConstructors();
            if (constructors.Length > 0)
                this.constructBinder = new ClrBinder(constructors);
            else
            {
                // The built-in primitive types do not have constructors, but we still want to
                // allow their construction since there is no way to construct them otherwise.
                // Pretend that a constructor does exist.
                switch (Type.GetTypeCode(type))
                {
                    case TypeCode.Int32:
                        this.constructBinder = new ClrBinder(ReflectionHelpers.Convert_ToInt32_Double);
                        break;
                }
            }

            this.FastSetProperty("name", type.Name);
            if (this.constructBinder != null)
                this.FastSetProperty("length", this.constructBinder.FunctionLength);

            // Populate the fields, properties and methods.
            PopulateMembers(this, type, BindingFlags.Static);
        }