Initial commit — jibo-cli v3.0.7 with bundled node_modules

node_modules/fs-plus/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2013 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/fs-plus/README.md

@@ -0,0 +1,235 @@
+# fs plus
+[![OS X Build Status](https://travis-ci.org/atom/fs-plus.svg?branch=master)](https://travis-ci.org/atom/fs-plus)
+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/gf2tleqp0hdek3o3/branch/master?svg=true)](https://ci.appveyor.com/project/Atom/fs-plus/branch/master)
+[![Dependency Status](https://david-dm.org/atom/fs-plus.svg)](https://david-dm.org/atom/fs-plus)
+
+Yet another filesystem helper based on node's [fs](http://nodejs.org/api/fs.html)
+module.  This library exports everything from node's fs module but with some
+extra helpers.
+
+## Using
+
+```sh
+npm install fs-plus
+```
+
+```coffee
+fs = require 'fs-plus'
+```
+
+## Documentation
+
+### `getHomeDirectory()`
+Returns the absolute path to the home directory.
+
+### `absolute(relativePath)`
+Make the given path absolute by resolving it against the current
+working directory.
+
+### Params
+
+ - **String** `relativePath`: The string representing the relative path. If the
+   path is prefixed with '~', it will be expanded to the current user's home
+   directory.
+
+### Return
+
+ - **String**: The absolute path or the relative path if it's unable to
+   determine its real path.
+
+### `normalize(pathToNormalize)`
+Normalize the given path treating a leading `~` segment as referring to the
+home directory. This method does not query the filesystem.
+
+#### Params
+
+ - **String** `pathToNormalize`: The string containing the abnormal path. If the
+   path is prefixed with '~', it will be expanded to the current user's home
+   directory.
+
+#### Return
+ - **String** Returns a normalized path.
+
+### `tildify(pathToTildify)`
+Convert an absolute path to tilde path for linux and mac:
+/Users/username/dev => ~/dev
+
+#### Params
+
+ - **String** `pathToTildify`: The string containing the full path.
+
+#### Return
+ - **String** Returns a tildified path.
+
+### `getAppDataDirectory()`
+Get path to store application specific data.
+
+#### Return
+ - **String** Returns the absolute path or null if platform isn't supported
+
+    - Mac: `~/Library/Application Support/`
+    - Win: `%AppData%`
+    - Linux: `/var/lib`
+
+### `isAbsolute(pathToCheck)`
+Is the given path absolute?
+
+#### Params
+ - **String** `pathToCheck`: The relative or absolute path to check.
+
+#### Return
+ - **Bolean** Returns `true` if the path is absolute, `false` otherwise.
+
+### `existsSync(pathToCheck)`
+Returns `true` if a file or folder at the specified path exists.
+
+### `isDirectorySync(directoryPath)`
+Returns `true` if the given path exists and is a directory.
+
+### `isDirectory(directoryPath)`
+Asynchronously checks that the given path exists and is a directory.
+
+### `isFileSync(filePath)`
+Returns true if the specified path exists and is a file.
+
+### `isSymbolicLinkSync(symlinkPath)`
+Returns `true` if the specified path is a symbolic link.
+
+### `isSymbolicLink(symlinkPath, callback)`
+Calls back with `true` if the specified path is a symbolic link.
+
+### `isExecutableSync(pathToCheck)`
+Returns `true` if the specified path is executable.
+
+### `getSizeSync(pathToCheck)`
+Returns the size of the specified path.
+
+### `listSync(rootPath, extensions)`
+Returns an Array with the paths of the files and directories
+contained within the directory path. It is not recursive.
+
+## Params
+ - **String** `rootPath`: The absolute path to the directory to list.
+ - **Array** `extensions`: An array of extensions to filter the results by. If none are
+   given, none are filtered (optional).
+
+### `list(rootPath, extensions)`
+Asynchronously lists the files and directories in the given path. The listing is not recursive.
+
+### `listTreeSync(rootPath)`
+Get all paths under the given path.
+
+#### Params
+ - **String** `rootPath` The {String} path to start at.
+
+#### Return
+ - **Array** Returns an array of strings under the given path.
+
+### `moveSync(source, target)`
+Moves the file or directory to the target synchronously.
+
+### `removeSync(pathToRemove)`
+Removes the file or directory at the given path synchronously.
+
+### `writeFileSync(filePath, content, options)`
+Open, write, flush, and close a file, writing the given content synchronously.
+It also creates the necessary parent directories.
+
+### `writeFile(filePath, content, options, callback)`
+Open, write, flush, and close a file, writing the given content
+asynchronously.
+It also creates the necessary parent directories.
+
+### `copySync(sourcePath, destinationPath)`
+Copies the given path recursively and synchronously.
+
+### `makeTreeSync(directoryPath)`
+Create a directory at the specified path including any missing
+parent directories synchronously.
+
+### `makeTree(directoryPath, callback)`
+Create a directory at the specified path including any missing
+parent directories asynchronously.
+
+### `traverseTreeSync(rootPath, onFile, onDirectory)`
+Recursively walk the given path and execute the given functions
+synchronously.
+
+#### Params
+ - **String** `rootPath`: The string containing the directory to recurse into.
+ - **Function** `onFile`: The function to execute on each file, receives a single argument
+   the absolute path.
+ - **Function** `onDirectory`: The function to execute on each directory, receives a single
+   argument the absolute path (defaults to onFile). If this
+   function returns a falsy value then the directory is not
+   entered.
+
+### `traverseTree(rootPath, onFile, onDirectory, onDone)`
+Public: Recursively walk the given path and execute the given functions
+asynchronously.
+
+### `md5ForPath(pathToDigest)`
+Hashes the contents of the given file.
+
+#### Params
+ - **String** `pathToDigest`: The string containing the absolute path.
+
+#### Return
+ - **String** Returns a string containing the MD5 hexadecimal hash.
+
+### `resolve(loadPaths, pathToResolve, extensions)`
+Finds a relative path among the given array of paths.
+
+#### Params
+ - **Array** `loadPaths`: An array of absolute and relative paths to search.
+ - **String** `pathToResolve` The string containing the path to resolve.
+ - **Array** `extensions` An array of extensions to pass to {resolveExtensions} in
+   which case pathToResolve should not contain an extension
+   (optional).
+
+#### Return
+Returns the absolute path of the file to be resolved if it's found and
+undefined otherwise.
+
+### `resolveOnLoadPath()`
+Like `.resolve` but uses node's modules paths as the load paths to
+search.
+
+### `resolveExtension(pathToResolve, extensions)`
+Finds the first file in the given path which matches the extension
+in the order given.
+
+#### Params
+ - **String** `pathToResolve`: the string containing relative or absolute path of the
+   file in question without the extension or '.'.
+ - **Array** `extensions`: the ordered array of extensions to try.
+
+#### Return
+Returns the absolute path of the file if it exists with any of the given
+extensions, otherwise it's undefined.
+
+### `isCompressedExtension(ext)`
+Returns true for extensions associated with compressed files.
+
+### `isImageExtension(ext)`
+Returns true for extensions associated with image files.
+
+### `isPdfExtension(ext)`
+Returns true for extensions associated with pdf files.
+
+### `isBinaryExtension(ext)`
+Returns true for extensions associated with binary files.
+
+### `isReadmePath(readmePath)`
+Returns true for files named similarily to 'README'
+
+### `isMarkdownExtension(ext)`
+Returns true for extensions associated with Markdown files.
+
+### `isCaseInsensitive()`
+Is the filesystem case insensitive?
+Returns `true` if case insensitive, `false` otherwise.
+
+### `isCaseSensitive()`
+Is the filesystem case sensitive?
+Returns `true` if case sensitive, `false` otherwise.

node_modules/fs-plus/appveyor.yml

@@ -0,0 +1,16 @@
+version: "{build}"
+
+os: Windows Server 2012 R2
+
+install:
+  - choco install atom -y
+  - cd %APPVEYOR_BUILD_FOLDER%
+  - npm install
+
+build_script:
+  - cd %APPVEYOR_BUILD_FOLDER%
+  - npm test
+
+test: off
+
+deploy: off

node_modules/fs-plus/lib/fs-plus.js

@@ -0,0 +1,699 @@
+(function() {
+  var BINARY_EXTENSIONS, COMPRESSED_EXTENSIONS, IMAGE_EXTENSIONS, MARKDOWN_EXTENSIONS, Module, async, fs, fsPlus, isMoveTargetValid, isMoveTargetValidSync, isPathValid, lstatSyncNoException, mkdirp, path, rimraf, statSyncNoException, _,
+    __slice = [].slice;
+
+  fs = require('fs');
+
+  Module = require('module');
+
+  path = require('path');
+
+  _ = require('underscore-plus');
+
+  async = require('async');
+
+  mkdirp = require('mkdirp');
+
+  rimraf = require('rimraf');
+
+  fsPlus = {
+    getHomeDirectory: function() {
+      if (process.platform === 'win32') {
+        return process.env.USERPROFILE;
+      } else {
+        return process.env.HOME;
+      }
+    },
+    absolute: function(relativePath) {
+      var e;
+      if (relativePath == null) {
+        return null;
+      }
+      relativePath = fsPlus.resolveHome(relativePath);
+      try {
+        return fs.realpathSync(relativePath);
+      } catch (_error) {
+        e = _error;
+        return relativePath;
+      }
+    },
+    normalize: function(pathToNormalize) {
+      if (pathToNormalize == null) {
+        return null;
+      }
+      return fsPlus.resolveHome(path.normalize(pathToNormalize.toString()));
+    },
+    resolveHome: function(relativePath) {
+      if (relativePath === '~') {
+        return fsPlus.getHomeDirectory();
+      } else if (relativePath.indexOf("~" + path.sep) === 0) {
+        return "" + (fsPlus.getHomeDirectory()) + (relativePath.substring(1));
+      }
+      return relativePath;
+    },
+    tildify: function(pathToTildify) {
+      var homeDir, normalized;
+      if (process.platform === 'win32') {
+        return pathToTildify;
+      }
+      normalized = fsPlus.normalize(pathToTildify);
+      homeDir = fsPlus.getHomeDirectory();
+      if (normalized === homeDir) {
+        return '~';
+      }
+      if (!normalized.startsWith(path.join(homeDir, path.sep))) {
+        return pathToTildify;
+      }
+      return path.join('~', path.sep, normalized.substring(homeDir.length + 1));
+    },
+    getAppDataDirectory: function() {
+      switch (process.platform) {
+        case 'darwin':
+          return fsPlus.absolute(path.join('~', 'Library', 'Application Support'));
+        case 'linux':
+          return '/var/lib';
+        case 'win32':
+          return process.env.APPDATA;
+        default:
+          return null;
+      }
+    },
+    isAbsolute: function(pathToCheck) {
+      if (pathToCheck == null) {
+        pathToCheck = '';
+      }
+      if (process.platform === 'win32') {
+        if (pathToCheck[1] === ':') {
+          return true;
+        }
+        if (pathToCheck[0] === '\\' && pathToCheck[1] === '\\') {
+          return true;
+        }
+      } else {
+        return pathToCheck[0] === '/';
+      }
+      return false;
+    },
+    existsSync: function(pathToCheck) {
+      return isPathValid(pathToCheck) && (statSyncNoException(pathToCheck) !== false);
+    },
+    isDirectorySync: function(directoryPath) {
+      var stat;
+      if (!isPathValid(directoryPath)) {
+        return false;
+      }
+      if (stat = statSyncNoException(directoryPath)) {
+        return stat.isDirectory();
+      } else {
+        return false;
+      }
+    },
+    isDirectory: function(directoryPath, done) {
+      if (!isPathValid(directoryPath)) {
+        return done(false);
+      }
+      return fs.stat(directoryPath, function(error, stat) {
+        if (error != null) {
+          return done(false);
+        } else {
+          return done(stat.isDirectory());
+        }
+      });
+    },
+    isFileSync: function(filePath) {
+      var stat;
+      if (!isPathValid(filePath)) {
+        return false;
+      }
+      if (stat = statSyncNoException(filePath)) {
+        return stat.isFile();
+      } else {
+        return false;
+      }
+    },
+    isSymbolicLinkSync: function(symlinkPath) {
+      var stat;
+      if (!isPathValid(symlinkPath)) {
+        return false;
+      }
+      if (stat = lstatSyncNoException(symlinkPath)) {
+        return stat.isSymbolicLink();
+      } else {
+        return false;
+      }
+    },
+    isSymbolicLink: function(symlinkPath, callback) {
+      if (isPathValid(symlinkPath)) {
+        return fs.lstat(symlinkPath, function(error, stat) {
+          return typeof callback === "function" ? callback((stat != null) && stat.isSymbolicLink()) : void 0;
+        });
+      } else {
+        return process.nextTick(function() {
+          return typeof callback === "function" ? callback(false) : void 0;
+        });
+      }
+    },
+    isExecutableSync: function(pathToCheck) {
+      var stat;
+      if (!isPathValid(pathToCheck)) {
+        return false;
+      }
+      if (stat = statSyncNoException(pathToCheck)) {
+        return (stat.mode & 0x1ff & 1) !== 0;
+      } else {
+        return false;
+      }
+    },
+    getSizeSync: function(pathToCheck) {
+      var _ref;
+      if (isPathValid(pathToCheck)) {
+        return (_ref = statSyncNoException(pathToCheck).size) != null ? _ref : -1;
+      } else {
+        return -1;
+      }
+    },
+    listSync: function(rootPath, extensions) {
+      var paths;
+      if (!fsPlus.isDirectorySync(rootPath)) {
+        return [];
+      }
+      paths = fs.readdirSync(rootPath);
+      if (extensions) {
+        paths = fsPlus.filterExtensions(paths, extensions);
+      }
+      paths = paths.sort(function(a, b) {
+        return a.toLowerCase().localeCompare(b.toLowerCase());
+      });
+      paths = paths.map(function(childPath) {
+        return path.join(rootPath, childPath);
+      });
+      return paths;
+    },
+    list: function() {
+      var done, extensions, rest, rootPath;
+      rootPath = arguments[0], rest = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      if (rest.length > 1) {
+        extensions = rest.shift();
+      }
+      done = rest.shift();
+      return fs.readdir(rootPath, function(error, paths) {
+        if (error != null) {
+          return done(error);
+        } else {
+          if (extensions) {
+            paths = fsPlus.filterExtensions(paths, extensions);
+          }
+          paths = paths.sort(function(a, b) {
+            return a.toLowerCase().localeCompare(b.toLowerCase());
+          });
+          paths = paths.map(function(childPath) {
+            return path.join(rootPath, childPath);
+          });
+          return done(null, paths);
+        }
+      });
+    },
+    filterExtensions: function(paths, extensions) {
+      extensions = extensions.map(function(ext) {
+        if (ext === '') {
+          return ext;
+        } else {
+          return '.' + ext.replace(/^\./, '');
+        }
+      });
+      return paths.filter(function(pathToCheck) {
+        return _.include(extensions, path.extname(pathToCheck));
+      });
+    },
+    listTreeSync: function(rootPath) {
+      var onPath, paths;
+      paths = [];
+      onPath = function(childPath) {
+        paths.push(childPath);
+        return true;
+      };
+      fsPlus.traverseTreeSync(rootPath, onPath, onPath);
+      return paths;
+    },
+    move: function(source, target, callback) {
+      return isMoveTargetValid(source, target, function(isMoveTargetValidErr, isTargetValid) {
+        var error, targetParentPath;
+        if (isMoveTargetValidErr) {
+          callback(isMoveTargetValidErr);
+          return;
+        }
+        if (!isTargetValid) {
+          error = new Error("'" + target + "' already exists.");
+          error.code = 'EEXIST';
+          callback(error);
+          return;
+        }
+        targetParentPath = path.dirname(target);
+        return fs.exists(targetParentPath, function(targetParentExists) {
+          if (targetParentExists) {
+            fs.rename(source, target, callback);
+            return;
+          }
+          return fsPlus.makeTree(targetParentPath, function(makeTreeErr) {
+            if (makeTreeErr) {
+              callback(makeTreeErr);
+              return;
+            }
+            return fs.rename(source, target, callback);
+          });
+        });
+      });
+    },
+    moveSync: function(source, target) {
+      var error, targetParentPath;
+      if (!isMoveTargetValidSync(source, target)) {
+        error = new Error("'" + target + "' already exists.");
+        error.code = 'EEXIST';
+        throw error;
+      }
+      targetParentPath = path.dirname(target);
+      if (!fs.existsSync(targetParentPath)) {
+        fsPlus.makeTreeSync(targetParentPath);
+      }
+      return fs.renameSync(source, target);
+    },
+    removeSync: function(pathToRemove) {
+      return rimraf.sync(pathToRemove);
+    },
+    remove: function(pathToRemove, callback) {
+      return rimraf(pathToRemove, callback);
+    },
+    writeFileSync: function(filePath, content, options) {
+      mkdirp.sync(path.dirname(filePath));
+      return fs.writeFileSync(filePath, content, options);
+    },
+    writeFile: function(filePath, content, options, callback) {
+      callback = _.last(arguments);
+      return mkdirp(path.dirname(filePath), function(error) {
+        if (error != null) {
+          return typeof callback === "function" ? callback(error) : void 0;
+        } else {
+          return fs.writeFile(filePath, content, options, callback);
+        }
+      });
+    },
+    copy: function(sourcePath, destinationPath, done) {
+      return mkdirp(path.dirname(destinationPath), function(error) {
+        var destinationStream, sourceStream;
+        if (error != null) {
+          if (typeof done === "function") {
+            done(error);
+          }
+          return;
+        }
+        sourceStream = fs.createReadStream(sourcePath);
+        sourceStream.on('error', function(error) {
+          if (typeof done === "function") {
+            done(error);
+          }
+          return done = null;
+        });
+        destinationStream = fs.createWriteStream(destinationPath);
+        destinationStream.on('error', function(error) {
+          if (typeof done === "function") {
+            done(error);
+          }
+          return done = null;
+        });
+        destinationStream.on('close', function() {
+          if (typeof done === "function") {
+            done();
+          }
+          return done = null;
+        });
+        return sourceStream.pipe(destinationStream);
+      });
+    },
+    copySync: function(sourcePath, destinationPath) {
+      var destinationFilePath, source, sourceFilePath, sources, _i, _len, _results;
+      sources = fs.readdirSync(sourcePath);
+      mkdirp.sync(destinationPath);
+      _results = [];
+      for (_i = 0, _len = sources.length; _i < _len; _i++) {
+        source = sources[_i];
+        sourceFilePath = path.join(sourcePath, source);
+        destinationFilePath = path.join(destinationPath, source);
+        if (fsPlus.isDirectorySync(sourceFilePath)) {
+          _results.push(fsPlus.copySync(sourceFilePath, destinationFilePath));
+        } else {
+          _results.push(fsPlus.copyFileSync(sourceFilePath, destinationFilePath));
+        }
+      }
+      return _results;
+    },
+    copyFileSync: function(sourceFilePath, destinationFilePath, bufferSize) {
+      var buffer, bytesRead, position, readFd, writeFd, _results;
+      if (bufferSize == null) {
+        bufferSize = 16 * 1024;
+      }
+      mkdirp.sync(path.dirname(destinationFilePath));
+      readFd = null;
+      writeFd = null;
+      try {
+        readFd = fs.openSync(sourceFilePath, 'r');
+        writeFd = fs.openSync(destinationFilePath, 'w');
+        bytesRead = 1;
+        position = 0;
+        _results = [];
+        while (bytesRead > 0) {
+          buffer = new Buffer(bufferSize);
+          bytesRead = fs.readSync(readFd, buffer, 0, buffer.length, position);
+          fs.writeSync(writeFd, buffer, 0, bytesRead, position);
+          _results.push(position += bytesRead);
+        }
+        return _results;
+      } finally {
+        if (readFd != null) {
+          fs.closeSync(readFd);
+        }
+        if (writeFd != null) {
+          fs.closeSync(writeFd);
+        }
+      }
+    },
+    makeTreeSync: function(directoryPath) {
+      if (!fsPlus.isDirectorySync(directoryPath)) {
+        return mkdirp.sync(directoryPath);
+      }
+    },
+    makeTree: function(directoryPath, callback) {
+      return fsPlus.isDirectory(directoryPath, function(exists) {
+        if (exists) {
+          return typeof callback === "function" ? callback() : void 0;
+        }
+        return mkdirp(directoryPath, function(error) {
+          return typeof callback === "function" ? callback(error) : void 0;
+        });
+      });
+    },
+    traverseTreeSync: function(rootPath, onFile, onDirectory) {
+      var traverse;
+      if (onDirectory == null) {
+        onDirectory = onFile;
+      }
+      if (!fsPlus.isDirectorySync(rootPath)) {
+        return;
+      }
+      traverse = function(directoryPath, onFile, onDirectory) {
+        var childPath, file, linkStats, stats, _i, _len, _ref;
+        _ref = fs.readdirSync(directoryPath);
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          file = _ref[_i];
+          childPath = path.join(directoryPath, file);
+          stats = fs.lstatSync(childPath);
+          if (stats.isSymbolicLink()) {
+            if (linkStats = statSyncNoException(childPath)) {
+              stats = linkStats;
+            }
+          }
+          if (stats.isDirectory()) {
+            if (onDirectory(childPath)) {
+              traverse(childPath, onFile, onDirectory);
+            }
+          } else if (stats.isFile()) {
+            onFile(childPath);
+          }
+        }
+        return void 0;
+      };
+      return traverse(rootPath, onFile, onDirectory);
+    },
+    traverseTree: function(rootPath, onFile, onDirectory, onDone) {
+      return fs.readdir(rootPath, function(error, files) {
+        var file, queue, _i, _len, _results;
+        if (error) {
+          return typeof onDone === "function" ? onDone() : void 0;
+        } else {
+          queue = async.queue(function(childPath, callback) {
+            return fs.stat(childPath, function(error, stats) {
+              if (error) {
+                return callback(error);
+              } else if (stats.isFile()) {
+                onFile(childPath);
+                return callback();
+              } else if (stats.isDirectory()) {
+                if (onDirectory(childPath)) {
+                  return fs.readdir(childPath, function(error, files) {
+                    var file, _i, _len;
+                    if (error) {
+                      return callback(error);
+                    } else {
+                      for (_i = 0, _len = files.length; _i < _len; _i++) {
+                        file = files[_i];
+                        queue.unshift(path.join(childPath, file));
+                      }
+                      return callback();
+                    }
+                  });
+                } else {
+                  return callback();
+                }
+              } else {
+                return callback();
+              }
+            });
+          });
+          queue.concurrency = 1;
+          queue.drain = onDone;
+          _results = [];
+          for (_i = 0, _len = files.length; _i < _len; _i++) {
+            file = files[_i];
+            _results.push(queue.push(path.join(rootPath, file)));
+          }
+          return _results;
+        }
+      });
+    },
+    md5ForPath: function(pathToDigest) {
+      var contents;
+      contents = fs.readFileSync(pathToDigest);
+      return require('crypto').createHash('md5').update(contents).digest('hex');
+    },
+    resolve: function() {
+      var args, candidatePath, extensions, loadPath, loadPaths, pathToResolve, resolvedPath, _i, _len, _ref;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      if (_.isArray(_.last(args))) {
+        extensions = args.pop();
+      }
+      pathToResolve = (_ref = args.pop()) != null ? _ref.toString() : void 0;
+      loadPaths = args;
+      if (!pathToResolve) {
+        return void 0;
+      }
+      if (fsPlus.isAbsolute(pathToResolve)) {
+        if (extensions && (resolvedPath = fsPlus.resolveExtension(pathToResolve, extensions))) {
+          return resolvedPath;
+        } else {
+          if (fsPlus.existsSync(pathToResolve)) {
+            return pathToResolve;
+          }
+        }
+      }
+      for (_i = 0, _len = loadPaths.length; _i < _len; _i++) {
+        loadPath = loadPaths[_i];
+        candidatePath = path.join(loadPath, pathToResolve);
+        if (extensions) {
+          if (resolvedPath = fsPlus.resolveExtension(candidatePath, extensions)) {
+            return resolvedPath;
+          }
+        } else {
+          if (fsPlus.existsSync(candidatePath)) {
+            return fsPlus.absolute(candidatePath);
+          }
+        }
+      }
+      return void 0;
+    },
+    resolveOnLoadPath: function() {
+      var args, loadPaths;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      loadPaths = Module.globalPaths.concat(module.paths);
+      return fsPlus.resolve.apply(fsPlus, __slice.call(loadPaths).concat(__slice.call(args)));
+    },
+    resolveExtension: function(pathToResolve, extensions) {
+      var extension, pathWithExtension, _i, _len;
+      for (_i = 0, _len = extensions.length; _i < _len; _i++) {
+        extension = extensions[_i];
+        if (extension === "") {
+          if (fsPlus.existsSync(pathToResolve)) {
+            return fsPlus.absolute(pathToResolve);
+          }
+        } else {
+          pathWithExtension = pathToResolve + "." + extension.replace(/^\./, "");
+          if (fsPlus.existsSync(pathWithExtension)) {
+            return fsPlus.absolute(pathWithExtension);
+          }
+        }
+      }
+      return void 0;
+    },
+    isCompressedExtension: function(ext) {
+      if (ext == null) {
+        return false;
+      }
+      return COMPRESSED_EXTENSIONS.hasOwnProperty(ext.toLowerCase());
+    },
+    isImageExtension: function(ext) {
+      if (ext == null) {
+        return false;
+      }
+      return IMAGE_EXTENSIONS.hasOwnProperty(ext.toLowerCase());
+    },
+    isPdfExtension: function(ext) {
+      return (ext != null ? ext.toLowerCase() : void 0) === '.pdf';
+    },
+    isBinaryExtension: function(ext) {
+      if (ext == null) {
+        return false;
+      }
+      return BINARY_EXTENSIONS.hasOwnProperty(ext.toLowerCase());
+    },
+    isReadmePath: function(readmePath) {
+      var base, extension;
+      extension = path.extname(readmePath);
+      base = path.basename(readmePath, extension).toLowerCase();
+      return base === 'readme' && (extension === '' || fsPlus.isMarkdownExtension(extension));
+    },
+    isMarkdownExtension: function(ext) {
+      if (ext == null) {
+        return false;
+      }
+      return MARKDOWN_EXTENSIONS.hasOwnProperty(ext.toLowerCase());
+    },
+    isCaseInsensitive: function() {
+      var lowerCaseStat, upperCaseStat;
+      if (fsPlus.caseInsensitiveFs == null) {
+        lowerCaseStat = statSyncNoException(process.execPath.toLowerCase());
+        upperCaseStat = statSyncNoException(process.execPath.toUpperCase());
+        if (lowerCaseStat && upperCaseStat) {
+          fsPlus.caseInsensitiveFs = lowerCaseStat.dev === upperCaseStat.dev && lowerCaseStat.ino === upperCaseStat.ino;
+        } else {
+          fsPlus.caseInsensitiveFs = false;
+        }
+      }
+      return fsPlus.caseInsensitiveFs;
+    },
+    isCaseSensitive: function() {
+      return !fsPlus.isCaseInsensitive();
+    }
+  };
+
+  statSyncNoException = fs.statSyncNoException, lstatSyncNoException = fs.lstatSyncNoException;
+
+  if (statSyncNoException == null) {
+    statSyncNoException = function() {
+      var args, error;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      try {
+        return fs.statSync.apply(fs, args);
+      } catch (_error) {
+        error = _error;
+        return false;
+      }
+    };
+  }
+
+  if (lstatSyncNoException == null) {
+    lstatSyncNoException = function() {
+      var args, error;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      try {
+        return fs.lstatSync.apply(fs, args);
+      } catch (_error) {
+        error = _error;
+        return false;
+      }
+    };
+  }
+
+  BINARY_EXTENSIONS = {
+    '.ds_store': true,
+    '.a': true,
+    '.exe': true,
+    '.o': true,
+    '.pyc': true,
+    '.pyo': true,
+    '.so': true,
+    '.woff': true
+  };
+
+  COMPRESSED_EXTENSIONS = {
+    '.bz2': true,
+    '.egg': true,
+    '.epub': true,
+    '.gem': true,
+    '.gz': true,
+    '.jar': true,
+    '.lz': true,
+    '.lzma': true,
+    '.lzo': true,
+    '.rar': true,
+    '.tar': true,
+    '.tgz': true,
+    '.war': true,
+    '.whl': true,
+    '.xpi': true,
+    '.xz': true,
+    '.z': true,
+    '.zip': true
+  };
+
+  IMAGE_EXTENSIONS = {
+    '.gif': true,
+    '.ico': true,
+    '.jpeg': true,
+    '.jpg': true,
+    '.png': true,
+    '.tif': true,
+    '.tiff': true,
+    '.webp': true
+  };
+
+  MARKDOWN_EXTENSIONS = {
+    '.markdown': true,
+    '.md': true,
+    '.mdown': true,
+    '.mkd': true,
+    '.mkdown': true,
+    '.rmd': true,
+    '.ron': true
+  };
+
+  isPathValid = function(pathToCheck) {
+    return (pathToCheck != null) && typeof pathToCheck === 'string' && pathToCheck.length > 0;
+  };
+
+  isMoveTargetValid = function(source, target, callback) {
+    return fs.stat(source, function(oldErr, oldStat) {
+      if (oldErr) {
+        callback(oldErr);
+        return;
+      }
+      return fs.stat(target, function(newErr, newStat) {
+        if (newErr && newErr.code === 'ENOENT') {
+          callback(void 0, true);
+          return;
+        }
+        return callback(void 0, source.toLowerCase() === target.toLowerCase() && oldStat.dev === newStat.dev && oldStat.ino === newStat.ino);
+      });
+    });
+  };
+
+  isMoveTargetValidSync = function(source, target) {
+    var newStat, oldStat;
+    oldStat = statSyncNoException(source);
+    newStat = statSyncNoException(target);
+    if (!(oldStat && newStat)) {
+      return true;
+    }
+    return source.toLowerCase() === target.toLowerCase() && oldStat.dev === newStat.dev && oldStat.ino === newStat.ino;
+  };
+
+  module.exports = _.extend({}, fs, fsPlus);
+
+}).call(this);

node_modules/fs-plus/node_modules/.bin/rimraf

@@ -0,0 +1 @@
+../rimraf/bin.js

node_modules/fs-plus/node_modules/async/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Caolan McMahon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/fs-plus/node_modules/async/component.json

@@ -0,0 +1,11 @@
+{
+  "name": "async",
+  "repo": "caolan/async",
+  "description": "Higher-order functions and common patterns for asynchronous code",
+  "version": "0.1.23",
+  "keywords": [],
+  "dependencies": {},
+  "development": {},
+  "main": "lib/async.js",
+  "scripts": [ "lib/async.js" ]
+}

node_modules/fs-plus/node_modules/async/lib/async.js

@@ -0,0 +1,958 @@
+/*global setImmediate: false, setTimeout: false, console: false */
+(function () {
+
+    var async = {};
+
+    // global on the server, window in the browser
+    var root, previous_async;
+
+    root = this;
+    if (root != null) {
+      previous_async = root.async;
+    }
+
+    async.noConflict = function () {
+        root.async = previous_async;
+        return async;
+    };
+
+    function only_once(fn) {
+        var called = false;
+        return function() {
+            if (called) throw new Error("Callback was already called.");
+            called = true;
+            fn.apply(root, arguments);
+        }
+    }
+
+    //// cross-browser compatiblity functions ////
+
+    var _each = function (arr, iterator) {
+        if (arr.forEach) {
+            return arr.forEach(iterator);
+        }
+        for (var i = 0; i < arr.length; i += 1) {
+            iterator(arr[i], i, arr);
+        }
+    };
+
+    var _map = function (arr, iterator) {
+        if (arr.map) {
+            return arr.map(iterator);
+        }
+        var results = [];
+        _each(arr, function (x, i, a) {
+            results.push(iterator(x, i, a));
+        });
+        return results;
+    };
+
+    var _reduce = function (arr, iterator, memo) {
+        if (arr.reduce) {
+            return arr.reduce(iterator, memo);
+        }
+        _each(arr, function (x, i, a) {
+            memo = iterator(memo, x, i, a);
+        });
+        return memo;
+    };
+
+    var _keys = function (obj) {
+        if (Object.keys) {
+            return Object.keys(obj);
+        }
+        var keys = [];
+        for (var k in obj) {
+            if (obj.hasOwnProperty(k)) {
+                keys.push(k);
+            }
+        }
+        return keys;
+    };
+
+    //// exported async module functions ////
+
+    //// nextTick implementation with browser-compatible fallback ////
+    if (typeof process === 'undefined' || !(process.nextTick)) {
+        if (typeof setImmediate === 'function') {
+            async.nextTick = function (fn) {
+                // not a direct alias for IE10 compatibility
+                setImmediate(fn);
+            };
+            async.setImmediate = async.nextTick;
+        }
+        else {
+            async.nextTick = function (fn) {
+                setTimeout(fn, 0);
+            };
+            async.setImmediate = async.nextTick;
+        }
+    }
+    else {
+        async.nextTick = process.nextTick;
+        if (typeof setImmediate !== 'undefined') {
+            async.setImmediate = function (fn) {
+              // not a direct alias for IE10 compatibility
+              setImmediate(fn);
+            };
+        }
+        else {
+            async.setImmediate = async.nextTick;
+        }
+    }
+
+    async.each = function (arr, iterator, callback) {
+        callback = callback || function () {};
+        if (!arr.length) {
+            return callback();
+        }
+        var completed = 0;
+        _each(arr, function (x) {
+            iterator(x, only_once(function (err) {
+                if (err) {
+                    callback(err);
+                    callback = function () {};
+                }
+                else {
+                    completed += 1;
+                    if (completed >= arr.length) {
+                        callback(null);
+                    }
+                }
+            }));
+        });
+    };
+    async.forEach = async.each;
+
+    async.eachSeries = function (arr, iterator, callback) {
+        callback = callback || function () {};
+        if (!arr.length) {
+            return callback();
+        }
+        var completed = 0;
+        var iterate = function () {
+            iterator(arr[completed], function (err) {
+                if (err) {
+                    callback(err);
+                    callback = function () {};
+                }
+                else {
+                    completed += 1;
+                    if (completed >= arr.length) {
+                        callback(null);
+                    }
+                    else {
+                        iterate();
+                    }
+                }
+            });
+        };
+        iterate();
+    };
+    async.forEachSeries = async.eachSeries;
+
+    async.eachLimit = function (arr, limit, iterator, callback) {
+        var fn = _eachLimit(limit);
+        fn.apply(null, [arr, iterator, callback]);
+    };
+    async.forEachLimit = async.eachLimit;
+
+    var _eachLimit = function (limit) {
+
+        return function (arr, iterator, callback) {
+            callback = callback || function () {};
+            if (!arr.length || limit <= 0) {
+                return callback();
+            }
+            var completed = 0;
+            var started = 0;
+            var running = 0;
+
+            (function replenish () {
+                if (completed >= arr.length) {
+                    return callback();
+                }
+
+                while (running < limit && started < arr.length) {
+                    started += 1;
+                    running += 1;
+                    iterator(arr[started - 1], function (err) {
+                        if (err) {
+                            callback(err);
+                            callback = function () {};
+                        }
+                        else {
+                            completed += 1;
+                            running -= 1;
+                            if (completed >= arr.length) {
+                                callback();
+                            }
+                            else {
+                                replenish();
+                            }
+                        }
+                    });
+                }
+            })();
+        };
+    };
+
+
+    var doParallel = function (fn) {
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            return fn.apply(null, [async.each].concat(args));
+        };
+    };
+    var doParallelLimit = function(limit, fn) {
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            return fn.apply(null, [_eachLimit(limit)].concat(args));
+        };
+    };
+    var doSeries = function (fn) {
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            return fn.apply(null, [async.eachSeries].concat(args));
+        };
+    };
+
+
+    var _asyncMap = function (eachfn, arr, iterator, callback) {
+        var results = [];
+        arr = _map(arr, function (x, i) {
+            return {index: i, value: x};
+        });
+        eachfn(arr, function (x, callback) {
+            iterator(x.value, function (err, v) {
+                results[x.index] = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err, results);
+        });
+    };
+    async.map = doParallel(_asyncMap);
+    async.mapSeries = doSeries(_asyncMap);
+    async.mapLimit = function (arr, limit, iterator, callback) {
+        return _mapLimit(limit)(arr, iterator, callback);
+    };
+
+    var _mapLimit = function(limit) {
+        return doParallelLimit(limit, _asyncMap);
+    };
+
+    // reduce only has a series version, as doing reduce in parallel won't
+    // work in many situations.
+    async.reduce = function (arr, memo, iterator, callback) {
+        async.eachSeries(arr, function (x, callback) {
+            iterator(memo, x, function (err, v) {
+                memo = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err, memo);
+        });
+    };
+    // inject alias
+    async.inject = async.reduce;
+    // foldl alias
+    async.foldl = async.reduce;
+
+    async.reduceRight = function (arr, memo, iterator, callback) {
+        var reversed = _map(arr, function (x) {
+            return x;
+        }).reverse();
+        async.reduce(reversed, memo, iterator, callback);
+    };
+    // foldr alias
+    async.foldr = async.reduceRight;
+
+    var _filter = function (eachfn, arr, iterator, callback) {
+        var results = [];
+        arr = _map(arr, function (x, i) {
+            return {index: i, value: x};
+        });
+        eachfn(arr, function (x, callback) {
+            iterator(x.value, function (v) {
+                if (v) {
+                    results.push(x);
+                }
+                callback();
+            });
+        }, function (err) {
+            callback(_map(results.sort(function (a, b) {
+                return a.index - b.index;
+            }), function (x) {
+                return x.value;
+            }));
+        });
+    };
+    async.filter = doParallel(_filter);
+    async.filterSeries = doSeries(_filter);
+    // select alias
+    async.select = async.filter;
+    async.selectSeries = async.filterSeries;
+
+    var _reject = function (eachfn, arr, iterator, callback) {
+        var results = [];
+        arr = _map(arr, function (x, i) {
+            return {index: i, value: x};
+        });
+        eachfn(arr, function (x, callback) {
+            iterator(x.value, function (v) {
+                if (!v) {
+                    results.push(x);
+                }
+                callback();
+            });
+        }, function (err) {
+            callback(_map(results.sort(function (a, b) {
+                return a.index - b.index;
+            }), function (x) {
+                return x.value;
+            }));
+        });
+    };
+    async.reject = doParallel(_reject);
+    async.rejectSeries = doSeries(_reject);
+
+    var _detect = function (eachfn, arr, iterator, main_callback) {
+        eachfn(arr, function (x, callback) {
+            iterator(x, function (result) {
+                if (result) {
+                    main_callback(x);
+                    main_callback = function () {};
+                }
+                else {
+                    callback();
+                }
+            });
+        }, function (err) {
+            main_callback();
+        });
+    };
+    async.detect = doParallel(_detect);
+    async.detectSeries = doSeries(_detect);
+
+    async.some = function (arr, iterator, main_callback) {
+        async.each(arr, function (x, callback) {
+            iterator(x, function (v) {
+                if (v) {
+                    main_callback(true);
+                    main_callback = function () {};
+                }
+                callback();
+            });
+        }, function (err) {
+            main_callback(false);
+        });
+    };
+    // any alias
+    async.any = async.some;
+
+    async.every = function (arr, iterator, main_callback) {
+        async.each(arr, function (x, callback) {
+            iterator(x, function (v) {
+                if (!v) {
+                    main_callback(false);
+                    main_callback = function () {};
+                }
+                callback();
+            });
+        }, function (err) {
+            main_callback(true);
+        });
+    };
+    // all alias
+    async.all = async.every;
+
+    async.sortBy = function (arr, iterator, callback) {
+        async.map(arr, function (x, callback) {
+            iterator(x, function (err, criteria) {
+                if (err) {
+                    callback(err);
+                }
+                else {
+                    callback(null, {value: x, criteria: criteria});
+                }
+            });
+        }, function (err, results) {
+            if (err) {
+                return callback(err);
+            }
+            else {
+                var fn = function (left, right) {
+                    var a = left.criteria, b = right.criteria;
+                    return a < b ? -1 : a > b ? 1 : 0;
+                };
+                callback(null, _map(results.sort(fn), function (x) {
+                    return x.value;
+                }));
+            }
+        });
+    };
+
+    async.auto = function (tasks, callback) {
+        callback = callback || function () {};
+        var keys = _keys(tasks);
+        if (!keys.length) {
+            return callback(null);
+        }
+
+        var results = {};
+
+        var listeners = [];
+        var addListener = function (fn) {
+            listeners.unshift(fn);
+        };
+        var removeListener = function (fn) {
+            for (var i = 0; i < listeners.length; i += 1) {
+                if (listeners[i] === fn) {
+                    listeners.splice(i, 1);
+                    return;
+                }
+            }
+        };
+        var taskComplete = function () {
+            _each(listeners.slice(0), function (fn) {
+                fn();
+            });
+        };
+
+        addListener(function () {
+            if (_keys(results).length === keys.length) {
+                callback(null, results);
+                callback = function () {};
+            }
+        });
+
+        _each(keys, function (k) {
+            var task = (tasks[k] instanceof Function) ? [tasks[k]]: tasks[k];
+            var taskCallback = function (err) {
+                var args = Array.prototype.slice.call(arguments, 1);
+                if (args.length <= 1) {
+                    args = args[0];
+                }
+                if (err) {
+                    var safeResults = {};
+                    _each(_keys(results), function(rkey) {
+                        safeResults[rkey] = results[rkey];
+                    });
+                    safeResults[k] = args;
+                    callback(err, safeResults);
+                    // stop subsequent errors hitting callback multiple times
+                    callback = function () {};
+                }
+                else {
+                    results[k] = args;
+                    async.setImmediate(taskComplete);
+                }
+            };
+            var requires = task.slice(0, Math.abs(task.length - 1)) || [];
+            var ready = function () {
+                return _reduce(requires, function (a, x) {
+                    return (a && results.hasOwnProperty(x));
+                }, true) && !results.hasOwnProperty(k);
+            };
+            if (ready()) {
+                task[task.length - 1](taskCallback, results);
+            }
+            else {
+                var listener = function () {
+                    if (ready()) {
+                        removeListener(listener);
+                        task[task.length - 1](taskCallback, results);
+                    }
+                };
+                addListener(listener);
+            }
+        });
+    };
+
+    async.waterfall = function (tasks, callback) {
+        callback = callback || function () {};
+        if (tasks.constructor !== Array) {
+          var err = new Error('First argument to waterfall must be an array of functions');
+          return callback(err);
+        }
+        if (!tasks.length) {
+            return callback();
+        }
+        var wrapIterator = function (iterator) {
+            return function (err) {
+                if (err) {
+                    callback.apply(null, arguments);
+                    callback = function () {};
+                }
+                else {
+                    var args = Array.prototype.slice.call(arguments, 1);
+                    var next = iterator.next();
+                    if (next) {
+                        args.push(wrapIterator(next));
+                    }
+                    else {
+                        args.push(callback);
+                    }
+                    async.setImmediate(function () {
+                        iterator.apply(null, args);
+                    });
+                }
+            };
+        };
+        wrapIterator(async.iterator(tasks))();
+    };
+
+    var _parallel = function(eachfn, tasks, callback) {
+        callback = callback || function () {};
+        if (tasks.constructor === Array) {
+            eachfn.map(tasks, function (fn, callback) {
+                if (fn) {
+                    fn(function (err) {
+                        var args = Array.prototype.slice.call(arguments, 1);
+                        if (args.length <= 1) {
+                            args = args[0];
+                        }
+                        callback.call(null, err, args);
+                    });
+                }
+            }, callback);
+        }
+        else {
+            var results = {};
+            eachfn.each(_keys(tasks), function (k, callback) {
+                tasks[k](function (err) {
+                    var args = Array.prototype.slice.call(arguments, 1);
+                    if (args.length <= 1) {
+                        args = args[0];
+                    }
+                    results[k] = args;
+                    callback(err);
+                });
+            }, function (err) {
+                callback(err, results);
+            });
+        }
+    };
+
+    async.parallel = function (tasks, callback) {
+        _parallel({ map: async.map, each: async.each }, tasks, callback);
+    };
+
+    async.parallelLimit = function(tasks, limit, callback) {
+        _parallel({ map: _mapLimit(limit), each: _eachLimit(limit) }, tasks, callback);
+    };
+
+    async.series = function (tasks, callback) {
+        callback = callback || function () {};
+        if (tasks.constructor === Array) {
+            async.mapSeries(tasks, function (fn, callback) {
+                if (fn) {
+                    fn(function (err) {
+                        var args = Array.prototype.slice.call(arguments, 1);
+                        if (args.length <= 1) {
+                            args = args[0];
+                        }
+                        callback.call(null, err, args);
+                    });
+                }
+            }, callback);
+        }
+        else {
+            var results = {};
+            async.eachSeries(_keys(tasks), function (k, callback) {
+                tasks[k](function (err) {
+                    var args = Array.prototype.slice.call(arguments, 1);
+                    if (args.length <= 1) {
+                        args = args[0];
+                    }
+                    results[k] = args;
+                    callback(err);
+                });
+            }, function (err) {
+                callback(err, results);
+            });
+        }
+    };
+
+    async.iterator = function (tasks) {
+        var makeCallback = function (index) {
+            var fn = function () {
+                if (tasks.length) {
+                    tasks[index].apply(null, arguments);
+                }
+                return fn.next();
+            };
+            fn.next = function () {
+                return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+            };
+            return fn;
+        };
+        return makeCallback(0);
+    };
+
+    async.apply = function (fn) {
+        var args = Array.prototype.slice.call(arguments, 1);
+        return function () {
+            return fn.apply(
+                null, args.concat(Array.prototype.slice.call(arguments))
+            );
+        };
+    };
+
+    var _concat = function (eachfn, arr, fn, callback) {
+        var r = [];
+        eachfn(arr, function (x, cb) {
+            fn(x, function (err, y) {
+                r = r.concat(y || []);
+                cb(err);
+            });
+        }, function (err) {
+            callback(err, r);
+        });
+    };
+    async.concat = doParallel(_concat);
+    async.concatSeries = doSeries(_concat);
+
+    async.whilst = function (test, iterator, callback) {
+        if (test()) {
+            iterator(function (err) {
+                if (err) {
+                    return callback(err);
+                }
+                async.whilst(test, iterator, callback);
+            });
+        }
+        else {
+            callback();
+        }
+    };
+
+    async.doWhilst = function (iterator, test, callback) {
+        iterator(function (err) {
+            if (err) {
+                return callback(err);
+            }
+            if (test()) {
+                async.doWhilst(iterator, test, callback);
+            }
+            else {
+                callback();
+            }
+        });
+    };
+
+    async.until = function (test, iterator, callback) {
+        if (!test()) {
+            iterator(function (err) {
+                if (err) {
+                    return callback(err);
+                }
+                async.until(test, iterator, callback);
+            });
+        }
+        else {
+            callback();
+        }
+    };
+
+    async.doUntil = function (iterator, test, callback) {
+        iterator(function (err) {
+            if (err) {
+                return callback(err);
+            }
+            if (!test()) {
+                async.doUntil(iterator, test, callback);
+            }
+            else {
+                callback();
+            }
+        });
+    };
+
+    async.queue = function (worker, concurrency) {
+        if (concurrency === undefined) {
+            concurrency = 1;
+        }
+        function _insert(q, data, pos, callback) {
+          if(data.constructor !== Array) {
+              data = [data];
+          }
+          _each(data, function(task) {
+              var item = {
+                  data: task,
+                  callback: typeof callback === 'function' ? callback : null
+              };
+
+              if (pos) {
+                q.tasks.unshift(item);
+              } else {
+                q.tasks.push(item);
+              }
+
+              if (q.saturated && q.tasks.length === concurrency) {
+                  q.saturated();
+              }
+              async.setImmediate(q.process);
+          });
+        }
+
+        var workers = 0;
+        var q = {
+            tasks: [],
+            concurrency: concurrency,
+            saturated: null,
+            empty: null,
+            drain: null,
+            push: function (data, callback) {
+              _insert(q, data, false, callback);
+            },
+            unshift: function (data, callback) {
+              _insert(q, data, true, callback);
+            },
+            process: function () {
+                if (workers < q.concurrency && q.tasks.length) {
+                    var task = q.tasks.shift();
+                    if (q.empty && q.tasks.length === 0) {
+                        q.empty();
+                    }
+                    workers += 1;
+                    var next = function () {
+                        workers -= 1;
+                        if (task.callback) {
+                            task.callback.apply(task, arguments);
+                        }
+                        if (q.drain && q.tasks.length + workers === 0) {
+                            q.drain();
+                        }
+                        q.process();
+                    };
+                    var cb = only_once(next);
+                    worker(task.data, cb);
+                }
+            },
+            length: function () {
+                return q.tasks.length;
+            },
+            running: function () {
+                return workers;
+            }
+        };
+        return q;
+    };
+
+    async.cargo = function (worker, payload) {
+        var working     = false,
+            tasks       = [];
+
+        var cargo = {
+            tasks: tasks,
+            payload: payload,
+            saturated: null,
+            empty: null,
+            drain: null,
+            push: function (data, callback) {
+                if(data.constructor !== Array) {
+                    data = [data];
+                }
+                _each(data, function(task) {
+                    tasks.push({
+                        data: task,
+                        callback: typeof callback === 'function' ? callback : null
+                    });
+                    if (cargo.saturated && tasks.length === payload) {
+                        cargo.saturated();
+                    }
+                });
+                async.setImmediate(cargo.process);
+            },
+            process: function process() {
+                if (working) return;
+                if (tasks.length === 0) {
+                    if(cargo.drain) cargo.drain();
+                    return;
+                }
+
+                var ts = typeof payload === 'number'
+                            ? tasks.splice(0, payload)
+                            : tasks.splice(0);
+
+                var ds = _map(ts, function (task) {
+                    return task.data;
+                });
+
+                if(cargo.empty) cargo.empty();
+                working = true;
+                worker(ds, function () {
+                    working = false;
+
+                    var args = arguments;
+                    _each(ts, function (data) {
+                        if (data.callback) {
+                            data.callback.apply(null, args);
+                        }
+                    });
+
+                    process();
+                });
+            },
+            length: function () {
+                return tasks.length;
+            },
+            running: function () {
+                return working;
+            }
+        };
+        return cargo;
+    };
+
+    var _console_fn = function (name) {
+        return function (fn) {
+            var args = Array.prototype.slice.call(arguments, 1);
+            fn.apply(null, args.concat([function (err) {
+                var args = Array.prototype.slice.call(arguments, 1);
+                if (typeof console !== 'undefined') {
+                    if (err) {
+                        if (console.error) {
+                            console.error(err);
+                        }
+                    }
+                    else if (console[name]) {
+                        _each(args, function (x) {
+                            console[name](x);
+                        });
+                    }
+                }
+            }]));
+        };
+    };
+    async.log = _console_fn('log');
+    async.dir = _console_fn('dir');
+    /*async.info = _console_fn('info');
+    async.warn = _console_fn('warn');
+    async.error = _console_fn('error');*/
+
+    async.memoize = function (fn, hasher) {
+        var memo = {};
+        var queues = {};
+        hasher = hasher || function (x) {
+            return x;
+        };
+        var memoized = function () {
+            var args = Array.prototype.slice.call(arguments);
+            var callback = args.pop();
+            var key = hasher.apply(null, args);
+            if (key in memo) {
+                callback.apply(null, memo[key]);
+            }
+            else if (key in queues) {
+                queues[key].push(callback);
+            }
+            else {
+                queues[key] = [callback];
+                fn.apply(null, args.concat([function () {
+                    memo[key] = arguments;
+                    var q = queues[key];
+                    delete queues[key];
+                    for (var i = 0, l = q.length; i < l; i++) {
+                      q[i].apply(null, arguments);
+                    }
+                }]));
+            }
+        };
+        memoized.memo = memo;
+        memoized.unmemoized = fn;
+        return memoized;
+    };
+
+    async.unmemoize = function (fn) {
+      return function () {
+        return (fn.unmemoized || fn).apply(null, arguments);
+      };
+    };
+
+    async.times = function (count, iterator, callback) {
+        var counter = [];
+        for (var i = 0; i < count; i++) {
+            counter.push(i);
+        }
+        return async.map(counter, iterator, callback);
+    };
+
+    async.timesSeries = function (count, iterator, callback) {
+        var counter = [];
+        for (var i = 0; i < count; i++) {
+            counter.push(i);
+        }
+        return async.mapSeries(counter, iterator, callback);
+    };
+
+    async.compose = function (/* functions... */) {
+        var fns = Array.prototype.reverse.call(arguments);
+        return function () {
+            var that = this;
+            var args = Array.prototype.slice.call(arguments);
+            var callback = args.pop();
+            async.reduce(fns, args, function (newargs, fn, cb) {
+                fn.apply(that, newargs.concat([function () {
+                    var err = arguments[0];
+                    var nextargs = Array.prototype.slice.call(arguments, 1);
+                    cb(err, nextargs);
+                }]))
+            },
+            function (err, results) {
+                callback.apply(that, [err].concat(results));
+            });
+        };
+    };
+
+    var _applyEach = function (eachfn, fns /*args...*/) {
+        var go = function () {
+            var that = this;
+            var args = Array.prototype.slice.call(arguments);
+            var callback = args.pop();
+            return eachfn(fns, function (fn, cb) {
+                fn.apply(that, args.concat([cb]));
+            },
+            callback);
+        };
+        if (arguments.length > 2) {
+            var args = Array.prototype.slice.call(arguments, 2);
+            return go.apply(this, args);
+        }
+        else {
+            return go;
+        }
+    };
+    async.applyEach = doParallel(_applyEach);
+    async.applyEachSeries = doSeries(_applyEach);
+
+    async.forever = function (fn, callback) {
+        function next(err) {
+            if (err) {
+                if (callback) {
+                    return callback(err);
+                }
+                throw err;
+            }
+            fn(next);
+        }
+        next();
+    };
+
+    // AMD / RequireJS
+    if (typeof define !== 'undefined' && define.amd) {
+        define([], function () {
+            return async;
+        });
+    }
+    // Node.js
+    else if (typeof module !== 'undefined' && module.exports) {
+        module.exports = async;
+    }
+    // included directly via <script> tag
+    else {
+        root.async = async;
+    }
+
+}());

node_modules/fs-plus/node_modules/async/package.json

@@ -0,0 +1,64 @@
+{
+  "_from": "async@>=0.2.9 <0.3.0",
+  "_id": "async@0.2.10",
+  "_inBundle": false,
+  "_integrity": "sha512-eAkdoKxU6/LkKDBzLpT+t6Ff5EtfSF4wx1WfJiPEEV7WNLnDaRXk0oVysiEPm262roaachGexwUv94WhSgN5TQ==",
+  "_location": "/fs-plus/async",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "async@0.2.10",
+    "name": "async",
+    "escapedName": "async",
+    "rawSpec": "0.2.10",
+    "saveSpec": null,
+    "fetchSpec": "0.2.10"
+  },
+  "_requiredBy": [
+    "/fs-plus"
+  ],
+  "_resolved": "https://registry.npmjs.org/async/-/async-0.2.10.tgz",
+  "_shasum": "b6bbe0b0674b9d719708ca38de8c237cb526c3d1",
+  "_spec": "async@0.2.10",
+  "_where": "/tmp/jibo-npm/jibo-cli-3.0.7",
+  "author": {
+    "name": "Caolan McMahon"
+  },
+  "bugs": {
+    "url": "https://github.com/caolan/async/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Higher-order functions and common patterns for asynchronous code",
+  "devDependencies": {
+    "nodelint": ">0.0.0",
+    "nodeunit": ">0.0.0",
+    "uglify-js": "1.2.x"
+  },
+  "homepage": "https://github.com/caolan/async#readme",
+  "jam": {
+    "main": "lib/async.js",
+    "include": [
+      "lib/async.js",
+      "README.md",
+      "LICENSE"
+    ]
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/caolan/async/raw/master/LICENSE"
+    }
+  ],
+  "main": "./lib/async",
+  "name": "async",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/caolan/async.git"
+  },
+  "scripts": {
+    "test": "nodeunit test/test-async.js"
+  },
+  "version": "0.2.10"
+}

