text: YUI.add('get', function (Y, NAME) {
  
      /**
      * 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) {
              if (Y.Lang.isFunction(cb.onEnd)) {
                  cb.onEnd.call(Y, msg, result);
              }
          }, pass = function(cb) {
              if (Y.Lang.isFunction(cb.onSuccess)) {
                  cb.onSuccess.call(Y, cb);
              }
              end(cb, 'success', 'success');
          }, fail = function(cb, 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) {
                      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.Get._include(url, function(err, url) {
                  if (!Y.config) {
                      Y.config = {
                          debug: true
                      };
                  }
                  if (options.onProgress) {
                      options.onProgress.call(options.context || Y, url);
                  }
                  if (err) {
                      fail(options, err);
                  } 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) {
          pass(cb);
      };
  
  
  
  }, 'patched-v3.16.0');
  