/**
                                * NodeJS specific Get module used to load remote resources.
                                * It contains the same signature as the default Get module so there is no code change needed.
                                * @module get-nodejs
                                * @class GetNodeJS
                                */
                            
                                var Module = require('module'),
                            
                                    path = require('path'),
                                    fs = require('fs'),
                                    request = require('request'),
                                    end = function(cb, msg, result) {
                                        //Y.log('Get end: ' + cb.onEnd);
                                        if (Y.Lang.isFunction(cb.onEnd)) {
                                            cb.onEnd.call(Y, msg, result);
                                        }
                                    }, pass = function(cb) {
                                        //Y.log('Get pass: ' + cb.onSuccess);
                                        if (Y.Lang.isFunction(cb.onSuccess)) {
                                            cb.onSuccess.call(Y, cb);
                                        }
                                        end(cb, 'success', 'success');
                                    }, fail = function(cb, er) {
                                        //Y.log('Get fail: ' + er);
                                        er.errors = [er];
                                        if (Y.Lang.isFunction(cb.onFailure)) {
                                            cb.onFailure.call(Y, er, cb);
                                        }
                                        end(cb, er, 'fail');
                                    };
                            
                            
                                Y.Get = function() {
                                };
                            
                                //Setup the default config base path
                                Y.config.base = path.join(__dirname, '../');
                            
                                YUI.require = require;
                                YUI.process = process;
                            
                                /**
                                * Takes the raw JS files and wraps them to be executed in the YUI context so they can be loaded
                                * into the YUI object
                                * @method _exec
                                * @private
                                * @param {String} data The JS to execute
                                * @param {String} url The path to the file that was parsed
                                * @param {Function} cb The callback to execute when this is completed
                                * @param {Error} cb.err=null Error object
                                * @param {String} cb.url The URL that was just parsed
                                */
                            
                                Y.Get._exec = function(data, url, cb) {
                                    if (data.charCodeAt(0) === 0xFEFF) {
                                        data = data.slice(1);
                                    }
                            
                                    var mod = new Module(url, module);
                                    mod.filename = url;
                                    mod.paths = Module._nodeModulePaths(path.dirname(url));
                                    if (typeof YUI._getLoadHook === 'function') {
                                        data = YUI._getLoadHook(data, url);
                                    }
                                    mod._compile('module.exports = function (YUI) {' +
                                        'return (function () {'+ data + '\n;return YUI;}).apply(global);' +
                                    '};', url);
                            
                                    /*global YUI:true */
                                    YUI = mod.exports(YUI);
                            
                                    mod.loaded = true;
                            
                                    cb(null, url);
                                };
                            
                                /**
                                * Fetches the content from a remote URL or a file from disc and passes the content
                                * off to `_exec` for parsing
                                * @method _include
                                * @private
                                * @param {String} url The URL/File path to fetch the content from
                                * @param {Function} cb The callback to fire once the content has been executed via `_exec`
                                */
                                Y.Get._include = function (url, cb) {
                                    var cfg,
                                        mod,
                                        self = this;
                            
                                    if (url.match(/^https?:\/\//)) {
                                        cfg = {
                                            url: url,
                                            timeout: self.timeout
                                        };
                                        request(cfg, function (err, response, body) {
                                            if (err) {
                                                Y.log(err, 'error', 'get');
                                                cb(err, url);
                                            } else {
                                                Y.Get._exec(body, url, cb);
                                            }
                                        });
                                    } else {
                                        try {
                                            // Try to resolve paths relative to the module that required yui.
                                            url = Module._findPath(url, Module._resolveLookupPaths(url, module.parent.parent)[1]);
                            
                                            if (Y.config.useSync) {
                                                //Needs to be in useSync
                                                mod = fs.readFileSync(url,'utf8');
                                            } else {
                                                fs.readFile(url, 'utf8', function (err, mod) {
                                                    if (err) {
                                                        cb(err, url);
                                                    } else {
                                                        Y.Get._exec(mod, url, cb);
                                                    }
                                                });
                                                return;
                                            }
                                        } catch (err) {
                                            cb(err, url);
                                            return;
                                        }
                            
                                        Y.Get._exec(mod, url, cb);
                                    }
                                };
                            
                            
                                /**
                                * Override for Get.script for loading local or remote YUI modules.
                                * @method js
                                * @param {Array|String} s The URL's to load into this context
                                * @param {Object} options Transaction options
                                */
                                Y.Get.js = function(s, options) {
                                    var urls = Y.Array(s), url, i, l = urls.length, c= 0,
                                        check = function() {
                                            if (c === l) {
                                                pass(options);
                                            }
                                        };
                            
                            
                                    /*jshint loopfunc: true */
                                    for (i=0; i<l; i++) {
                                        url = urls[i];
                                        if (Y.Lang.isObject(url)) {
                                            url = url.url;
                                        }
                            
                                        url = url.replace(/'/g, '%27');
                                        Y.log('URL: ' + url, 'info', 'get');
                                        Y.Get._include(url, function(err, url) {
                                            if (!Y.config) {
                                                Y.config = {
                                                    debug: true
                                                };
                                            }
                                            if (options.onProgress) {
                                                options.onProgress.call(options.context || Y, url);
                                            }
                                            Y.log('After Load: ' + url, 'info', 'get');
                                            if (err) {
                                                fail(options, err);
                                                Y.log('----------------------------------------------------------', 'error', 'get');
                                                Y.log(err, 'error', 'get');
                                                Y.log('----------------------------------------------------------', 'error', 'get');
                                            } else {
                                                c++;
                                                check();
                                            }
                                        });
                                    }
                            
                                    //Keeping Signature in the browser.
                                    return {
                                        execute: function() {}
                                    };
                                };
                            
                                /**
                                * Alias for `Y.Get.js`
                                * @method script
                                */
                                Y.Get.script = Y.Get.js;
                            
                                //Place holder for SS Dom access
                                Y.Get.css = function(s, cb) {
                                    Y.log('Y.Get.css is not supported, just reporting that it has loaded but not fetching.', 'warn', 'get');
                                    pass(cb);
                                };