node_modules/fs-plus/node_modules/mkdirp/.npmignore

@@ -0,0 +1,2 @@
+node_modules/
+npm-debug.log

node_modules/fs-plus/node_modules/mkdirp/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.6
+  - 0.8
+  - 0.9

node_modules/fs-plus/node_modules/mkdirp/LICENSE

@@ -0,0 +1,21 @@
+Copyright 2010 James Halliday (mail@substack.net)
+
+This project is free software released under the MIT/X11 license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/fs-plus/node_modules/mkdirp/examples/pow.js

@@ -0,0 +1,6 @@
+var mkdirp = require('mkdirp');
+
+mkdirp('/tmp/foo/bar/baz', function (err) {
+    if (err) console.error(err)
+    else console.log('pow!')
+});

node_modules/fs-plus/node_modules/mkdirp/index.js

@@ -0,0 +1,82 @@
+var path = require('path');
+var fs = require('fs');
+
+module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
+
+function mkdirP (p, mode, f, made) {
+    if (typeof mode === 'function' || mode === undefined) {
+        f = mode;
+        mode = 0777 & (~process.umask());
+    }
+    if (!made) made = null;
+
+    var cb = f || function () {};
+    if (typeof mode === 'string') mode = parseInt(mode, 8);
+    p = path.resolve(p);
+
+    fs.mkdir(p, mode, function (er) {
+        if (!er) {
+            made = made || p;
+            return cb(null, made);
+        }
+        switch (er.code) {
+            case 'ENOENT':
+                mkdirP(path.dirname(p), mode, function (er, made) {
+                    if (er) cb(er, made);
+                    else mkdirP(p, mode, cb, made);
+                });
+                break;
+
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                fs.stat(p, function (er2, stat) {
+                    // if the stat fails, then that's super weird.
+                    // let the original error be the failure reason.
+                    if (er2 || !stat.isDirectory()) cb(er, made)
+                    else cb(null, made);
+                });
+                break;
+        }
+    });
+}
+
+mkdirP.sync = function sync (p, mode, made) {
+    if (mode === undefined) {
+        mode = 0777 & (~process.umask());
+    }
+    if (!made) made = null;
+
+    if (typeof mode === 'string') mode = parseInt(mode, 8);
+    p = path.resolve(p);
+
+    try {
+        fs.mkdirSync(p, mode);
+        made = made || p;
+    }
+    catch (err0) {
+        switch (err0.code) {
+            case 'ENOENT' :
+                made = sync(path.dirname(p), mode, made);
+                sync(p, mode, made);
+                break;
+
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                var stat;
+                try {
+                    stat = fs.statSync(p);
+                }
+                catch (err1) {
+                    throw err0;
+                }
+                if (!stat.isDirectory()) throw err0;
+                break;
+        }
+    }
+
+    return made;
+};

