docs: function _downloadNode(
    version,
    directory,
    nodeConfigureArgs,
    nodeMakeArgs,
    nodeVCBuildArgs,
    complete,
  ) {
    var nodeFileDir = path.resolve(path.join(directory, framework, version)), // fixes #107, was process.cwd(), + rest.
      nodeFilePath = path.resolve(
        path.join(nodeFileDir, framework + '-' + version + '.tar.gz'),
      );
  
    // might already be downloaded, and unzipped
    if (
      _getNodeCompiler(
        nodeFileDir,
        nodeConfigureArgs,
        nodeMakeArgs,
        nodeVCBuildArgs,
        complete,
      )
    ) {
      return;
    }
  
    async.waterfall(
      [
        /**
         * first make the directory where the zip file will live
         */
  
        function makeDirectory(next) {
          mkdirp.sync(path.dirname(nodeFilePath));
          next();
        },
  
        /**
         * download node into the target directory
         */
  
        function downloadNode(next) {
          if (fs.existsSync(nodeFilePath)) return next();
  
          var uri = framework;
  
          if (framework === 'node') {
            uri = 'nodejs'; // if node, use nodejs uri
          } else if (framework === 'nodejs') {
            framework = 'node'; // support nodejs, and node, as framework.
          }
  
          var type = global.type;
          var url,
            prefix = 'https://' + uri + '.org/dist';
  
          if (version === 'latest') {
            url = prefix + '/' + framework + '-' + version + '.tar.gz';
          } else {
            url =
              prefix +
              '/v' +
              version +
              '/' +
              framework +
              '-v' +
              version +
              '.tar.gz';
          }
  
          _log('downloading %s', url);
  
          var output = fs.createWriteStream(nodeFilePath, {
            flags: 'w+',
          });
  
          // need to set user-agent to bypass some corporate firewalls
          var requestOptions = {
            url: url,
            headers: {
              'User-Agent': 'Node.js',
            },
          };
  
          _logProgress(request(requestOptions)).pipe(output);
  
          output.on('close', function() {
            next();
          });
        },
  
        /**
         * unzip in the same directory
         */
  
        function unzipNodeTarball(next) {
          var onError = function(err) {
            console.log(err.stack);
            _log('error', 'failed to extract the node source');
            process.exit(1);
          };
  
          if (isWin) {
            _log('extracting the node source [node-tar.gz]');
  
            // tar-stream method w/ gunzip-maybe
            var read = fs.createReadStream(nodeFilePath);
            var extract = tarstream.extract();
            var basedir = nodeFileDir;
  
            if (!fs.existsSync(nodeFileDir)) {
              fs.mkdirSync(nodeFileDir);
            }
  
            extract.on('entry', function(header, stream, callback) {
              // header is the tar header
              // stream is the content body (might be an empty stream)
              // call next when you are done with this entry
  
              var absolutepath = path.join(basedir, header.name);
              if (header.type === 'directory') {
                // handle directories.
                // console.log('dir:', header.name);
                fs.mkdirSync(absolutepath);
                return callback();
              } else if (header.type === 'file') {
                // handle files
                // console.log('file:', header.name);
              } else {
                console.log(header.type + ':', header.name);
                _log('warn', 'unhandled type in tar extraction, skipping');
                return callback();
              }
  
              var write = fs.createWriteStream(absolutepath);
  
              stream.pipe(write);
  
              write.on('close', function() {
                return callback();
              });
  
              stream.on('error', function(err) {
                return onError(err);
              });
  
              write.on('error', function(err) {
                return onError(err);
              });
  
              stream.resume(); // just auto drain the stream
            });
  
            extract.on('finish', function() {
              _log('extraction finished');
              return next();
            });
  
            read.pipe(gunzip()).pipe(extract);
          } else {
            _log('extracting the node source [native tar]');
  
            var cmd = ['tar', '-xf', nodeFilePath, '-C', nodeFileDir];
            _log(cmd.join(' '));
  
            var tar = spawn(cmd.shift(), cmd);
            tar.stdout.pipe(process.stdout);
            tar.stderr.pipe(process.stderr);
  
            tar.on('close', function() {
              return next();
            });
            tar.on('error', onError);
          }
        },
  
        /**
         * return the compiler object for the node version
         */
  
        function(next, type) {
          _getNodeCompiler(
            nodeFileDir,
            nodeConfigureArgs,
            nodeMakeArgs,
            nodeVCBuildArgs,
            next,
            type,
          );
        },
      ],
      complete,
    );
  }