node_modules/fs-plus/node_modules/mkdirp/package.json

@@ -0,0 +1,55 @@
+{
+  "_from": "mkdirp@>=0.3.5 <0.4.0",
+  "_id": "mkdirp@0.3.5",
+  "_inBundle": false,
+  "_integrity": "sha512-8OCq0De/h9ZxseqzCH8Kw/Filf5pF/vMI6+BH7Lu0jXz2pqYCjTAQRolSxRIi+Ax+oCCjlxoJMP0YQ4XlrQNHg==",
+  "_location": "/fs-plus/mkdirp",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "mkdirp@0.3.5",
+    "name": "mkdirp",
+    "escapedName": "mkdirp",
+    "rawSpec": "0.3.5",
+    "saveSpec": null,
+    "fetchSpec": "0.3.5"
+  },
+  "_requiredBy": [
+    "/fs-plus"
+  ],
+  "_resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.3.5.tgz",
+  "_shasum": "de3e5f8961c88c787ee1368df849ac4413eca8d7",
+  "_spec": "mkdirp@0.3.5",
+  "_where": "/tmp/jibo-npm/jibo-cli-3.0.7",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "bugs": {
+    "url": "https://github.com/substack/node-mkdirp/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": "Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.)",
+  "description": "Recursively mkdir, like `mkdir -p`",
+  "devDependencies": {
+    "tap": "~0.4.0"
+  },
+  "homepage": "https://github.com/substack/node-mkdirp#readme",
+  "keywords": [
+    "mkdir",
+    "directory"
+  ],
+  "license": "MIT",
+  "main": "./index",
+  "name": "mkdirp",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/substack/node-mkdirp.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "version": "0.3.5"
+}

node_modules/fs-plus/node_modules/mkdirp/readme.markdown

@@ -0,0 +1,63 @@
+# mkdirp
+
+Like `mkdir -p`, but in node.js!
+
+[![build status](https://secure.travis-ci.org/substack/node-mkdirp.png)](http://travis-ci.org/substack/node-mkdirp)
+
+# example
+
+## pow.js
+
+```js
+var mkdirp = require('mkdirp');
+    
+mkdirp('/tmp/foo/bar/baz', function (err) {
+    if (err) console.error(err)
+    else console.log('pow!')
+});
+```
+
+Output
+
+```
+pow!
+```
+
+And now /tmp/foo/bar/baz exists, huzzah!
+
+# methods
+
+```js
+var mkdirp = require('mkdirp');
+```
+
+## mkdirp(dir, mode, cb)
+
+Create a new directory and any necessary subdirectories at `dir` with octal
+permission string `mode`.
+
+If `mode` isn't specified, it defaults to `0777 & (~process.umask())`.
+
+`cb(err, made)` fires with the error or the first directory `made`
+that had to be created, if any.
+
+## mkdirp.sync(dir, mode)
+
+Synchronously create a new directory and any necessary subdirectories at `dir`
+with octal permission string `mode`.
+
+If `mode` isn't specified, it defaults to `0777 & (~process.umask())`.
+
+Returns the first directory that had to be created, if any.
+
+# install
+
+With [npm](http://npmjs.org) do:
+
+```
+npm install mkdirp
+```
+
+# license
+
+MIT

node_modules/fs-plus/node_modules/mkdirp/test/chmod.js

@@ -0,0 +1,38 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+var ps = [ '', 'tmp' ];
+
+for (var i = 0; i < 25; i++) {
+    var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    ps.push(dir);
+}
+
+var file = ps.join('/');
+
+test('chmod-pre', function (t) {
+    var mode = 0744
+    mkdirp(file, mode, function (er) {
+        t.ifError(er, 'should not error');
+        fs.stat(file, function (er, stat) {
+            t.ifError(er, 'should exist');
+            t.ok(stat && stat.isDirectory(), 'should be directory');
+            t.equal(stat && stat.mode & 0777, mode, 'should be 0744');
+            t.end();
+        });
+    });
+});
+
+test('chmod', function (t) {
+    var mode = 0755
+    mkdirp(file, mode, function (er) {
+        t.ifError(er, 'should not error');
+        fs.stat(file, function (er, stat) {
+            t.ifError(er, 'should exist');
+            t.ok(stat && stat.isDirectory(), 'should be directory');
+            t.end();
+        });
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/clobber.js

@@ -0,0 +1,37 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+var ps = [ '', 'tmp' ];
+
+for (var i = 0; i < 25; i++) {
+    var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    ps.push(dir);
+}
+
+var file = ps.join('/');
+
+// a file in the way
+var itw = ps.slice(0, 3).join('/');
+
+
+test('clobber-pre', function (t) {
+    console.error("about to write to "+itw)
+    fs.writeFileSync(itw, 'I AM IN THE WAY, THE TRUTH, AND THE LIGHT.');
+
+    fs.stat(itw, function (er, stat) {
+        t.ifError(er)
+        t.ok(stat && stat.isFile(), 'should be file')
+        t.end()
+    })
+})
+
+test('clobber', function (t) {
+    t.plan(2);
+    mkdirp(file, 0755, function (err) {
+        t.ok(err);
+        t.equal(err.code, 'ENOTDIR');
+        t.end();
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/mkdirp.js

@@ -0,0 +1,28 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('woo', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/tmp/' + [x,y,z].join('/');
+    
+    mkdirp(file, 0755, function (err) {
+        if (err) t.fail(err);
+        else path.exists(file, function (ex) {
+            if (!ex) t.fail('file not created')
+            else fs.stat(file, function (err, stat) {
+                if (err) t.fail(err)
+                else {
+                    t.equal(stat.mode & 0777, 0755);
+                    t.ok(stat.isDirectory(), 'target not a directory');
+                    t.end();
+                }
+            })
+        })
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/perm.js

@@ -0,0 +1,32 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('async perm', function (t) {
+    t.plan(2);
+    var file = '/tmp/' + (Math.random() * (1<<30)).toString(16);
+    
+    mkdirp(file, 0755, function (err) {
+        if (err) t.fail(err);
+        else path.exists(file, function (ex) {
+            if (!ex) t.fail('file not created')
+            else fs.stat(file, function (err, stat) {
+                if (err) t.fail(err)
+                else {
+                    t.equal(stat.mode & 0777, 0755);
+                    t.ok(stat.isDirectory(), 'target not a directory');
+                    t.end();
+                }
+            })
+        })
+    });
+});
+
+test('async root perm', function (t) {
+    mkdirp('/tmp', 0755, function (err) {
+        if (err) t.fail(err);
+        t.end();
+    });
+    t.end();
+});

node_modules/fs-plus/node_modules/mkdirp/test/perm_sync.js

@@ -0,0 +1,39 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('sync perm', function (t) {
+    t.plan(2);
+    var file = '/tmp/' + (Math.random() * (1<<30)).toString(16) + '.json';
+    
+    mkdirp.sync(file, 0755);
+    path.exists(file, function (ex) {
+        if (!ex) t.fail('file not created')
+        else fs.stat(file, function (err, stat) {
+            if (err) t.fail(err)
+            else {
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+                t.end();
+            }
+        })
+    });
+});
+
+test('sync root perm', function (t) {
+    t.plan(1);
+    
+    var file = '/tmp';
+    mkdirp.sync(file, 0755);
+    path.exists(file, function (ex) {
+        if (!ex) t.fail('file not created')
+        else fs.stat(file, function (err, stat) {
+            if (err) t.fail(err)
+            else {
+                t.ok(stat.isDirectory(), 'target not a directory');
+                t.end();
+            }
+        })
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/race.js

@@ -0,0 +1,41 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('race', function (t) {
+    t.plan(4);
+    var ps = [ '', 'tmp' ];
+    
+    for (var i = 0; i < 25; i++) {
+        var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+        ps.push(dir);
+    }
+    var file = ps.join('/');
+    
+    var res = 2;
+    mk(file, function () {
+        if (--res === 0) t.end();
+    });
+    
+    mk(file, function () {
+        if (--res === 0) t.end();
+    });
+    
+    function mk (file, cb) {
+        mkdirp(file, 0755, function (err) {
+            if (err) t.fail(err);
+            else path.exists(file, function (ex) {
+                if (!ex) t.fail('file not created')
+                else fs.stat(file, function (err, stat) {
+                    if (err) t.fail(err)
+                    else {
+                        t.equal(stat.mode & 0777, 0755);
+                        t.ok(stat.isDirectory(), 'target not a directory');
+                        if (cb) cb();
+                    }
+                })
+            })
+        });
+    }
+});

node_modules/fs-plus/node_modules/mkdirp/test/rel.js

@@ -0,0 +1,32 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('rel', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var cwd = process.cwd();
+    process.chdir('/tmp');
+    
+    var file = [x,y,z].join('/');
+    
+    mkdirp(file, 0755, function (err) {
+        if (err) t.fail(err);
+        else path.exists(file, function (ex) {
+            if (!ex) t.fail('file not created')
+            else fs.stat(file, function (err, stat) {
+                if (err) t.fail(err)
+                else {
+                    process.chdir(cwd);
+                    t.equal(stat.mode & 0777, 0755);
+                    t.ok(stat.isDirectory(), 'target not a directory');
+                    t.end();
+                }
+            })
+        })
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/return.js

@@ -0,0 +1,25 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('return value', function (t) {
+    t.plan(4);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    // should return the first dir created.
+    // By this point, it would be profoundly surprising if /tmp didn't
+    // already exist, since every other test makes things in there.
+    mkdirp(file, function (err, made) {
+        t.ifError(err);
+        t.equal(made, '/tmp/' + x);
+        mkdirp(file, function (err, made) {
+          t.ifError(err);
+          t.equal(made, null);
+        });
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/return_sync.js

@@ -0,0 +1,24 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('return value', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    // should return the first dir created.
+    // By this point, it would be profoundly surprising if /tmp didn't
+    // already exist, since every other test makes things in there.
+    // Note that this will throw on failure, which will fail the test.
+    var made = mkdirp.sync(file);
+    t.equal(made, '/tmp/' + x);
+
+    // making the same file again should have no effect.
+    made = mkdirp.sync(file);
+    t.equal(made, null);
+});

node_modules/fs-plus/node_modules/mkdirp/test/root.js

@@ -0,0 +1,18 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('root', function (t) {
+    // '/' on unix, 'c:/' on windows.
+    var file = path.resolve('/');
+
+    mkdirp(file, 0755, function (err) {
+        if (err) throw err
+        fs.stat(file, function (er, stat) {
+            if (er) throw er
+            t.ok(stat.isDirectory(), 'target is a directory');
+            t.end();
+        })
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/sync.js

@@ -0,0 +1,32 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('sync', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    try {
+        mkdirp.sync(file, 0755);
+    } catch (err) {
+        t.fail(err);
+        return t.end();
+    }
+
+    path.exists(file, function (ex) {
+        if (!ex) t.fail('file not created')
+        else fs.stat(file, function (err, stat) {
+            if (err) t.fail(err)
+            else {
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+                t.end();
+            }
+        });
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/umask.js

@@ -0,0 +1,28 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('implicit mode from umask', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/tmp/' + [x,y,z].join('/');
+    
+    mkdirp(file, function (err) {
+        if (err) t.fail(err);
+        else path.exists(file, function (ex) {
+            if (!ex) t.fail('file not created')
+            else fs.stat(file, function (err, stat) {
+                if (err) t.fail(err)
+                else {
+                    t.equal(stat.mode & 0777, 0777 & (~process.umask()));
+                    t.ok(stat.isDirectory(), 'target not a directory');
+                    t.end();
+                }
+            })
+        })
+    });
+});

node_modules/fs-plus/node_modules/mkdirp/test/umask_sync.js

@@ -0,0 +1,32 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('umask sync modes', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    try {
+        mkdirp.sync(file);
+    } catch (err) {
+        t.fail(err);
+        return t.end();
+    }
+
+    path.exists(file, function (ex) {
+        if (!ex) t.fail('file not created')
+        else fs.stat(file, function (err, stat) {
+            if (err) t.fail(err)
+            else {
+                t.equal(stat.mode & 0777, (0777 & (~process.umask())));
+                t.ok(stat.isDirectory(), 'target not a directory');
+                t.end();
+            }
+        });
+    });
+});

node_modules/fs-plus/node_modules/rimraf/AUTHORS

@@ -0,0 +1,6 @@
+# Authors sorted by whether or not they're me.
+Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)
+Wayne Larsen <wayne@larsen.st> (http://github.com/wvl)
+ritch <skawful@gmail.com>
+Marcel Laverdet
+Yosef Dinerstein <yosefd@microsoft.com>

node_modules/fs-plus/node_modules/rimraf/LICENSE

@@ -0,0 +1,23 @@
+Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

node_modules/fs-plus/node_modules/rimraf/README.md

@@ -0,0 +1,30 @@
+`rm -rf` for node.
+
+Install with `npm install rimraf`, or just drop rimraf.js somewhere.
+
+## API
+
+`rimraf(f, callback)`
+
+The callback will be called with an error if there is one.  Certain
+errors are handled for you:
+
+* Windows: `EBUSY` and `ENOTEMPTY` - rimraf will back off a maximum of
+  `opts.maxBusyTries` times before giving up.
+* `ENOENT` - If the file doesn't exist, rimraf will return
+  successfully, since your desired outcome is already the case.
+
+## rimraf.sync
+
+It can remove stuff synchronously, too.  But that's not so good.  Use
+the async API.  It's better.
+
+## CLI
+
+If installed with `npm install rimraf -g` it can be used as a global
+command `rimraf <path>` which is useful for cross platform support.
+
+## mkdirp
+
+If you need to create a directory recursively, check out
+[mkdirp](https://github.com/substack/node-mkdirp).

node_modules/fs-plus/node_modules/rimraf/bin.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+var rimraf = require('./')
+
+var help = false
+var dashdash = false
+var args = process.argv.slice(2).filter(function(arg) {
+  if (dashdash)
+    return !!arg
+  else if (arg === '--')
+    dashdash = true
+  else if (arg.match(/^(-+|\/)(h(elp)?|\?)$/))
+    help = true
+  else
+    return !!arg
+});
+
+if (help || args.length === 0) {
+  // If they didn't ask for help, then this is not a "success"
+  var log = help ? console.log : console.error
+  log('Usage: rimraf <path>')
+  log('')
+  log('  Deletes all files and folders at "path" recursively.')
+  log('')
+  log('Options:')
+  log('')
+  log('  -h, --help    Display this usage info')
+  process.exit(help ? 0 : 1)
+} else {
+  args.forEach(function(arg) {
+    rimraf.sync(arg)
+  })
+}

node_modules/fs-plus/node_modules/rimraf/package.json

@@ -0,0 +1,77 @@
+{
+  "_from": "rimraf@>=2.2.2 <2.3.0",
+  "_id": "rimraf@2.2.8",
+  "_inBundle": false,
+  "_integrity": "sha512-R5KMKHnPAQaZMqLOsyuyUmcIjSeDm+73eoqQpaXA7AZ22BL+6C+1mcUscgOsNd8WVlJuvlgAPsegcx7pjlV0Dg==",
+  "_location": "/fs-plus/rimraf",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "rimraf@2.2.8",
+    "name": "rimraf",
+    "escapedName": "rimraf",
+    "rawSpec": "2.2.8",
+    "saveSpec": null,
+    "fetchSpec": "2.2.8"
+  },
+  "_requiredBy": [
+    "/fs-plus"
+  ],
+  "_resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.2.8.tgz",
+  "_shasum": "e439be2aaee327321952730f99a8929e4fc50582",
+  "_spec": "rimraf@2.2.8",
+  "_where": "/tmp/jibo-npm/jibo-cli-3.0.7",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "bin": {
+    "rimraf": "./bin.js"
+  },
+  "bugs": {
+    "url": "https://github.com/isaacs/rimraf/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Isaac Z. Schlueter",
+      "email": "i@izs.me",
+      "url": "http://blog.izs.me"
+    },
+    {
+      "name": "Wayne Larsen",
+      "email": "wayne@larsen.st",
+      "url": "http://github.com/wvl"
+    },
+    {
+      "name": "ritch",
+      "email": "skawful@gmail.com"
+    },
+    {
+      "name": "Marcel Laverdet"
+    },
+    {
+      "name": "Yosef Dinerstein",
+      "email": "yosefd@microsoft.com"
+    }
+  ],
+  "deprecated": "Rimraf versions prior to v4 are no longer supported",
+  "description": "A deep deletion module for node (like `rm -rf`)",
+  "homepage": "https://github.com/isaacs/rimraf#readme",
+  "license": {
+    "type": "MIT",
+    "url": "https://github.com/isaacs/rimraf/raw/master/LICENSE"
+  },
+  "main": "rimraf.js",
+  "name": "rimraf",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/rimraf.git"
+  },
+  "scripts": {
+    "test": "cd test && bash run.sh"
+  },
+  "version": "2.2.8"
+}

node_modules/fs-plus/node_modules/rimraf/rimraf.js

@@ -0,0 +1,248 @@
+module.exports = rimraf
+rimraf.sync = rimrafSync
+
+var assert = require("assert")
+var path = require("path")
+var fs = require("fs")
+
+// for EMFILE handling
+var timeout = 0
+exports.EMFILE_MAX = 1000
+exports.BUSYTRIES_MAX = 3
+
+var isWindows = (process.platform === "win32")
+
+function defaults (options) {
+  var methods = [
+    'unlink',
+    'chmod',
+    'stat',
+    'rmdir',
+    'readdir'
+  ]
+  methods.forEach(function(m) {
+    options[m] = options[m] || fs[m]
+    m = m + 'Sync'
+    options[m] = options[m] || fs[m]
+  })
+}
+
+function rimraf (p, options, cb) {
+  if (typeof options === 'function') {
+    cb = options
+    options = {}
+  }
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+
+  defaults(options)
+
+  if (!cb) throw new Error("No callback passed to rimraf()")
+
+  var busyTries = 0
+  rimraf_(p, options, function CB (er) {
+    if (er) {
+      if (isWindows && (er.code === "EBUSY" || er.code === "ENOTEMPTY") &&
+          busyTries < exports.BUSYTRIES_MAX) {
+        busyTries ++
+        var time = busyTries * 100
+        // try again, with the same exact callback as this one.
+        return setTimeout(function () {
+          rimraf_(p, options, CB)
+        }, time)
+      }
+
+      // this one won't happen if graceful-fs is used.
+      if (er.code === "EMFILE" && timeout < exports.EMFILE_MAX) {
+        return setTimeout(function () {
+          rimraf_(p, options, CB)
+        }, timeout ++)
+      }
+
+      // already gone
+      if (er.code === "ENOENT") er = null
+    }
+
+    timeout = 0
+    cb(er)
+  })
+}
+
+// Two possible strategies.
+// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
+// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
+//
+// Both result in an extra syscall when you guess wrong.  However, there
+// are likely far more normal files in the world than directories.  This
+// is based on the assumption that a the average number of files per
+// directory is >= 1.
+//
+// If anyone ever complains about this, then I guess the strategy could
+// be made configurable somehow.  But until then, YAGNI.
+function rimraf_ (p, options, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+
+  options.unlink(p, function (er) {
+    if (er) {
+      if (er.code === "ENOENT")
+        return cb(null)
+      if (er.code === "EPERM")
+        return (isWindows)
+          ? fixWinEPERM(p, options, er, cb)
+          : rmdir(p, options, er, cb)
+      if (er.code === "EISDIR")
+        return rmdir(p, options, er, cb)
+    }
+    return cb(er)
+  })
+}
+
+function fixWinEPERM (p, options, er, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+  if (er)
+    assert(er instanceof Error)
+
+  options.chmod(p, 666, function (er2) {
+    if (er2)
+      cb(er2.code === "ENOENT" ? null : er)
+    else
+      options.stat(p, function(er3, stats) {
+        if (er3)
+          cb(er3.code === "ENOENT" ? null : er)
+        else if (stats.isDirectory())
+          rmdir(p, options, er, cb)
+        else
+          options.unlink(p, cb)
+      })
+  })
+}
+
+function fixWinEPERMSync (p, options, er) {
+  assert(p)
+  assert(options)
+  if (er)
+    assert(er instanceof Error)
+
+  try {
+    options.chmodSync(p, 666)
+  } catch (er2) {
+    if (er2.code === "ENOENT")
+      return
+    else
+      throw er
+  }
+
+  try {
+    var stats = options.statSync(p)
+  } catch (er3) {
+    if (er3.code === "ENOENT")
+      return
+    else
+      throw er
+  }
+
+  if (stats.isDirectory())
+    rmdirSync(p, options, er)
+  else
+    options.unlinkSync(p)
+}
+
+function rmdir (p, options, originalEr, cb) {
+  assert(p)
+  assert(options)
+  if (originalEr)
+    assert(originalEr instanceof Error)
+  assert(typeof cb === 'function')
+
+  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
+  // if we guessed wrong, and it's not a directory, then
+  // raise the original error.
+  options.rmdir(p, function (er) {
+    if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
+      rmkids(p, options, cb)
+    else if (er && er.code === "ENOTDIR")
+      cb(originalEr)
+    else
+      cb(er)
+  })
+}
+
+function rmkids(p, options, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+
+  options.readdir(p, function (er, files) {
+    if (er)
+      return cb(er)
+    var n = files.length
+    if (n === 0)
+      return options.rmdir(p, cb)
+    var errState
+    files.forEach(function (f) {
+      rimraf(path.join(p, f), options, function (er) {
+        if (errState)
+          return
+        if (er)
+          return cb(errState = er)
+        if (--n === 0)
+          options.rmdir(p, cb)
+      })
+    })
+  })
+}
+
+// this looks simpler, and is strictly *faster*, but will
+// tie up the JavaScript thread and fail on excessively
+// deep directory trees.
+function rimrafSync (p, options) {
+  options = options || {}
+  defaults(options)
+
+  assert(p)
+  assert(options)
+
+  try {
+    options.unlinkSync(p)
+  } catch (er) {
+    if (er.code === "ENOENT")
+      return
+    if (er.code === "EPERM")
+      return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
+    if (er.code !== "EISDIR")
+      throw er
+    rmdirSync(p, options, er)
+  }
+}
+
+function rmdirSync (p, options, originalEr) {
+  assert(p)
+  assert(options)
+  if (originalEr)
+    assert(originalEr instanceof Error)
+
+  try {
+    options.rmdirSync(p)
+  } catch (er) {
+    if (er.code === "ENOENT")
+      return
+    if (er.code === "ENOTDIR")
+      throw originalEr
+    if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
+      rmkidsSync(p, options)
+  }
+}
+
+function rmkidsSync (p, options) {
+  assert(p)
+  assert(options)
+  options.readdirSync(p).forEach(function (f) {
+    rimrafSync(path.join(p, f), options)
+  })
+  options.rmdirSync(p, options)
+}

node_modules/fs-plus/node_modules/rimraf/test/run.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+code=0
+for i in test-*.js; do
+  echo -n $i ...
+  bash setup.sh
+  node $i
+  if [ -d target ]; then
+    echo "fail"
+    code=1
+  else
+    echo "pass"
+  fi
+done
+rm -rf target
+exit $code

node_modules/fs-plus/node_modules/rimraf/test/setup.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+set -e
+
+files=10
+folders=2
+depth=4
+target="$PWD/target"
+
+rm -rf target
+
+fill () {
+  local depth=$1
+  local files=$2
+  local folders=$3
+  local target=$4
+
+  if ! [ -d $target ]; then
+    mkdir -p $target
+  fi
+
+  local f
+
+  f=$files
+  while [ $f -gt 0 ]; do
+    touch "$target/f-$depth-$f"
+    let f--
+  done
+
+  let depth--
+
+  if [ $depth -le 0 ]; then
+    return 0
+  fi
+
+  f=$folders
+  while [ $f -gt 0 ]; do
+    mkdir "$target/folder-$depth-$f"
+    fill $depth $files $folders "$target/d-$depth-$f"
+    let f--
+  done
+}
+
+fill $depth $files $folders $target
+
+# sanity assert
+[ -d $target ]

node_modules/fs-plus/node_modules/rimraf/test/test-async.js

@@ -0,0 +1,5 @@
+var rimraf = require("../rimraf")
+  , path = require("path")
+rimraf(path.join(__dirname, "target"), function (er) {
+  if (er) throw er
+})

node_modules/fs-plus/node_modules/rimraf/test/test-sync.js

@@ -0,0 +1,3 @@
+var rimraf = require("../rimraf")
+  , path = require("path")
+rimraf.sync(path.join(__dirname, "target"))

node_modules/fs-plus/node_modules/underscore-plus/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2013 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/fs-plus/node_modules/underscore-plus/README.md

@@ -0,0 +1,14 @@
+# underscore-plus [![Build Status](https://travis-ci.org/atom/underscore-plus.svg?branch=master)](https://travis-ci.org/atom/underscore-plus)
+
+Takes the great [underscore](http://underscorejs.org/) library and adds a few
+more things.
+
+## Using
+
+```sh
+npm install underscore-plus
+```
+
+```coffeescript
+_ = require 'underscore-plus' # Has all underscore methods and more
+```

node_modules/fs-plus/node_modules/underscore-plus/lib/underscore-plus.js

@@ -0,0 +1,522 @@
+(function() {
+  var isEqual, isPlainObject, macModifierKeyMap, nonMacModifierKeyMap, plus, shiftKeyMap, splitKeyPath, _,
+    __slice = [].slice;
+
+  _ = require('underscore');
+
+  macModifierKeyMap = {
+    cmd: '\u2318',
+    ctrl: '\u2303',
+    alt: '\u2325',
+    option: '\u2325',
+    shift: '\u21e7',
+    enter: '\u23ce',
+    left: '\u2190',
+    right: '\u2192',
+    up: '\u2191',
+    down: '\u2193'
+  };
+
+  nonMacModifierKeyMap = {
+    cmd: 'Cmd',
+    ctrl: 'Ctrl',
+    alt: 'Alt',
+    option: 'Alt',
+    shift: 'Shift',
+    enter: 'Enter',
+    left: 'Left',
+    right: 'Right',
+    up: 'Up',
+    down: 'Down'
+  };
+
+  shiftKeyMap = {
+    '~': '`',
+    '_': '-',
+    '+': '=',
+    '|': '\\',
+    '{': '[',
+    '}': ']',
+    ':': ';',
+    '"': '\'',
+    '<': ',',
+    '>': '.',
+    '?': '/'
+  };
+
+  splitKeyPath = function(keyPath) {
+    var char, i, keyPathArray, startIndex, _i, _len;
+    startIndex = 0;
+    keyPathArray = [];
+    if (keyPath == null) {
+      return keyPathArray;
+    }
+    for (i = _i = 0, _len = keyPath.length; _i < _len; i = ++_i) {
+      char = keyPath[i];
+      if (char === '.' && (i === 0 || keyPath[i - 1] !== '\\')) {
+        keyPathArray.push(keyPath.substring(startIndex, i));
+        startIndex = i + 1;
+      }
+    }
+    keyPathArray.push(keyPath.substr(startIndex, keyPath.length));
+    return keyPathArray;
+  };
+
+  isPlainObject = function(value) {
+    return _.isObject(value) && !_.isArray(value);
+  };
+
+  plus = {
+    adviseBefore: function(object, methodName, advice) {
+      var original;
+      original = object[methodName];
+      return object[methodName] = function() {
+        var args;
+        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+        if (advice.apply(this, args) !== false) {
+          return original.apply(this, args);
+        }
+      };
+    },
+    camelize: function(string) {
+      if (string) {
+        return string.replace(/[_-]+(\w)/g, function(m) {
+          return m[1].toUpperCase();
+        });
+      } else {
+        return '';
+      }
+    },
+    capitalize: function(word) {
+      if (!word) {
+        return '';
+      }
+      if (word.toLowerCase() === 'github') {
+        return 'GitHub';
+      } else {
+        return word[0].toUpperCase() + word.slice(1);
+      }
+    },
+    compactObject: function(object) {
+      var key, newObject, value;
+      newObject = {};
+      for (key in object) {
+        value = object[key];
+        if (value != null) {
+          newObject[key] = value;
+        }
+      }
+      return newObject;
+    },
+    dasherize: function(string) {
+      if (!string) {
+        return '';
+      }
+      string = string[0].toLowerCase() + string.slice(1);
+      return string.replace(/([A-Z])|(_)/g, function(m, letter) {
+        if (letter) {
+          return "-" + letter.toLowerCase();
+        } else {
+          return "-";
+        }
+      });
+    },
+    deepClone: function(object) {
+      if (_.isArray(object)) {
+        return object.map(function(value) {
+          return plus.deepClone(value);
+        });
+      } else if (_.isObject(object) && !_.isFunction(object)) {
+        return plus.mapObject(object, (function(_this) {
+          return function(key, value) {
+            return [key, plus.deepClone(value)];
+          };
+        })(this));
+      } else {
+        return object;
+      }
+    },
+    deepExtend: function(target) {
+      var i, key, object, result, _i, _len, _ref;
+      result = target;
+      i = 0;
+      while (++i < arguments.length) {
+        object = arguments[i];
+        if (isPlainObject(result) && isPlainObject(object)) {
+          _ref = Object.keys(object);
+          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+            key = _ref[_i];
+            result[key] = plus.deepExtend(result[key], object[key]);
+          }
+        } else {
+          result = plus.deepClone(object);
+        }
+      }
+      return result;
+    },
+    deepContains: function(array, target) {
+      var object, _i, _len;
+      if (array == null) {
+        return false;
+      }
+      for (_i = 0, _len = array.length; _i < _len; _i++) {
+        object = array[_i];
+        if (_.isEqual(object, target)) {
+          return true;
+        }
+      }
+      return false;
+    },
+    endsWith: function(string, suffix) {
+      if (suffix == null) {
+        suffix = '';
+      }
+      if (string) {
+        return string.indexOf(suffix, string.length - suffix.length) !== -1;
+      } else {
+        return false;
+      }
+    },
+    escapeAttribute: function(string) {
+      if (string) {
+        return string.replace(/"/g, '&quot;').replace(/\n/g, '').replace(/\\/g, '-');
+      } else {
+        return '';
+      }
+    },
+    escapeRegExp: function(string) {
+      if (string) {
+        return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+      } else {
+        return '';
+      }
+    },
+    humanizeEventName: function(eventName, eventDoc) {
+      var event, namespace, namespaceDoc, _ref;
+      _ref = eventName.split(':'), namespace = _ref[0], event = _ref[1];
+      if (event == null) {
+        return plus.undasherize(namespace);
+      }
+      namespaceDoc = plus.undasherize(namespace);
+      if (eventDoc == null) {
+        eventDoc = plus.undasherize(event);
+      }
+      return "" + namespaceDoc + ": " + eventDoc;
+    },
+    humanizeKey: function(key, platform) {
+      var modifierKeyMap;
+      if (platform == null) {
+        platform = process.platform;
+      }
+      if (!key) {
+        return key;
+      }
+      modifierKeyMap = platform === 'darwin' ? macModifierKeyMap : nonMacModifierKeyMap;
+      if (modifierKeyMap[key]) {
+        return modifierKeyMap[key];
+      } else if (key.length === 1 && (shiftKeyMap[key] != null)) {
+        return [modifierKeyMap.shift, shiftKeyMap[key]];
+      } else if (key.length === 1 && key === key.toUpperCase() && key.toUpperCase() !== key.toLowerCase()) {
+        return [modifierKeyMap.shift, key.toUpperCase()];
+      } else if (key.length === 1 || /f[0-9]{1,2}/.test(key)) {
+        return key.toUpperCase();
+      } else {
+        if (platform === 'darwin') {
+          return key;
+        } else {
+          return plus.capitalize(key);
+        }
+      }
+    },
+    humanizeKeystroke: function(keystroke, platform) {
+      var humanizedKeystrokes, index, key, keys, keystrokes, splitKeystroke, _i, _j, _len, _len1;
+      if (platform == null) {
+        platform = process.platform;
+      }
+      if (!keystroke) {
+        return keystroke;
+      }
+      keystrokes = keystroke.split(' ');
+      humanizedKeystrokes = [];
+      for (_i = 0, _len = keystrokes.length; _i < _len; _i++) {
+        keystroke = keystrokes[_i];
+        keys = [];
+        splitKeystroke = keystroke.split('-');
+        for (index = _j = 0, _len1 = splitKeystroke.length; _j < _len1; index = ++_j) {
+          key = splitKeystroke[index];
+          if (key === '' && splitKeystroke[index - 1] === '') {
+            key = '-';
+          }
+          if (key) {
+            keys.push(plus.humanizeKey(key, platform));
+          }
+        }
+        keys = _.uniq(_.flatten(keys));
+        if (platform === 'darwin') {
+          keys = keys.join('');
+        } else {
+          keys = keys.join('+');
+        }
+        humanizedKeystrokes.push(keys);
+      }
+      return humanizedKeystrokes.join(' ');
+    },
+    isSubset: function(potentialSubset, potentialSuperset) {
+      return _.every(potentialSubset, function(element) {
+        return _.include(potentialSuperset, element);
+      });
+    },
+    losslessInvert: function(hash) {
+      var inverted, key, value;
+      inverted = {};
+      for (key in hash) {
+        value = hash[key];
+        if (inverted[value] == null) {
+          inverted[value] = [];
+        }
+        inverted[value].push(key);
+      }
+      return inverted;
+    },
+    mapObject: function(object, iterator) {
+      var key, newObject, value, _i, _len, _ref, _ref1;
+      newObject = {};
+      _ref = Object.keys(object);
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        key = _ref[_i];
+        _ref1 = iterator(key, object[key]), key = _ref1[0], value = _ref1[1];
+        newObject[key] = value;
+      }
+      return newObject;
+    },
+    multiplyString: function(string, n) {
+      var finalString, i;
+      finalString = "";
+      i = 0;
+      while (i < n) {
+        finalString += string;
+        i++;
+      }
+      return finalString;
+    },
+    pluralize: function(count, singular, plural) {
+      if (count == null) {
+        count = 0;
+      }
+      if (plural == null) {
+        plural = singular + 's';
+      }
+      if (count === 1) {
+        return "" + count + " " + singular;
+      } else {
+        return "" + count + " " + plural;
+      }
+    },
+    remove: function(array, element) {
+      var index;
+      index = array.indexOf(element);
+      if (index >= 0) {
+        array.splice(index, 1);
+      }
+      return array;
+    },
+    setValueForKeyPath: function(object, keyPath, value) {
+      var key, keys;
+      keys = splitKeyPath(keyPath);
+      while (keys.length > 1) {
+        key = keys.shift();
+        if (object[key] == null) {
+          object[key] = {};
+        }
+        object = object[key];
+      }
+      if (value != null) {
+        return object[keys.shift()] = value;
+      } else {
+        return delete object[keys.shift()];
+      }
+    },
+    hasKeyPath: function(object, keyPath) {
+      var key, keys, _i, _len;
+      keys = splitKeyPath(keyPath);
+      for (_i = 0, _len = keys.length; _i < _len; _i++) {
+        key = keys[_i];
+        if (!object.hasOwnProperty(key)) {
+          return false;
+        }
+        object = object[key];
+      }
+      return true;
+    },
+    spliceWithArray: function(originalArray, start, length, insertedArray, chunkSize) {
+      var chunkStart, _i, _ref, _results;
+      if (chunkSize == null) {
+        chunkSize = 100000;
+      }
+      if (insertedArray.length < chunkSize) {
+        return originalArray.splice.apply(originalArray, [start, length].concat(__slice.call(insertedArray)));
+      } else {
+        originalArray.splice(start, length);
+        _results = [];
+        for (chunkStart = _i = 0, _ref = insertedArray.length; chunkSize > 0 ? _i <= _ref : _i >= _ref; chunkStart = _i += chunkSize) {
+          _results.push(originalArray.splice.apply(originalArray, [start + chunkStart, 0].concat(__slice.call(insertedArray.slice(chunkStart, chunkStart + chunkSize)))));
+        }
+        return _results;
+      }
+    },
+    sum: function(array) {
+      var elt, sum, _i, _len;
+      sum = 0;
+      for (_i = 0, _len = array.length; _i < _len; _i++) {
+        elt = array[_i];
+        sum += elt;
+      }
+      return sum;
+    },
+    uncamelcase: function(string) {
+      var result;
+      if (!string) {
+        return '';
+      }
+      result = string.replace(/([A-Z])|_+/g, function(match, letter) {
+        if (letter == null) {
+          letter = '';
+        }
+        return " " + letter;
+      });
+      return plus.capitalize(result.trim());
+    },
+    undasherize: function(string) {
+      if (string) {
+        return string.split('-').map(plus.capitalize).join(' ');
+      } else {
+        return '';
+      }
+    },
+    underscore: function(string) {
+      if (!string) {
+        return '';
+      }
+      string = string[0].toLowerCase() + string.slice(1);
+      return string.replace(/([A-Z])|-+/g, function(match, letter) {
+        if (letter == null) {
+          letter = '';
+        }
+        return "_" + (letter.toLowerCase());
+      });
+    },
+    valueForKeyPath: function(object, keyPath) {
+      var key, keys, _i, _len;
+      keys = splitKeyPath(keyPath);
+      for (_i = 0, _len = keys.length; _i < _len; _i++) {
+        key = keys[_i];
+        object = object[key];
+        if (object == null) {
+          return;
+        }
+      }
+      return object;
+    },
+    isEqual: function(a, b, aStack, bStack) {
+      if (_.isArray(aStack) && _.isArray(bStack)) {
+        return isEqual(a, b, aStack, bStack);
+      } else {
+        return isEqual(a, b);
+      }
+    },
+    isEqualForProperties: function() {
+      var a, b, properties, property, _i, _len;
+      a = arguments[0], b = arguments[1], properties = 3 <= arguments.length ? __slice.call(arguments, 2) : [];
+      for (_i = 0, _len = properties.length; _i < _len; _i++) {
+        property = properties[_i];
+        if (!_.isEqual(a[property], b[property])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  };
+
+  isEqual = function(a, b, aStack, bStack) {
+    var aCtor, aCtorValid, aElement, aKeyCount, aValue, bCtor, bCtorValid, bKeyCount, bValue, equal, i, key, stackIndex, _i, _len;
+    if (aStack == null) {
+      aStack = [];
+    }
+    if (bStack == null) {
+      bStack = [];
+    }
+    if (a === b) {
+      return _.isEqual(a, b);
+    }
+    if (_.isFunction(a) || _.isFunction(b)) {
+      return _.isEqual(a, b);
+    }
+    stackIndex = aStack.length;
+    while (stackIndex--) {
+      if (aStack[stackIndex] === a) {
+        return bStack[stackIndex] === b;
+      }
+    }
+    aStack.push(a);
+    bStack.push(b);
+    equal = false;
+    if (_.isFunction(a != null ? a.isEqual : void 0)) {
+      equal = a.isEqual(b, aStack, bStack);
+    } else if (_.isFunction(b != null ? b.isEqual : void 0)) {
+      equal = b.isEqual(a, bStack, aStack);
+    } else if (_.isArray(a) && _.isArray(b) && a.length === b.length) {
+      equal = true;
+      for (i = _i = 0, _len = a.length; _i < _len; i = ++_i) {
+        aElement = a[i];
+        if (!isEqual(aElement, b[i], aStack, bStack)) {
+          equal = false;
+          break;
+        }
+      }
+    } else if (_.isRegExp(a) && _.isRegExp(b)) {
+      equal = _.isEqual(a, b);
+    } else if (_.isElement(a) && _.isElement(b)) {
+      equal = a === b;
+    } else if (_.isObject(a) && _.isObject(b)) {
+      aCtor = a.constructor;
+      bCtor = b.constructor;
+      aCtorValid = _.isFunction(aCtor) && aCtor instanceof aCtor;
+      bCtorValid = _.isFunction(bCtor) && bCtor instanceof bCtor;
+      if (aCtor !== bCtor && !(aCtorValid && bCtorValid)) {
+        equal = false;
+      } else {
+        aKeyCount = 0;
+        equal = true;
+        for (key in a) {
+          aValue = a[key];
+          if (!_.has(a, key)) {
+            continue;
+          }
+          aKeyCount++;
+          if (!(_.has(b, key) && isEqual(aValue, b[key], aStack, bStack))) {
+            equal = false;
+            break;
+          }
+        }
+        if (equal) {
+          bKeyCount = 0;
+          for (key in b) {
+            bValue = b[key];
+            if (_.has(b, key)) {
+              bKeyCount++;
+            }
+          }
+          equal = aKeyCount === bKeyCount;
+        }
+      }
+    } else {
+      equal = _.isEqual(a, b);
+    }
+    aStack.pop();
+    bStack.pop();
+    return equal;
+  };
+
+  module.exports = _.extend({}, _, plus);
+
+}).call(this);

node_modules/fs-plus/node_modules/underscore-plus/node_modules/underscore/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative
+Reporters & Editors
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

node_modules/fs-plus/node_modules/underscore-plus/node_modules/underscore/README.md

@@ -0,0 +1,22 @@
+                       __
+                      /\ \                                                         __
+     __  __    ___    \_\ \     __   _ __   ____    ___    ___   _ __    __       /\_\    ____
+    /\ \/\ \ /' _ `\  /'_  \  /'__`\/\  __\/ ,__\  / ___\ / __`\/\  __\/'__`\     \/\ \  /',__\
+    \ \ \_\ \/\ \/\ \/\ \ \ \/\  __/\ \ \//\__, `\/\ \__//\ \ \ \ \ \//\  __/  __  \ \ \/\__, `\
+     \ \____/\ \_\ \_\ \___,_\ \____\\ \_\\/\____/\ \____\ \____/\ \_\\ \____\/\_\ _\ \ \/\____/
+      \/___/  \/_/\/_/\/__,_ /\/____/ \/_/ \/___/  \/____/\/___/  \/_/ \/____/\/_//\ \_\ \/___/
+                                                                                  \ \____/
+                                                                                   \/___/
+
+Underscore.js is a utility-belt library for JavaScript that provides
+support for the usual functional suspects (each, map, reduce, filter...)
+without extending any core JavaScript objects.
+
+For Docs, License, Tests, and pre-packed downloads, see:
+http://underscorejs.org
+
+Underscore is an open-sourced component of DocumentCloud:
+https://github.com/documentcloud
+
+Many thanks to our contributors:
+https://github.com/jashkenas/underscore/contributors

node_modules/fs-plus/node_modules/underscore-plus/node_modules/underscore/package.json

@@ -0,0 +1,71 @@
+{
+  "_from": "underscore@>=1.6.0 <1.7.0",
+  "_id": "underscore@1.6.0",
+  "_inBundle": false,
+  "_integrity": "sha512-z4o1fvKUojIWh9XuaVLUDdf86RQiq13AC1dmHbTpoyuu+bquHms76v16CjycCbec87J7z0k//SiQVk0sMdFmpQ==",
+  "_location": "/fs-plus/underscore-plus/underscore",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "underscore@1.6.0",
+    "name": "underscore",
+    "escapedName": "underscore",
+    "rawSpec": "1.6.0",
+    "saveSpec": null,
+    "fetchSpec": "1.6.0"
+  },
+  "_requiredBy": [
+    "/fs-plus/underscore-plus"
+  ],
+  "_resolved": "https://registry.npmjs.org/underscore/-/underscore-1.6.0.tgz",
+  "_shasum": "8b38b10cacdef63337b8b24e4ff86d45aea529a8",
+  "_spec": "underscore@1.6.0",
+  "_where": "/tmp/jibo-npm/jibo-cli-3.0.7",
+  "author": {
+    "name": "Jeremy Ashkenas",
+    "email": "jeremy@documentcloud.org"
+  },
+  "bugs": {
+    "url": "https://github.com/jashkenas/underscore/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "JavaScript's functional programming helper library.",
+  "devDependencies": {
+    "docco": "0.6.x",
+    "phantomjs": "1.9.0-1",
+    "uglify-js": "2.4.x"
+  },
+  "files": [
+    "underscore.js",
+    "underscore-min.js",
+    "LICENSE"
+  ],
+  "homepage": "http://underscorejs.org",
+  "keywords": [
+    "util",
+    "functional",
+    "server",
+    "client",
+    "browser"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://raw.github.com/jashkenas/underscore/master/LICENSE"
+    }
+  ],
+  "main": "underscore.js",
+  "name": "underscore",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jashkenas/underscore.git"
+  },
+  "scripts": {
+    "build": "uglifyjs underscore.js -c \"evaluate=false\" --comments \"/    .*/\" -m --source-map underscore-min.map -o underscore-min.js",
+    "doc": "docco underscore.js",
+    "test": "phantomjs test/vendor/runner.js test/index.html?noglobals=true"
+  },
+  "version": "1.6.0"
+}

node_modules/fs-plus/node_modules/underscore-plus/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "underscore-plus@>=1.0.0 <2.0.0",
+  "_id": "underscore-plus@1.6.6",
+  "_inBundle": false,
+  "_integrity": "sha512-lI/HthOwH141O9ftoQlox6hBeRk52PCdmGFaf3wf52mudh30fmBtMTT8Dfsl6AsvgsO6uBkUr0tYBJxdlz4OMQ==",
+  "_location": "/fs-plus/underscore-plus",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "underscore-plus@1.6.6",
+    "name": "underscore-plus",
+    "escapedName": "underscore-plus",
+    "rawSpec": "1.6.6",
+    "saveSpec": null,
+    "fetchSpec": "1.6.6"
+  },
+  "_requiredBy": [
+    "/fs-plus"
+  ],
+  "_resolved": "https://registry.npmjs.org/underscore-plus/-/underscore-plus-1.6.6.tgz",
+  "_shasum": "65ecde1bdc441a35d89e650fd70dcf13ae439a7d",
+  "_spec": "underscore-plus@1.6.6",
+  "_where": "/tmp/jibo-npm/jibo-cli-3.0.7",
+  "bugs": {
+    "url": "https://github.com/atom/underscore-plus/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "underscore": "~1.6.0"
+  },
+  "deprecated": false,
+  "description": "Underscore plus additional utilities",
+  "devDependencies": {
+    "grunt": "~0.4.1",
+    "grunt-cli": "~0.1.8",
+    "grunt-coffeelint": "0.0.6",
+    "grunt-contrib-coffee": "~0.9.0",
+    "grunt-shell": "~0.2.2",
+    "jasmine-focused": "1.x",
+    "rimraf": "~2.1.4",
+    "temp": "~0.5.0"
+  },
+  "homepage": "http://atom.github.io/underscore-plus",
+  "keywords": [
+    "underscore"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/atom/underscore-plus/raw/master/LICENSE.md"
+    }
+  ],
+  "main": "./lib/underscore-plus.js",
+  "name": "underscore-plus",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atom/underscore-plus.git"
+  },
+  "scripts": {
+    "prepublish": "grunt clean coffee lint",
+    "test": "grunt test"
+  },
+  "version": "1.6.6"
+}

node_modules/fs-plus/package.json

@@ -0,0 +1,63 @@
+{
+  "_from": "fs-plus@>=2.7.1 <3.0.0",
+  "_id": "fs-plus@2.9.3",
+  "_inBundle": false,
+  "_integrity": "sha512-6Kr+O68rqBWbY1pGuE+mSn9lbUdYfNa7YeFZr+rOIEKfZSxMVQRFr4ARGV5duz7F8et+DHOf1ZJ5MaK9hNMoJw==",
+  "_location": "/fs-plus",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "fs-plus@2.9.3",
+    "name": "fs-plus",
+    "escapedName": "fs-plus",
+    "rawSpec": "2.9.3",
+    "saveSpec": null,
+    "fetchSpec": "2.9.3"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/fs-plus/-/fs-plus-2.9.3.tgz",
+  "_shasum": "75e6d7c57e45364955a1cfbfc563fc5820e0cff2",
+  "_spec": "fs-plus@2.9.3",
+  "_where": "/tmp/jibo-npm/jibo-cli-3.0.7",
+  "bugs": {
+    "url": "https://github.com/atom/fs-plus/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "async": "~0.2.9",
+    "mkdirp": "~0.3.5",
+    "rimraf": "~2.2.2",
+    "underscore-plus": "1.x"
+  },
+  "deprecated": false,
+  "description": "node's fs with more helpers",
+  "devDependencies": {
+    "grunt": "~0.4.1",
+    "grunt-cli": "~0.1.8",
+    "grunt-coffeelint": "0.0.6",
+    "grunt-contrib-coffee": "~0.9.0",
+    "grunt-shell": "~0.2.2",
+    "jasmine-focused": "1.x",
+    "temp": "~0.8.1"
+  },
+  "homepage": "http://atom.github.io/fs-plus",
+  "keywords": [
+    "fs",
+    "filesystem"
+  ],
+  "license": "MIT",
+  "main": "./lib/fs-plus.js",
+  "name": "fs-plus",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atom/fs-plus.git"
+  },
+  "scripts": {
+    "prepublish": "grunt prepublish",
+    "test": "grunt test"
+  },
+  "version": "2.9.3"
+}